mnemos-capture 1.1.0 → 1.2.0

package/dist/cli/index.js

@@ -17,10 +17,10 @@ async function main() {
         const keyIdx = args.indexOf("--key");
         const apiKey = keyIdx !== -1 ? args[keyIdx + 1] : undefined;
         if (!apiKey) {
-            console.error("Usage: npx mnemos-capture setup-hooks --key YOUR_API_KEY [--briefing]");
+            console.error("Usage: npx mnemos-capture setup-hooks --key YOUR_API_KEY [--briefing] [--vault]");
             process.exit(1);
         }
-        setupHooks(apiKey, { briefing: args.includes("--briefing") });
+        setupHooks(apiKey, { briefing: args.includes("--briefing"), vault: args.includes("--vault") });
         return;
     }
     if (command === "inbox-check") {
@@ -32,6 +32,34 @@ async function main() {
         await inboxCheck(apiKey, { briefing: args.includes("--briefing") });
         return;
     }
+    if (command === "vault-check") {
+        const { vaultCheck } = await import("./hooks.js");
+        const keyIdx = args.indexOf("--key");
+        const apiKey = keyIdx !== -1 ? args[keyIdx + 1] : undefined;
+        if (!apiKey)
+            process.exit(0); // silent fail in hook context
+        await vaultCheck(apiKey);
+        return;
+    }
+    if (command === "config") {
+        const { runConfigCommand } = await import("./config.js");
+        runConfigCommand(args.slice(1));
+        return;
+    }
+    if (command === "kos") {
+        const { kos } = await import("./kos.js");
+        const { readConfig } = await import("./config.js");
+        const keyIdx = args.indexOf("--key");
+        const apiKey = keyIdx !== -1 ? args[keyIdx + 1] : readConfig().key;
+        if (!apiKey) {
+            console.error("No API key. Pass --key YOUR_KEY or store it: mnemos config set key YOUR_KEY");
+            process.exit(1);
+        }
+        const planIdx = args.indexOf("--plan");
+        const plan = planIdx !== -1 ? args[planIdx + 1] : undefined;
+        await kos(apiKey, { plan });
+        return;
+    }
     // Default: open the hosted app
     console.log("");
     console.log("  Mnemos — Knowledge capture for agentic workflows\n");
@@ -52,11 +80,30 @@ function printHelp() {
   Mnemos — Knowledge capture for agentic workflows
 
   Usage:
-    npx mnemos-capture                                   Open Mnemos in your browser
-    npx mnemos-capture serve-mcp --key KEY               Start the MCP server for Claude Code
-    npx mnemos-capture setup-hooks --key KEY             Install inbox count hook (fast)
-    npx mnemos-capture setup-hooks --key KEY --briefing  Install full briefing hook (uses LLM)
-    npx mnemos-capture help                              Show this help
+    npx mnemos-capture                                         Open Mnemos in your browser
+    npx mnemos-capture serve-mcp --key KEY                     Start the MCP server for Claude Code
+    npx mnemos-capture setup-hooks --key KEY                   Install inbox count hook (fast)
+    npx mnemos-capture setup-hooks --key KEY --briefing        Install full briefing hook (uses LLM)
+    npx mnemos-capture setup-hooks --key KEY --vault           Install vault hook (PreToolCall)
+    npx mnemos-capture setup-hooks --key KEY --briefing --vault  Install both hooks
+    npx mnemos-capture config set agent "claude -p"            Set which AI assistant kos drives
+    npx mnemos-capture kos --key KEY [--plan FILE]             Implement a plan in an isolated worktree
+    npx mnemos-capture help                                    Show this help
+
+  MCP tools (via your AI assistant):
+    briefing          — Session-start briefing with ranked insights to apply
+    generate_plan     — Turn selected captures into a full implementation plan
+    list_plans        — List or read saved implementation plans
+    vault_scan        — Scan all captures for relevance to current activity
+    curate            — Validate URLs and flag stale captures
+
+  kos — implement plans with your own AI assistant (model-agnostic):
+    1. Tell Mnemos which assistant to drive (once):
+         mnemos config set agent "claude -p"      # or "codex exec", "aider --yes --message"
+    2. Generate a plan via the generate_plan MCP tool.
+    3. Run: mnemos kos --key YOUR_KEY
+       kos creates an isolated git worktree, hands the plan to your assistant,
+       and reports the branch + the plan's Verification Checklist when done.
 
   Get started:
     1. Run: npx mnemos-capture
@@ -74,6 +121,9 @@ function printHelp() {
   The hook is installed automatically when you start the MCP server.
   To upgrade to a full project briefing at session start:
     npx mnemos-capture setup-hooks --key YOUR_API_KEY --briefing
+
+  To enable the vault (surfaces captures as you edit files — opt-in):
+    npx mnemos-capture setup-hooks --key YOUR_API_KEY --vault
   `);
 }
 main().catch((err) => {

package/dist/cli/kos.js

@@ -0,0 +1,123 @@
+/**
+ * kos — Mnemos' Knowledge Operations orchestrator.
+ *
+ * Drives whatever AI assistant the user configured (`mnemos config set agent ...`)
+ * to implement a generated plan in an isolated git worktree. Mnemos owns the
+ * harness-independent parts: fetching the plan, the worktree, and reporting the
+ * Verification Checklist. The assistant is a black box — model-agnostic by design.
+ */
+import { tmpdir } from "os";
+import { join } from "path";
+import { writeFileSync, existsSync, appendFileSync, readFileSync } from "fs";
+import { execSync } from "child_process";
+import { callMcp } from "./hooks.js";
+import { readConfig } from "./config.js";
+// ── Pure helpers (exported for testing) ──
+/** Extract `**filename.md**` plan names from a list_plans response. */
+export function parsePlanFilenames(listText) {
+    const matches = listText.match(/\*\*([^*]+\.md)\*\*/g) ?? [];
+    return matches.map((m) => m.replace(/\*\*/g, ""));
+}
+/** Pick the newest plan. Filenames are date-prefixed (YYYY-MM-DD-...), so lexical desc = newest. */
+export function latestPlanFilename(listText) {
+    const names = parsePlanFilenames(listText);
+    if (names.length === 0)
+        return null;
+    return [...names].sort((a, b) => b.localeCompare(a))[0] ?? null;
+}
+/** Pull the Verification Checklist items out of a plan's Markdown. */
+export function parseChecklist(planText) {
+    const section = planText.match(/##\s*Verification Checklist\s*\n([\s\S]*?)(?=\n##\s|$)/i);
+    if (!section?.[1])
+        return [];
+    return section[1]
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => /^- \[[ x]\]/i.test(l))
+        .map((l) => l.replace(/^- \[[ x]\]\s*/i, ""));
+}
+/** Build a unique, sortable branch name for a kos run. */
+export function buildKosBranch(now = new Date()) {
+    const stamp = now.toISOString().replace(/[:.]/g, "-").replace("T", "-").slice(0, 19);
+    return `mnemos/kos-${stamp}`;
+}
+/** The instruction handed to the assistant. The plan file is the real contract. */
+export const KOS_PROMPT = "Implement the plan in MNEMOS_PLAN.md in this repository. " +
+    "Follow the Codebase Mapping table exactly — change only the files it lists. " +
+    "For each step apply the thinking effort named in its Effort column " +
+    "(low = quick/mechanical, medium = careful, high = deep reasoning). " +
+    "When finished, make sure every item in the Verification Checklist is satisfied.";
+// ── Orchestrator ──
+function run(cmd, cwd) {
+    return execSync(cmd, { cwd, stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+}
+export async function kos(apiKey, opts = {}) {
+    const cfg = readConfig();
+    if (!cfg.agent) {
+        console.error("No agent configured. Tell Mnemos which AI assistant to drive:\n");
+        console.error('  mnemos config set agent "claude -p"               # Claude Code');
+        console.error('  mnemos config set agent "codex exec"              # Codex');
+        console.error('  mnemos config set agent "aider --yes --message"   # Aider');
+        process.exit(1);
+    }
+    // 1. Resolve the plan — explicit filename, or the newest saved plan
+    const planFile = opts.plan ?? latestPlanFilename((await callMcp(apiKey, "list_plans", {}, 15000)) ?? "");
+    if (!planFile) {
+        console.error("No plans found. Generate one first with the generate_plan MCP tool.");
+        process.exit(1);
+    }
+    const planText = await callMcp(apiKey, "list_plans", { filename: planFile }, 15000);
+    if (!planText || !planText.trim()) {
+        console.error(`Could not read plan: ${planFile}`);
+        process.exit(1);
+    }
+    // 2. Must be inside a git repo
+    let repoRoot;
+    try {
+        repoRoot = run("git rev-parse --show-toplevel");
+    }
+    catch {
+        console.error("mnemos kos must be run inside a git repository.");
+        process.exit(1);
+        return;
+    }
+    // 3. Isolated worktree on a fresh branch
+    const branch = buildKosBranch();
+    const worktreePath = join(tmpdir(), branch.replace(/\//g, "-"));
+    console.log(`Creating isolated worktree on branch ${branch}...`);
+    run(`git worktree add -b ${branch} "${worktreePath}"`, repoRoot);
+    // 4. Drop the plan in and keep git from tracking it (local exclude, not committed)
+    writeFileSync(join(worktreePath, "MNEMOS_PLAN.md"), planText);
+    try {
+        const excludePath = join(repoRoot, ".git", "info", "exclude");
+        if (existsSync(excludePath)) {
+            const current = readFileSync(excludePath, "utf-8");
+            if (!current.includes("MNEMOS_PLAN.md"))
+                appendFileSync(excludePath, "\nMNEMOS_PLAN.md\n");
+        }
+    }
+    catch {
+        // best-effort
+    }
+    // 5. Hand off to the user's assistant, running inside the worktree
+    console.log(`Launching: ${cfg.agent}\n`);
+    try {
+        execSync(`${cfg.agent} ${JSON.stringify(KOS_PROMPT)}`, { cwd: worktreePath, stdio: "inherit" });
+    }
+    catch {
+        console.error("\nThe agent exited with an error. The worktree is preserved for inspection.");
+    }
+    // 6. Report — branch + the plan's own checklist as the review gate
+    const checklist = parseChecklist(planText);
+    console.log(`\n${"─".repeat(60)}`);
+    console.log(`kos finished. Plan: ${planFile}`);
+    console.log(`Branch:   ${branch}`);
+    console.log(`Worktree: ${worktreePath}`);
+    if (checklist.length > 0) {
+        console.log(`\nVerify before merging:`);
+        for (const item of checklist)
+            console.log(`  [ ] ${item}`);
+    }
+    console.log(`\nReview the branch, then merge. Clean up the worktree with:`);
+    console.log(`  git worktree remove "${worktreePath}"`);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mnemos-capture",
-  "version": "1.1.0",
-  "description": "Zero-friction knowledge capture for agentic workflows. Paste anything → Claude extracts insights → auto-commits to your knowledge repo → your Claude Code workflow picks it up.",
+  "version": "1.2.0",
+  "description": "Capture anything. Your agents apply it. A knowledge pipeline that ingests the outside world and makes it directly actionable by any AI agent over MCP.",
   "type": "module",
   "bin": {
     "mnemos-capture": "./dist/cli/index.js"
@@ -11,7 +11,9 @@
     "build": "next build",
     "start": "next start",
     "build:cli": "tsc -p cli/tsconfig.json",
-    "prepublishOnly": "npm run build:cli"
+    "prepublishOnly": "npm run build:cli",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "keywords": [
     "ai",
@@ -51,7 +53,8 @@
     "autoprefixer": "^10.4.21",
     "postcss": "^8.5.3",
     "tailwindcss": "^3.4.17",
-    "typescript": "^5"
+    "typescript": "^5",
+    "vitest": "^4.1.8"
   },
   "engines": {
     "node": ">=18"