@cleocode/cleo 2026.4.55 → 2026.4.57

package/dist/cli/index.js

@@ -9508,6 +9508,12 @@ var init_brain_schema = __esm({
       // observation → references → symbol
       "modified_by",
       // file → modified_by → session
+      "code_reference",
+      // memory node → code_reference → nexus symbol/file (T645)
+      "affects",
+      // observation → affects → symbol/file (impact tracking)
+      "mentions",
+      // observation → mentions → symbol name (weak reference)
       // Plasticity (Hebbian + STDP co-retrieval)
       "co_retrieved"
       // A → co_retrieved → B (Hebbian: frequently retrieved together)
@@ -45910,7 +45916,9 @@ var init_edge_types = __esm({
       // Observation → symbol name mention
       MENTIONS: "mentions",
       // Observation → symbol/file structural link
-      DOCUMENTS: "documents"
+      DOCUMENTS: "documents",
+      // Memory node → nexus symbol/file (T645)
+      CODE_REFERENCE: "code_reference"
     };
   }
 });
@@ -88221,7 +88229,6 @@ var init_cleo = __esm({
 // packages/core/src/index.ts
 var init_src3 = __esm({
   "packages/core/src/index.ts"() {
-    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -141321,6 +141328,495 @@ function registerNexusCommand(program) {
         );
       } else {
         process.stderr.write(`[nexus] Error: ${msg}
+`);
+      }
+      process.exitCode = 1;
+    }
+  });
+  projects.command("scan").description(
+    "Walk filesystem roots to discover .cleo/ directories not registered in the global nexus registry"
+  ).option(
+    "--roots <paths>",
+    "Comma-separated search roots (default: ~/code,~/projects,/mnt/projects)"
+  ).option("--max-depth <n>", "Maximum directory traversal depth (default: 4)", parseInt, 4).option("--auto-register", "Register all discovered unregistered projects automatically").option("--include-existing", "Also report projects that are already registered").option("--json", "Output as JSON (LAFS envelope format)").action(async (opts) => {
+    const startTime = Date.now();
+    const jsonOutput = !!opts["json"];
+    const autoRegister = !!opts["autoRegister"];
+    const includeExisting = !!opts["includeExisting"];
+    const maxDepth = Math.max(1, Math.min(opts["maxDepth"] ?? 4, 20));
+    const { homedir: homedir8 } = await import("node:os");
+    const home = homedir8();
+    const defaultRoots = [path10.join(home, "code"), path10.join(home, "projects"), "/mnt/projects"];
+    const rawRoots = typeof opts["roots"] === "string" && opts["roots"].trim().length > 0 ? opts["roots"].split(",").map((r) => r.trim()).filter((r) => r.length > 0).map(
+      (r) => r.startsWith("~") ? path10.join(home, r.slice(1)) : path10.resolve(r)
+    ) : defaultRoots;
+    const { existsSync: existsSync135, readdirSync: readdirSync42, statSync: statSync22 } = await import("node:fs");
+    const { Dirent } = await import("node:fs");
+    const roots = rawRoots.filter((r) => {
+      try {
+        return existsSync135(r) && statSync22(r).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    if (!jsonOutput) {
+      process.stdout.write(
+        `[nexus] Scanning ${roots.length} root(s) up to depth ${maxDepth}:
+` + roots.map((r) => `  ${r}`).join("\n") + "\n"
+      );
+    }
+    const SKIP_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      "target",
+      // Rust build
+      "dist",
+      "build",
+      ".svelte-kit",
+      ".next",
+      ".cache",
+      "coverage",
+      ".turbo",
+      ".nx",
+      "__pycache__",
+      ".venv",
+      "venv",
+      ".tox",
+      "vendor"
+    ]);
+    function getDevice(p2) {
+      try {
+        return statSync22(p2).dev;
+      } catch {
+        return -1;
+      }
+    }
+    function walkForCleo(dir, depth, rootDev) {
+      if (depth > maxDepth) return [];
+      let entries;
+      try {
+        entries = readdirSync42(dir, { withFileTypes: true });
+      } catch {
+        return [];
+      }
+      const found = [];
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.isSymbolicLink()) continue;
+        const fullPath = path10.join(dir, entry.name);
+        if (entry.name === ".cleo") {
+          found.push(dir);
+          continue;
+        }
+        if (SKIP_DIRS.has(entry.name)) continue;
+        const childDev = getDevice(fullPath);
+        if (childDev !== rootDev && childDev !== -1) continue;
+        const nested = walkForCleo(fullPath, depth + 1, rootDev);
+        for (const n of nested) found.push(n);
+      }
+      return found;
+    }
+    const allCandidates = [];
+    for (const root of roots) {
+      const rootDev = getDevice(root);
+      const found = walkForCleo(root, 0, rootDev);
+      for (const f2 of found) allCandidates.push(f2);
+    }
+    const candidates = [...new Set(allCandidates)];
+    let registeredPaths = /* @__PURE__ */ new Set();
+    try {
+      const { nexusList: listProjects } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+      const projects2 = await listProjects();
+      for (const p2 of projects2) {
+        registeredPaths.add(path10.resolve(p2.path));
+      }
+    } catch {
+      registeredPaths = /* @__PURE__ */ new Set();
+    }
+    const unregistered = [];
+    const registered = [];
+    for (const candidate of candidates) {
+      const resolved = path10.resolve(candidate);
+      if (registeredPaths.has(resolved)) {
+        registered.push(resolved);
+      } else {
+        unregistered.push(resolved);
+      }
+    }
+    const tally = {
+      total: candidates.length,
+      unregistered: unregistered.length,
+      registered: registered.length
+    };
+    const autoRegistered = [];
+    const autoRegisterErrors = [];
+    if (autoRegister && unregistered.length > 0) {
+      const { nexusRegister: doRegister } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+      for (const projectPath of unregistered) {
+        try {
+          await doRegister(projectPath);
+          autoRegistered.push(projectPath);
+        } catch (err) {
+          autoRegisterErrors.push({
+            path: projectPath,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
+    try {
+      const { getNexusDb: getNexusDb2 } = await import("@cleocode/core/store/nexus-sqlite");
+      const { nexusAuditLog: auditTable } = await import("@cleocode/core/store/nexus-schema");
+      const { randomUUID: randomUUID15 } = await import("node:crypto");
+      const db = await getNexusDb2();
+      await db.insert(auditTable).values({
+        id: randomUUID15(),
+        action: "projects.scan",
+        domain: "nexus",
+        operation: "projects.scan",
+        success: 1,
+        detailsJson: JSON.stringify({
+          roots,
+          found: candidates.length,
+          unregistered: unregistered.length,
+          registered: registered.length,
+          autoRegistered: autoRegistered.length
+        })
+      });
+    } catch {
+    }
+    const durationMs = Date.now() - startTime;
+    if (jsonOutput) {
+      const data = {
+        roots,
+        unregistered,
+        tally
+      };
+      if (includeExisting) data["registered"] = registered;
+      if (autoRegister) {
+        data["autoRegistered"] = autoRegistered;
+        data["autoRegisterErrors"] = autoRegisterErrors;
+      }
+      process.stdout.write(
+        JSON.stringify(
+          {
+            success: true,
+            data,
+            meta: {
+              operation: "nexus.projects.scan",
+              duration_ms: durationMs,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          },
+          null,
+          2
+        ) + "\n"
+      );
+    } else {
+      process.stdout.write(
+        `
+[nexus] Scan complete \u2014 ${tally.total} project(s) found (${tally.unregistered} unregistered, ${tally.registered} registered)
+`
+      );
+      if (unregistered.length > 0) {
+        process.stdout.write("\n  Unregistered:\n");
+        for (const p2 of unregistered) {
+          process.stdout.write(`    ${p2}
+`);
+        }
+        if (!autoRegister) {
+          process.stdout.write(
+            "\n  Tip: run with --auto-register to register all of the above.\n"
+          );
+        }
+      }
+      if (includeExisting && registered.length > 0) {
+        process.stdout.write("\n  Already registered:\n");
+        for (const p2 of registered) {
+          process.stdout.write(`    ${p2}
+`);
+        }
+      }
+      if (autoRegister) {
+        process.stdout.write(
+          `
+  Auto-registered: ${autoRegistered.length} project(s)` + (autoRegisterErrors.length > 0 ? `, ${autoRegisterErrors.length} failed` : "") + "\n"
+        );
+        for (const e of autoRegisterErrors) {
+          process.stdout.write(`    FAILED ${e.path}: ${e.error}
+`);
+        }
+      }
+    }
+  });
+  projects.command("clean").description(
+    "Bulk purge project_registry rows matching path criteria (requires at least one filter flag)"
+  ).option("--dry-run", "List matching projects without deleting anything").option("--pattern <regex>", "JS regex matched against project_path").option("--include-temp", "Preset: match paths containing a .temp/ segment").option(
+    "--include-tests",
+    "Preset: match paths containing tmp/test/fixture/scratch/sandbox segments"
+  ).option("--unhealthy", 'Also match rows where health_status is "unhealthy"').option("--never-indexed", "Also match rows where last_indexed IS NULL").option("--yes", "Skip confirmation prompt (still shows preview)").option("--json", "Output as JSON (LAFS envelope format)").action(async (opts) => {
+    const startTime = Date.now();
+    const jsonOutput = !!opts["json"];
+    const dryRun = !!opts["dryRun"];
+    const skipPrompt = !!opts["yes"];
+    const patternRaw = opts["pattern"];
+    const includeTemp = !!opts["includeTemp"];
+    const includeTests = !!opts["includeTests"];
+    const matchUnhealthy = !!opts["unhealthy"];
+    const matchNeverIndexed = !!opts["neverIndexed"];
+    const hasCriteria = patternRaw !== void 0 || includeTemp || includeTests || matchUnhealthy || matchNeverIndexed;
+    if (!hasCriteria) {
+      const errMsg = "No filter criteria provided. Refusing to purge all projects without explicit criteria.\nUse at least one of: --pattern <regex>, --include-temp, --include-tests, --unhealthy, --never-indexed";
+      if (jsonOutput) {
+        process.stdout.write(
+          JSON.stringify(
+            {
+              success: false,
+              error: { code: "E_NO_CRITERIA", message: errMsg },
+              meta: {
+                operation: "nexus.projects.clean",
+                duration_ms: Date.now() - startTime,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            },
+            null,
+            2
+          ) + "\n"
+        );
+      } else {
+        process.stderr.write(`[nexus] Error: ${errMsg}
+`);
+      }
+      process.exitCode = 6;
+      return;
+    }
+    let patternRegex = null;
+    if (patternRaw !== void 0) {
+      try {
+        patternRegex = new RegExp(patternRaw);
+      } catch (err) {
+        const msg = `Invalid --pattern regex: ${err instanceof Error ? err.message : String(err)}`;
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify(
+              {
+                success: false,
+                error: { code: "E_INVALID_PATTERN", message: msg },
+                meta: {
+                  operation: "nexus.projects.clean",
+                  duration_ms: Date.now() - startTime,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                }
+              },
+              null,
+              2
+            ) + "\n"
+          );
+        } else {
+          process.stderr.write(`[nexus] Error: ${msg}
+`);
+        }
+        process.exitCode = 6;
+        return;
+      }
+    }
+    const TEMP_RE = /(^|\/)\.temp(\/|$)/;
+    const TESTS_RE = /(^|\/)(tmp|test|fixture|scratch|sandbox)(\/|$)/;
+    function matchesCriteria(projectPath, healthStatus, lastIndexed) {
+      if (patternRegex?.test(projectPath)) return true;
+      if (includeTemp && TEMP_RE.test(projectPath)) return true;
+      if (includeTests && TESTS_RE.test(projectPath)) return true;
+      if (matchUnhealthy && healthStatus === "unhealthy") return true;
+      if (matchNeverIndexed && lastIndexed === null) return true;
+      return false;
+    }
+    try {
+      const { getNexusDb: getNexusDb2 } = await import("@cleocode/core/store/nexus-sqlite");
+      const { projectRegistry: regTable, nexusAuditLog: auditTable } = await import("@cleocode/core/store/nexus-schema");
+      const { randomUUID: randomUUID15 } = await import("node:crypto");
+      const { inArray: inArray8 } = await import("drizzle-orm");
+      const db = await getNexusDb2();
+      const allRows = await db.select({
+        projectId: regTable.projectId,
+        projectPath: regTable.projectPath,
+        healthStatus: regTable.healthStatus,
+        lastIndexed: regTable.lastIndexed
+      }).from(regTable);
+      const matches = allRows.filter(
+        (row) => matchesCriteria(row.projectPath, row.healthStatus, row.lastIndexed)
+      );
+      const totalCount = allRows.length;
+      const matchCount = matches.length;
+      const samplePaths = matches.slice(0, 10).map((r) => r.projectPath);
+      if (!jsonOutput) {
+        process.stdout.write(
+          `[nexus] Clean preview \u2014 ${matchCount} project(s) of ${totalCount} total match criteria:
+`
+        );
+        if (matchCount === 0) {
+          process.stdout.write("  (no matches)\n");
+        } else {
+          for (const p2 of samplePaths) {
+            process.stdout.write(`  ${p2}
+`);
+          }
+          if (matchCount > 10) {
+            process.stdout.write(`  ... and ${matchCount - 10} more
+`);
+          }
+        }
+      }
+      if (matchCount === 0) {
+        const durationMs2 = Date.now() - startTime;
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify(
+              {
+                success: true,
+                data: {
+                  dryRun,
+                  matched: 0,
+                  purged: 0,
+                  remaining: totalCount,
+                  sample: []
+                },
+                meta: {
+                  operation: "nexus.projects.clean",
+                  duration_ms: durationMs2,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                }
+              },
+              null,
+              2
+            ) + "\n"
+          );
+        }
+        return;
+      }
+      if (dryRun) {
+        const durationMs2 = Date.now() - startTime;
+        if (jsonOutput) {
+          process.stdout.write(
+            JSON.stringify(
+              {
+                success: true,
+                data: {
+                  dryRun: true,
+                  matched: matchCount,
+                  purged: 0,
+                  remaining: totalCount,
+                  sample: samplePaths
+                },
+                meta: {
+                  operation: "nexus.projects.clean",
+                  duration_ms: durationMs2,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                }
+              },
+              null,
+              2
+            ) + "\n"
+          );
+        } else {
+          process.stdout.write(
+            `[nexus] Dry-run \u2014 ${matchCount} project(s) would be purged. Rerun without --dry-run to delete.
+`
+          );
+        }
+        return;
+      }
+      if (!skipPrompt) {
+        const { createInterface: createInterface3 } = await import("node:readline");
+        const rl = createInterface3({ input: process.stdin, output: process.stdout });
+        const confirmed = await new Promise((resolve17) => {
+          rl.question(
+            `
+[nexus] Delete ${matchCount} project(s) from the registry? [y/N] `,
+            (answer) => {
+              rl.close();
+              resolve17(answer.trim().toLowerCase() === "y");
+            }
+          );
+        });
+        if (!confirmed) {
+          process.stdout.write("[nexus] Aborted \u2014 no projects deleted.\n");
+          return;
+        }
+      }
+      const idsToDelete = matches.map((r) => r.projectId);
+      await db.delete(regTable).where(inArray8(regTable.projectId, idsToDelete));
+      const remaining = totalCount - matchCount;
+      try {
+        await db.insert(auditTable).values({
+          id: randomUUID15(),
+          action: "projects.clean",
+          domain: "nexus",
+          operation: "projects.clean",
+          success: 1,
+          detailsJson: JSON.stringify({
+            pattern: patternRaw ?? null,
+            presets: {
+              includeTemp,
+              includeTests,
+              matchUnhealthy,
+              matchNeverIndexed
+            },
+            count: matchCount,
+            sample: samplePaths
+          })
+        });
+      } catch {
+      }
+      const durationMs = Date.now() - startTime;
+      if (jsonOutput) {
+        process.stdout.write(
+          JSON.stringify(
+            {
+              success: true,
+              data: {
+                dryRun: false,
+                matched: matchCount,
+                purged: matchCount,
+                remaining,
+                sample: samplePaths
+              },
+              meta: {
+                operation: "nexus.projects.clean",
+                duration_ms: durationMs,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            },
+            null,
+            2
+          ) + "\n"
+        );
+      } else {
+        process.stdout.write(
+          `[nexus] Purged ${matchCount} project(s). ${remaining} project(s) remaining in registry.
+`
+        );
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const durationMs = Date.now() - startTime;
+      if (jsonOutput) {
+        process.stdout.write(
+          JSON.stringify(
+            {
+              success: false,
+              error: { code: "E_CLEAN_FAILED", message: msg },
+              meta: {
+                operation: "nexus.projects.clean",
+                duration_ms: durationMs,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              }
+            },
+            null,
+            2
+          ) + "\n"
+        );
+      } else {
+        process.stderr.write(`[nexus] Error: ${msg}
 `);
       }
       process.exitCode = 1;