@codyswann/lisa 2.24.0 → 2.25.0

package/plugins/src/wiki/scripts/diff-guard.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+/**
+ * diff-guard.mjs — enforce a connector's touched-file boundary. Dependency-free
+ * (git + Node built-ins).
+ *
+ * Run AFTER a connector returns and BEFORE the kernel synthesizes: a connector may
+ * write ONLY its declared source-note path(s) and run-metadata. Any repo change
+ * outside the allowed globs is a hard failure (this is what makes "source-note only"
+ * enforceable, not aspirational). Writes outside the repo (e.g. external-write to a
+ * remote system) are not git-visible and so are not policed here.
+ *
+ * The change set ALWAYS includes untracked files (connectors create new files), so a
+ * stray new file can never bypass the guard. `--base <ref>` additionally unions a
+ * committed range. Paths are read NUL-safe to handle renames/quoting.
+ *
+ * Usage: node diff-guard.mjs --allow <glob> [--allow <glob>...] [--base <ref>]
+ * Exit 0 = all changes within allowed globs, 1 = out-of-bounds change (or git error).
+ */
+import { execFileSync } from "node:child_process";
+import { globToRegExp } from "./_wiki-lib.mjs";
+
+function fail(msg) {
+  console.error(`✗ ${msg}`);
+  process.exit(1);
+}
+
+const argv = process.argv.slice(2);
+const allows = [];
+let base;
+for (let i = 0; i < argv.length; i += 1) {
+  const a = argv[i];
+  if (a === "--allow") {
+    const v = argv[i + 1];
+    if (!v || v.startsWith("--")) fail("--allow requires a glob argument");
+    allows.push(v);
+    i += 1;
+  } else if (a === "--base") {
+    const v = argv[i + 1];
+    if (!v || v.startsWith("--")) fail("--base requires a ref argument");
+    base = v;
+    i += 1;
+  } else {
+    fail(`unknown argument: ${a}`);
+  }
+}
+
+if (allows.length === 0) {
+  fail(
+    "diff-guard requires at least one --allow <glob> (the connector's permitted paths)"
+  );
+}
+
+function git(args) {
+  return execFileSync("git", args, { encoding: "utf8" });
+}
+
+let repoRoot;
+try {
+  repoRoot = git(["rev-parse", "--show-toplevel"]).trim();
+} catch {
+  fail("not inside a git repository");
+}
+const inRepo = args => ["-C", repoRoot, ...args];
+
+// Working-tree change set, NUL-safe, including untracked files. Renames/copies
+// (status starts with R/C) emit the destination then the source as separate NUL
+// records — include both so neither side can slip outside the allow-list.
+function workingTreePaths() {
+  const out = git(
+    inRepo(["status", "--porcelain=v1", "-z", "--untracked-files=all"])
+  );
+  const records = out.split("\0");
+  const paths = [];
+  for (let i = 0; i < records.length; i += 1) {
+    const rec = records[i];
+    if (!rec) continue;
+    const status = rec.slice(0, 2);
+    const p = rec.slice(3);
+    if (p) paths.push(p);
+    if (status[0] === "R" || status[0] === "C") {
+      i += 1;
+      if (records[i]) paths.push(records[i]);
+    }
+  }
+  return paths;
+}
+
+let changed = [];
+try {
+  changed = workingTreePaths();
+  if (base) {
+    changed = changed.concat(
+      git(inRepo(["diff", "--name-only", "-z", base])).split("\0")
+    );
+  }
+} catch (e) {
+  fail(`git failed: ${e.message}`);
+}
+
+changed = [...new Set(changed.map(s => s.trim()).filter(Boolean))];
+const matchers = allows.map(globToRegExp);
+const isAllowed = p => matchers.some(re => re.test(p));
+const violations = changed.filter(p => !isAllowed(p));
+
+if (violations.length > 0) {
+  console.error(
+    `✗ diff-guard: ${violations.length} change(s) outside the allowed connector paths:`
+  );
+  for (const v of violations) console.error(`  - ${v}`);
+  console.error(`  allowed: ${allows.join(", ")}`);
+  process.exit(1);
+}
+
+console.log(
+  `✓ diff-guard: ${changed.length} change(s) all within allowed paths (${allows.join(", ")}).`
+);

