🎉 init: 小龙的工作空间

2026-06-06 10:40:48 +08:00
commit a188ee1426
3201 changed files with 231817 additions and 0 deletions
@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * Guard 4: MEMORY.md Direct Write Guard
+ * Prevents new code from writing directly to MEMORY.md.
+ * 
+ * → Architecture Freeze v2 (PR-1): docs/architecture-freeze-v2.md
+ * → Forbidden Addition §6.6: 禁止直接写 MEMORY.md
+ * 
+ * Only allowed writers (whitelisted):
+ *   - session-memory hook (bundled/session-memory)
+ *   - memory-core dreaming (extensions/memory-core)
+ *   - memory-core manager (extensions/memory-core)
+ *   - openclaw CLI (memory promote/write)
+ * 
+ * FAIL: new code path writes to MEMORY.md
+ */
+
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+
+const OPENCLAW_HOME = process.env.OPENCLAW_HOME || "/opt/homebrew/lib/node_modules/openclaw";
+const DIST_DIR = join(OPENCLAW_HOME, "dist");
+const WORKSPACE = join(homedir(), ".openclaw", "workspace");
+
+// Known/allowed MEMORY.md writers
+const ALLOWED_MEMORY_MD_WRITERS = new Set([
+  "memory-core",
+  "memory-wiki",
+  "active-memory",  // writes to prompt, not MEMORY.md directly
+]);
+
+function guardMemoryDirectWrite() {
+  const issues = [];
+  const foundWriters = [];
+
+  // Search JS files in dist for MEMORY.md write references
+  // We grep for patterns that write to MEMORY.md
+  const searchPatterns = [
+    "MEMORY.md",
+    "'MEMORY.md'",
+    '"MEMORY.md"',
+  ];
+
+  try {
+    // Use grep to find references to MEMORY.md in dist JS files
+    const grepResult = execSync(
+      `grep -rl "MEMORY.md" "${DIST_DIR}" 2>/dev/null | grep -v ".d.ts$" | grep -v "node_modules" | grep -v ".json$" | head -50`,
+      { timeout: 30000, encoding: "utf8", maxBuffer: 10 * 1024 * 1024 }
+    ).trim();
+
+    if (grepResult) {
+      const files = grepResult.split("\n").filter(Boolean);
+      for (const file of files) {
+        const relativePath = file.replace(DIST_DIR + "/", "");
+        
+        // Determine which module this belongs to
+        let module = "unknown";
+        if (relativePath.includes("memory-core")) module = "memory-core";
+        else if (relativePath.includes("memory-wiki")) module = "memory-wiki";
+        else if (relativePath.includes("memory-lancedb")) module = "memory-lancedb";
+        else if (relativePath.includes("active-memory")) module = "active-memory";
+        else if (relativePath.includes("bundled/session-memory")) module = "bundled/session-memory";
+        else if (relativePath.includes("bundle")) module = "bundled";
+        else if (relativePath.includes("cli")) module = "cli";
+        else module = relativePath.split("/")[0] || "unknown";
+
+        foundWriters.push({ file: relativePath, module });
+      }
+    }
+  } catch (e) {
+    // grep returns exit 1 if no matches found — that's OK
+    if (e.status !== 1) {
+      issues.push({ level: "WARN", msg: `grep error: ${e.message}` });
+    }
+  }
+
+  // Group by module
+  const moduleGroups = {};
+  for (const w of foundWriters) {
+    if (!moduleGroups[w.module]) moduleGroups[w.module] = [];
+    moduleGroups[w.module].push(w.file);
+  }
+
+  const knownModules = new Set(Object.keys(moduleGroups));
+
+  console.log("");
+  console.log("═══════════════════════════════════════");
+  console.log("  Guard 4: MEMORY.md Direct Write Guard");
+  console.log("═══════════════════════════════════════");
+  console.log("");
+
+  console.log(`  Modules referencing MEMORY.md: ${knownModules.size}`);
+  for (const [mod, files] of Object.entries(moduleGroups)) {
+    const status = ALLOWED_MEMORY_MD_WRITERS.has(mod) ? "✓ allowed" : "⚠ unknown";
+    console.log(`    ${status} ${mod} (${files.length} files)`);
+    if (files.length <= 3) {
+      for (const f of files) {
+        console.log(`      - ${f}`);
+      }
+    }
+  }
+
+  // Check for unexpected writers
+  const unexpectedModules = [...knownModules].filter(m => !ALLOWED_MEMORY_MD_WRITERS.has(m));
+  
+  if (unexpectedModules.length > 0) {
+    console.log("");
+    for (const mod of unexpectedModules) {
+      // some modules like "bundled" are expected to reference MEMORY.md for reading
+      // Only flag as WARN if they might be writing
+      issues.push({
+        level: "WARN",
+        msg: `Module "${mod}" references MEMORY.md — verify it's read-only`
+      });
+    }
+  }
+
+  console.log("");
+  const failIssues = issues.filter(i => i.level === "FAIL");
+  const warnIssues = issues.filter(i => i.level === "WARN");
+  
+  if (failIssues.length > 0) {
+    for (const issue of failIssues) {
+      console.log(`  [FAIL] ${issue.msg}`);
+    }
+    console.log("  ✗ FAIL: new direct MEMORY.md writer(s) detected");
+    process.exit(1);
+  } else {
+    if (warnIssues.length > 0) {
+      for (const issue of warnIssues) {
+        console.log(`  [WARN] ${issue.msg}`);
+      }
+    }
+    console.log("  ✓ PASS: MEMORY.md direct write paths unchanged");
+    process.exit(0);
+  }
+}
+
+guardMemoryDirectWrite();