sverklo 0.16.0 → 0.17.1

package/dist/bin/sverklo.js

@@ -51,6 +51,8 @@ if (command && command !== "--help" && command !== "-h") {
             dashboard: "Alias for `sverklo ui`.",
             wakeup: "Print compressed project context (for system-prompt injection in non-MCP clients).",
             digest: "5-line summary of what changed in this project. Flags: --since 7d, --format markdown|plain.",
+            memory: "Manage the memory store. Subcommands: export.",
+            grammars: "Manage tree-sitter grammars for the SVERKLO_PARSER=tree-sitter opt-in path. Subcommands: install.",
             "audit-prompt": "Print a ready-to-paste codebase-audit prompt (hybrid agent workflow).",
             "review-prompt": "Print a ready-to-paste PR/MR-review prompt (hybrid agent workflow).",
             bench: "Run reproducible benchmarks on gin/nestjs/react.",
@@ -327,6 +329,88 @@ if (command === "workspace") {
             console.log(`  · ${r.alias || ""} ${r.path}`);
         process.exit(0);
     }
+    if (sub === "memory") {
+        // sverklo workspace memory <name> <list|add|search|forget> [...]
+        //
+        // Per-workspace shared memory store at
+        // ~/.sverklo/workspaces/<name>/memories.db. CLI ships in v0.17;
+        // sverklo_remember scope:workspace is the v0.18 follow-up.
+        const name = args[2];
+        const op = args[3];
+        if (!name || !op) {
+            console.error("Usage: sverklo workspace memory <name> <list|add|search|forget> [args]");
+            process.exit(1);
+        }
+        const { openWorkspaceMemory, addWorkspaceMemory, searchWorkspaceMemory, workspaceMemoryExists, } = await import("../src/workspace/memory.js");
+        if (op === "add") {
+            const content = args.slice(4).join(" ");
+            if (!content) {
+                console.error('Usage: sverklo workspace memory <name> add "memory text"');
+                process.exit(1);
+            }
+            const ws = openWorkspaceMemory(name);
+            const id = addWorkspaceMemory(ws, { content });
+            console.log(`Saved workspace memory #${id} → ${ws.dbPath}`);
+            ws.close();
+            process.exit(0);
+        }
+        if (op === "list") {
+            if (!workspaceMemoryExists(name)) {
+                console.log(`No memories yet for workspace "${name}". Add one with:`);
+                console.log(`  sverklo workspace memory ${name} add "your decision here"`);
+                process.exit(0);
+            }
+            const ws = openWorkspaceMemory(name);
+            const rows = ws.memoryStore.getAll(50);
+            console.log(`\nWorkspace "${name}" memories (${rows.length}):\n`);
+            for (const m of rows) {
+                const age = new Date(m.created_at).toISOString().slice(0, 10);
+                console.log(`  #${m.id} [${m.category}/${m.kind}] ${age}`);
+                console.log(`    ${m.content.replace(/\n/g, " ").slice(0, 100)}${m.content.length > 100 ? "…" : ""}`);
+            }
+            ws.close();
+            process.exit(0);
+        }
+        if (op === "search") {
+            const query = args.slice(4).join(" ");
+            if (!query) {
+                console.error('Usage: sverklo workspace memory <name> search "query"');
+                process.exit(1);
+            }
+            if (!workspaceMemoryExists(name)) {
+                console.log(`No memories for workspace "${name}".`);
+                process.exit(0);
+            }
+            const ws = openWorkspaceMemory(name);
+            const rows = searchWorkspaceMemory(ws, query, 20);
+            console.log(`\n${rows.length} match${rows.length === 1 ? "" : "es"}:\n`);
+            for (const m of rows) {
+                console.log(`  #${m.id} [${m.category}/${m.kind}]`);
+                console.log(`    ${m.content.replace(/\n/g, " ").slice(0, 200)}${m.content.length > 200 ? "…" : ""}`);
+            }
+            ws.close();
+            process.exit(0);
+        }
+        if (op === "forget") {
+            const idStr = args[4];
+            if (!idStr) {
+                console.error("Usage: sverklo workspace memory <name> forget <id>");
+                process.exit(1);
+            }
+            const id = parseInt(idStr, 10);
+            if (!Number.isFinite(id)) {
+                console.error(`✗ "${idStr}" is not a valid id`);
+                process.exit(2);
+            }
+            const ws = openWorkspaceMemory(name);
+            const ok = ws.memoryStore.delete(id);
+            ws.close();
+            console.log(ok ? `Forgot memory #${id}.` : `Memory #${id} not found.`);
+            process.exit(ok ? 0 : 1);
+        }
+        console.error(`Unknown workspace memory op: ${op}`);
+        process.exit(1);
+    }
     console.log(`
 sverklo workspace — manage multi-repo workspaces
 
@@ -621,7 +705,20 @@ if (command === "review") {
         (process.env.GITHUB_BASE_REF
             ? `origin/${process.env.GITHUB_BASE_REF}..HEAD`
             : "main..HEAD");
-    const projectPath = await resolveProjectPath(flags);
+    // Strip value-taking flags so `--format github-review-json` doesn't
+    // leave "github-review-json" looking like a positional path.
+    const valueFlags = new Set(["--ref", "--format", "--max-files", "--fail-on"]);
+    const cleanFlags = [];
+    for (let i = 0; i < flags.length; i++) {
+        if (valueFlags.has(flags[i])) {
+            i++;
+            continue;
+        }
+        if (Array.from(valueFlags).some((f) => flags[i].startsWith(`${f}=`)))
+            continue;
+        cleanFlags.push(flags[i]);
+    }
+    const projectPath = await resolveProjectPath(cleanFlags);
     // Ensure model is available
     const { existsSync: modelExists } = await import("node:fs");
     const { join: joinPath } = await import("node:path");
@@ -636,17 +733,34 @@ if (command === "review") {
     const { getProjectConfig } = await import("../src/utils/config.js");
     const { Indexer } = await import("../src/indexer/indexer.js");
     const { handleReviewDiff } = await import("../src/server/tools/review-diff.js");
+    const { buildReviewJson } = await import("../src/server/tools/review-format.js");
     const config = getProjectConfig(projectPath);
     const indexer = new Indexer(config);
     await indexer.index();
-    const markdown = handleReviewDiff(indexer, {
+    const reviewArgs = {
         ref: effectiveRef,
         max_files: maxFiles,
         token_budget: 8000,
-    });
+    };
+    // Run early so we can both decide the threshold AND emit the format.
+    // For github-review-json we want the structured payload; for the
+    // other two formats we just need the markdown.
+    let markdown = "";
+    let structured = null;
+    if (format === "github-review-json") {
+        structured = buildReviewJson(indexer, reviewArgs);
+        if ("error" in structured) {
+            process.stderr.write(`✗ ${structured.error}\n`);
+            indexer.close();
+            process.exit(2);
+        }
+        markdown = structured.summary;
+    }
+    else {
+        markdown = handleReviewDiff(indexer, reviewArgs);
+    }
     indexer.close();
     if (format === "json") {
-        // Wrap the markdown in a JSON envelope with parsed risk level
         const riskLevels = ["low", "medium", "high", "critical"];
         let maxRisk = "low";
         for (const level of riskLevels) {
@@ -660,6 +774,9 @@ if (command === "review") {
         };
         process.stdout.write(JSON.stringify(output, null, 2) + "\n");
     }
+    else if (format === "github-review-json") {
+        process.stdout.write(JSON.stringify(structured, null, 2) + "\n");
+    }
     else {
         process.stdout.write(markdown + "\n");
     }
@@ -1221,6 +1338,156 @@ if (command === "concept-index") {
     indexer.close();
     process.exit(r.failed > 0 && r.labeled === 0 ? 1 : 0);
 }
+if (command === "grammars") {
+    // Installs / refreshes the WASM grammars used by SVERKLO_PARSER=tree-sitter
+    // into ~/.sverklo/grammars/. v0.17 opt-in path; the regex parser
+    // works without grammars, so this is purely additive.
+    const sub = args[1];
+    if (sub !== "install" && sub !== "list") {
+        console.log(`\nsverklo grammars — manage tree-sitter grammars for the SVERKLO_PARSER=tree-sitter opt-in parser\n\n` +
+            `Usage:\n` +
+            `  sverklo grammars install [--lang typescript,python,go] [--force]\n` +
+            `  sverklo grammars list\n\n` +
+            `Languages supported: typescript, tsx, javascript, python, go, rust\n` +
+            `Grammars land in ~/.sverklo/grammars/. Total ~6 MB across all six.\n`);
+        process.exit(0);
+    }
+    const flags = args.slice(2);
+    const langArg = flags.find((f, i) => flags[i - 1] === "--lang") ?? "";
+    const langs = langArg
+        ? langArg.split(",").map((s) => s.trim())
+        : undefined;
+    const force = flags.includes("--force");
+    const { installGrammars, grammarsDir, GRAMMARS } = await import("../src/indexer/grammars-install.js");
+    if (sub === "list") {
+        console.log(`\nGrammars dir: ${grammarsDir()}\n`);
+        const { existsSync, statSync } = await import("node:fs");
+        const { join: jp } = await import("node:path");
+        for (const g of GRAMMARS) {
+            const p = jp(grammarsDir(), g.wasm);
+            if (existsSync(p)) {
+                console.log(`  ✓ ${g.lang.padEnd(12)}${(statSync(p).size / 1024).toFixed(0)} KB`);
+            }
+            else {
+                console.log(`  ✗ ${g.lang.padEnd(12)}not installed`);
+            }
+        }
+        console.log(`\nRun \`sverklo grammars install\` to fetch missing grammars.\n`);
+        process.exit(0);
+    }
+    console.log(`\nInstalling tree-sitter grammars into ${grammarsDir()}\n`);
+    const results = await installGrammars({
+        langs,
+        force,
+        onProgress: (m) => console.log(m),
+    });
+    const fresh = results.filter((r) => r.status === "fresh").length;
+    const cached = results.filter((r) => r.status === "cached").length;
+    const errors = results.filter((r) => r.status === "error");
+    console.log(`\nDone: ${fresh} downloaded, ${cached} cached, ${errors.length} failed.`);
+    if (errors.length > 0) {
+        for (const e of errors)
+            console.log(`  ✗ ${e.lang}: ${e.error}`);
+        console.log(`\nRetry with \`sverklo grammars install --force\` after checking your network.\n`);
+    }
+    else {
+        console.log(`\nNext: SVERKLO_PARSER=tree-sitter sverklo audit . to use them.\n`);
+    }
+    process.exit(errors.length > 0 ? 1 : 0);
+}
+if (command === "memory") {
+    // `sverklo memory export` — push the memory store out to markdown,
+    // Notion, or raw JSON. Closes the "memory is a private journal"
+    // gap from the v0.16 product teardown.
+    const sub = args[1];
+    if (sub !== "export") {
+        console.log(`\nsverklo memory — export the memory store to other tools\n\n` +
+            `Usage:\n  sverklo memory export --format markdown|notion|json --to PATH [flags]\n\n` +
+            `Flags:\n` +
+            `  --format markdown|notion|json    output format (required)\n` +
+            `  --to PATH                        directory (markdown) or file (json/notion)\n` +
+            `  --kind episodic|semantic|procedural   filter by cognitive axis (default: all)\n` +
+            `  --include-invalidated            include superseded rows for the bi-temporal timeline\n` +
+            `  --notion-database ID             target database id (required for --format notion)\n` +
+            `  -h, --help                       show this help\n`);
+        process.exit(0);
+    }
+    const flags = args.slice(2);
+    if (flags.includes("--help") || flags.includes("-h")) {
+        console.log(`\nsverklo memory export — push memory rows to markdown / Notion / JSON\n\n` +
+            `Required: --format markdown|notion|json --to PATH\n` +
+            `See \`sverklo memory\` for the full flag list.\n`);
+        process.exit(0);
+    }
+    const flagVal = (name) => {
+        const idx = flags.indexOf(name);
+        if (idx !== -1 && flags[idx + 1])
+            return flags[idx + 1];
+        const prefixed = flags.find((f) => f.startsWith(`${name}=`));
+        return prefixed ? prefixed.slice(name.length + 1) : undefined;
+    };
+    const format = flagVal("--format");
+    if (!format || !["markdown", "notion", "json"].includes(format)) {
+        console.error("✗ --format markdown|notion|json is required");
+        process.exit(2);
+    }
+    const to = flagVal("--to");
+    if (!to) {
+        console.error("✗ --to PATH is required");
+        process.exit(2);
+    }
+    const kindRaw = flagVal("--kind");
+    if (kindRaw && !["episodic", "semantic", "procedural"].includes(kindRaw)) {
+        console.error(`✗ --kind must be episodic|semantic|procedural, got "${kindRaw}"`);
+        process.exit(2);
+    }
+    const includeInvalidated = flags.includes("--include-invalidated");
+    const notionDatabase = flagVal("--notion-database");
+    if (format === "notion" && !notionDatabase) {
+        console.error("✗ --notion-database ID is required for --format notion");
+        process.exit(2);
+    }
+    // Strip value-taking flags before resolving the project path
+    const valueFlags = new Set(["--format", "--to", "--kind", "--notion-database"]);
+    const cleanFlags = [];
+    for (let i = 0; i < flags.length; i++) {
+        if (valueFlags.has(flags[i])) {
+            i++;
+            continue;
+        }
+        if (Array.from(valueFlags).some((f) => flags[i].startsWith(`${f}=`)))
+            continue;
+        cleanFlags.push(flags[i]);
+    }
+    const projectPath = await resolveProjectPath(cleanFlags);
+    const { resolve: resolvePath } = await import("node:path");
+    const outPath = resolvePath(to);
+    const { getProjectConfig } = await import("../src/utils/config.js");
+    const { Indexer } = await import("../src/indexer/indexer.js");
+    const { runMemoryExport } = await import("../src/memory/export.js");
+    const config = getProjectConfig(projectPath);
+    const indexer = new Indexer(config);
+    await indexer.index();
+    try {
+        const report = runMemoryExport(indexer, {
+            format,
+            to: outPath,
+            kind: kindRaw,
+            includeInvalidated,
+            notionDatabase,
+        });
+        console.log(`\nExported ${report.rowsExported} memories (${format}):\n` +
+            report.written.map((p) => `  ${p}`).join("\n") +
+            `\n\nBy category: ${Object.entries(report.byCategory).map(([k, v]) => `${k}=${v}`).join(", ") || "(none)"}\n`);
+    }
+    catch (err) {
+        const e = err;
+        console.error(`✗ export failed: ${e.message ?? String(err)}`);
+        process.exit(1);
+    }
+    indexer.close();
+    process.exit(0);
+}
 if (command === "digest") {
     // Habit-loop scaffold: 5-line summary of what changed in this project
     // since the user last paid attention. Designed to be cheap to render
@@ -1395,6 +1662,8 @@ Memory + offline maintenance:
   sverklo wakeup             Print compressed project context (for system-prompt injection)
   sverklo wiki               Generate a markdown wiki from the indexed codebase
   sverklo digest             5-line summary of what changed in this project (--since 7d)
+  sverklo memory export      Export memories to markdown / Notion / JSON
+  sverklo grammars install   Install tree-sitter grammars for the v0.17 opt-in parser
   sverklo prune              Decay stale memories + consolidate similar episodic ones
   sverklo concept-index      Label clusters with an LLM (requires Ollama)
   sverklo enrich-symbols     Add LLM-generated purpose to top-PageRank symbols (requires Ollama)