package/plugins/src/wiki/scripts/ingest-git.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * ingest-git.mjs — git/PR-history connector. Dependency-free (git + optional gh).
+ * Read-only: it never checks out, fetches, or mutates the target repo.
+ *
+ * Writes a sanitized, dated source note under <source-dir> summarizing commits (and
+ * merged PRs, if `gh` is available) since the cursor, and emits a PROPOSED next cursor
+ * to --emit-meta. It does NOT advance final state — the kernel does that after
+ * verification (per the §7 connector contract).
+ *
+ * Usage:
+ *   node ingest-git.mjs --repo <path> [--slug <name>] [--config <p>]
+ *     [--source-dir <dir>] [--state <file>] [--emit-meta <file>]
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { readJsonSafe, SECRET_PATTERNS } from "./_wiki-lib.mjs";
+
+const argv = process.argv.slice(2);
+const opt = (n, d) => {
+  const i = argv.indexOf(n);
+  return i !== -1 ? argv[i + 1] : d;
+};
+const repo = path.resolve(opt("--repo", "."));
+const slug = opt("--slug", path.basename(repo));
+const githubRepo = opt("--github-repo"); // owner/repo for PR history (else inferred via gh)
+const fileSlug = slug.replace(/[^A-Za-z0-9_.-]+/g, "-"); // safe for filenames
+const sourceDir = path.resolve(opt("--source-dir", "wiki/sources/git"));
+const statePath = opt("--state");
+const emitMeta = opt("--emit-meta");
+
+const fail = m => {
+  console.error(`✗ ${m}`);
+  process.exit(1);
+};
+const git = args =>
+  execFileSync("git", ["-C", repo, ...args], { encoding: "utf8" }).trim();
+const tryGit = args => {
+  try {
+    return git(args);
+  } catch {
+    return "";
+  }
+};
+const commitExists = c => {
+  try {
+    execFileSync("git", ["-C", repo, "cat-file", "-e", `${c}^{commit}`], {
+      stdio: "ignore",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+};
+const redact = t =>
+  SECRET_PATTERNS.reduce(
+    (acc, { re }) => acc.replace(new RegExp(re, "g"), "[REDACTED]"),
+    t
+  );
+
+if (
+  !fs.existsSync(path.join(repo, ".git")) &&
+  !tryGit(["rev-parse", "--is-inside-work-tree"])
+) {
+  fail(`not a git repository: ${repo}`);
+}
+
+const cursor = statePath ? (readJsonSafe(statePath)?.cursor ?? {}) : {};
+const lastCommit = cursor.lastCommit;
+const head = tryGit(["rev-parse", "HEAD"]);
+if (!head) fail("could not resolve HEAD (empty repo?)");
+if (lastCommit && !commitExists(lastCommit)) {
+  fail(
+    `cursor commit ${lastCommit} not found in ${repo}; refusing to silently re-window from HEAD`
+  );
+}
+
+const range = lastCommit ? `${lastCommit}..HEAD` : "HEAD";
+const logLines = tryGit([
+  "log",
+  range,
+  "--pretty=format:%h\t%ad\t%s",
+  "--date=short",
+])
+  .split("\n")
+  .filter(Boolean);
+const totalCommits = Number(tryGit(["rev-list", "--count", "HEAD"]) || "0");
+
+// merged PRs via gh (optional, read-only); resolve the GitHub repo explicitly
+let lastPr = cursor.lastPr ?? null;
+let prSummary = "(no GitHub repo resolved — PR history skipped)";
+let ghRepo = githubRepo;
+if (!ghRepo) {
+  try {
+    ghRepo = execFileSync(
+      "gh",
+      ["repo", "view", "--json", "nameWithOwner", "-q", ".nameWithOwner"],
+      { cwd: repo, encoding: "utf8" }
+    ).trim();
+  } catch {
+    ghRepo = "";
+  }
+}
+if (ghRepo) {
+  try {
+    const prs = JSON.parse(
+      execFileSync(
+        "gh",
+        [
+          "pr",
+          "list",
+          "--repo",
+          ghRepo,
+          "--state",
+          "merged",
+          "--limit",
+          "20",
+          "--json",
+          "number,title,mergedAt",
+        ],
+        { cwd: repo, encoding: "utf8" }
+      )
+    );
+    if (prs.length) {
+      lastPr = prs[0].number;
+      prSummary = `${prs.length} recent merged PR(s) in ${ghRepo}; latest #${prs[0].number} "${prs[0].title}"`;
+    } else {
+      prSummary = `no merged PRs found in ${ghRepo}`;
+    }
+  } catch {
+    prSummary = `(gh pr list failed for ${ghRepo} — PR history skipped)`;
+  }
+}
+
+const date = new Date().toISOString().slice(0, 10);
+const newCommits = logLines.length;
+const notePath = path.join(sourceDir, `${date}-${fileSlug}-git.md`);
+const note = `---
+type: source
+created: ${date}
+updated: ${date}
+related: []
+sources: []
+source_system: git
+project: ${slug}
+---
+
+# git history — ${slug} (${date})
+
+- Repo: \`${repo}\`
+- HEAD: \`${head}\`
+- Total commits on HEAD: ${totalCommits}
+- New commits since last ingest${lastCommit ? ` (\`${lastCommit}\`)` : " (first run)"}: ${newCommits}
+- Merged PRs: ${prSummary}
+
+## New commits
+${
+  newCommits
+    ? logLines
+        .slice(0, 200)
+        .map(l => `- ${l.replace(/\t/g, " · ")}`)
+        .join("\n")
+    : "_(none)_"
+}
+`;
+
+fs.mkdirSync(sourceDir, { recursive: true });
+fs.writeFileSync(notePath, redact(note));
+
+const meta = {
+  connector: "git",
+  profile: slug,
+  ranAt: new Date().toISOString(),
+  proposedCursor: { lastCommit: head, lastPr },
+  sourceNotes: [path.relative(process.cwd(), notePath)],
+};
+if (emitMeta) {
+  fs.mkdirSync(path.dirname(emitMeta), { recursive: true });
+  fs.writeFileSync(emitMeta, `${JSON.stringify(meta, null, 2)}\n`);
+}
+
+console.log(
+  `✓ git connector: ${newCommits} new commit(s) → ${path.relative(process.cwd(), notePath)}`
+);
+if (emitMeta)
+  console.log(
+    `  proposed cursor → ${path.relative(process.cwd(), emitMeta)} (kernel advances final state after verification)`
+  );

package/plugins/src/wiki/scripts/ingest-memory.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+/**
+ * ingest-memory.mjs — PROJECT-SCOPED memory connector. Dependency-free.
+ *
+ * Ingests ONLY a project's own persisted memory into a sanitized source note.
+ * NEVER ingests global/unrelated memory: global Codex memory (~/.codex/memories) and
+ * the Codex Chronicle store are hard-refused. Claude per-project memory is inherently
+ * project-scoped; Codex memory is accepted only via an explicit project-scoped path
+ * (e.g. a per-project CODEX_HOME). Emits a proposed cursor; the kernel advances state.
+ *
+ * Usage:
+ *   node ingest-memory.mjs --memory-dir <dir> [--config <p>] [--source-dir <dir>]
+ *     [--state <file>] [--emit-meta <file>]
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { loadConfig, walkFiles, SECRET_PATTERNS } from "./_wiki-lib.mjs";
+
+const argv = process.argv.slice(2);
+const opt = (n, d) => {
+  const i = argv.indexOf(n);
+  return i !== -1 ? argv[i + 1] : d;
+};
+const memoryDir = opt("--memory-dir");
+const sourceDir = path.resolve(opt("--source-dir", "wiki/sources/memory"));
+const emitMeta = opt("--emit-meta");
+
+const fail = m => {
+  console.error(`✗ ${m}`);
+  process.exit(1);
+};
+if (!memoryDir)
+  fail("--memory-dir is required (the PROJECT-SCOPED memory directory)");
+const resolvedMem = path.resolve(memoryDir);
+
+// Hard refusal of global / unrelated memory stores.
+const globalCodex = path.resolve(os.homedir(), ".codex", "memories");
+const chronicle = path.resolve(os.homedir(), ".codex", "memories_extensions");
+if (
+  resolvedMem === globalCodex ||
+  resolvedMem.startsWith(globalCodex + path.sep) ||
+  resolvedMem.startsWith(chronicle + path.sep)
+) {
+  fail(
+    `refusing global Codex memory (${resolvedMem}). Memory ingestion is project-scoped only — never global/unrelated.`
+  );
+}
+if (!fs.existsSync(resolvedMem)) fail(`memory dir not found: ${resolvedMem}`);
+
+// Prove the directory is PROJECT-scoped (don't just trust the caller): accept only the
+// Claude per-project memory dir for THIS repo, a per-project CODEX_HOME memories dir, or a
+// config-declared allowlist. Otherwise refuse — it could be another project's memory.
+const repo = path.resolve(opt("--repo", "."));
+const { config } = loadConfig(opt("--config"));
+const allowedRoots = (config?.memory?.allowedRoots ?? []).map(p =>
+  path.resolve(p)
+);
+const claudeMem = path.resolve(
+  os.homedir(),
+  ".claude",
+  "projects",
+  repo.split(path.sep).join("-"),
+  "memory"
+);
+const codexHome = process.env.CODEX_HOME
+  ? path.resolve(process.env.CODEX_HOME)
+  : null;
+const projectCodexMem =
+  codexHome && codexHome !== path.resolve(os.homedir(), ".codex")
+    ? path.join(codexHome, "memories")
+    : null;
+const under = root =>
+  Boolean(root) &&
+  (resolvedMem === root || resolvedMem.startsWith(root + path.sep));
+if (!(under(claudeMem) || under(projectCodexMem) || allowedRoots.some(under))) {
+  fail(
+    `--memory-dir is not provably project-scoped for repo ${repo}. Expected the Claude per-project dir (${claudeMem}), a per-project CODEX_HOME memories dir, or config.memory.allowedRoots. Refusing possibly-unrelated memory.`
+  );
+}
+
+const redact = t =>
+  SECRET_PATTERNS.reduce(
+    (acc, { re }) => acc.replace(new RegExp(re, "g"), "[REDACTED]"),
+    t
+  );
+const mdFiles = walkFiles(resolvedMem, { ext: ".md" });
+const date = new Date().toISOString().slice(0, 10);
+const entries = mdFiles.map(f => {
+  const body = redact(fs.readFileSync(f, "utf8")).trim();
+  return `### ${path.basename(f)}\n\n${body}`;
+});
+
+const notePath = path.join(sourceDir, `${date}-memory.md`);
+const note = `---
+type: source
+created: ${date}
+updated: ${date}
+related: []
+sources: []
+source_system: memory
+sensitivity: internal
+---
+
+# project-scoped memory (${date})
+
+- Source: \`${resolvedMem}\` (project-scoped; global/Chronicle memory is never ingested)
+- Files: ${mdFiles.length}
+
+${entries.join("\n\n") || "_(no memory files)_"}
+`;
+
+fs.mkdirSync(sourceDir, { recursive: true });
+fs.writeFileSync(notePath, note);
+
+const meta = {
+  connector: "memory",
+  profile: "project",
+  ranAt: new Date().toISOString(),
+  proposedCursor: { files: mdFiles.length, lastIngest: date },
+  sourceNotes: [path.relative(process.cwd(), notePath)],
+};
+if (emitMeta) {
+  fs.mkdirSync(path.dirname(emitMeta), { recursive: true });
+  fs.writeFileSync(emitMeta, `${JSON.stringify(meta, null, 2)}\n`);
+}
+
+console.log(
+  `✓ memory connector: ${mdFiles.length} file(s) → ${path.relative(process.cwd(), notePath)}`
+);

package/plugins/src/wiki/scripts/ingest-roles.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * ingest-roles.mjs — roles connector. Dependency-free. Ingests the wiki's own staff
+ * roster (config.staff[] + wiki/staff/*.md) into a sanitized source note. Emits a
+ * proposed cursor; the kernel advances state. Does NOT run any subagent.
+ *
+ * Usage:
+ *   node ingest-roles.mjs [--config <p>] [--wiki <root>] [--source-dir <dir>]
+ *     [--state <file>] [--emit-meta <file>]
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig, walkFiles } from "./_wiki-lib.mjs";
+
+const argv = process.argv.slice(2);
+const opt = (n, d) => {
+  const i = argv.indexOf(n);
+  return i !== -1 ? argv[i + 1] : d;
+};
+const { config } = loadConfig(opt("--config"));
+const wikiRoot = path.resolve(opt("--wiki", config?.wikiRoot ?? "wiki"));
+const sourceDir = path.resolve(
+  opt("--source-dir", path.join(wikiRoot, "sources", "roles"))
+);
+const emitMeta = opt("--emit-meta");
+
+const staff = Array.isArray(config?.staff) ? config.staff : [];
+const staffDir = path.join(wikiRoot, "staff");
+const staffPages = fs.existsSync(staffDir)
+  ? walkFiles(staffDir, { ext: ".md" })
+  : [];
+const date = new Date().toISOString().slice(0, 10);
+
+const rosterRows = staff.length
+  ? staff
+      .map(
+        s =>
+          `- **${s.role}** (\`${s.id}\`)${s.expertise ? ` — ${s.expertise}` : ""}${s.owns?.categories ? ` · owns: ${s.owns.categories.join(", ")}` : ""}`
+      )
+      .join("\n")
+  : "_(no roles declared in config.staff[])_";
+
+const notePath = path.join(sourceDir, `${date}-roles.md`);
+const note = `---
+type: source
+created: ${date}
+updated: ${date}
+related: []
+sources: []
+source_system: roles
+---
+
+# digital staff roster (${date})
+
+Declared roles: ${staff.length}; staff doc pages: ${staffPages.length}.
+
+## Roles
+${rosterRows}
+
+## Staff pages
+${staffPages.length ? staffPages.map(p => `- \`${path.relative(wikiRoot, p)}\``).join("\n") : "_(none)_"}
+`;
+
+fs.mkdirSync(sourceDir, { recursive: true });
+fs.writeFileSync(notePath, note);
+
+const meta = {
+  connector: "roles",
+  profile: "project",
+  ranAt: new Date().toISOString(),
+  proposedCursor: {
+    roles: staff.length,
+    pages: staffPages.length,
+    lastIngest: date,
+  },
+  sourceNotes: [path.relative(process.cwd(), notePath)],
+};
+if (emitMeta) {
+  fs.mkdirSync(path.dirname(emitMeta), { recursive: true });
+  fs.writeFileSync(emitMeta, `${JSON.stringify(meta, null, 2)}\n`);
+}
+
+console.log(
+  `✓ roles connector: ${staff.length} role(s), ${staffPages.length} page(s) → ${path.relative(process.cwd(), notePath)}`
+);