obsidian-brain-mcp 0.1.0 → 0.2.0

package/dist/cli/brain-auto-load.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit hook entrypoint for Claude Code.
+ *
+ * Reads the hook JSON from stdin, scans the obsidian-brain vault for
+ * agents whose `triggers` frontmatter matches the submitted prompt, and
+ * emits a `hookSpecificOutput.additionalContext` payload containing the
+ * concatenated bodies of the matching agents' `_agent.md` files.
+ *
+ * master is always included as the baseline persona.
+ *
+ * Performance budget: <200ms wall-clock. We only read `_agent.md` files,
+ * never belief/decision/pattern bodies.
+ */
+export {};

package/dist/cli/brain-auto-load.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit hook entrypoint for Claude Code.
+ *
+ * Reads the hook JSON from stdin, scans the obsidian-brain vault for
+ * agents whose `triggers` frontmatter matches the submitted prompt, and
+ * emits a `hookSpecificOutput.additionalContext` payload containing the
+ * concatenated bodies of the matching agents' `_agent.md` files.
+ *
+ * master is always included as the baseline persona.
+ *
+ * Performance budget: <200ms wall-clock. We only read `_agent.md` files,
+ * never belief/decision/pattern bodies.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { initVault, ensureBrainDir, getAllAgentNames, agentDir, readMarkdown, } from "../vault.js";
+const ALWAYS_ON = ["master"];
+async function readStdin() {
+    // If stdin isn't piped (e.g. direct invocation with no data), return empty
+    // immediately. Otherwise collect all chunks.
+    if (process.stdin.isTTY) {
+        return "";
+    }
+    return new Promise((resolve, reject) => {
+        let buf = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+            buf += chunk;
+        });
+        process.stdin.on("end", () => resolve(buf));
+        process.stdin.on("error", reject);
+    });
+}
+function parseHookInput(raw) {
+    if (!raw || raw.trim().length === 0)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object") {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore — fall through to empty
+    }
+    return {};
+}
+function emitEmpty() {
+    process.stdout.write("{}\n");
+}
+function emitContext(additionalContext) {
+    const payload = {
+        hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext,
+        },
+    };
+    process.stdout.write(JSON.stringify(payload) + "\n");
+}
+async function loadAgentSlices() {
+    const names = await getAllAgentNames();
+    const slices = [];
+    for (const name of names) {
+        try {
+            const { data, content } = await readMarkdown(path.join(agentDir(name), "_agent.md"));
+            const triggers = Array.isArray(data.triggers)
+                ? data.triggers.filter((t) => typeof t === "string")
+                : [];
+            slices.push({ name, triggers, body: content.trim() });
+        }
+        catch {
+            // skip unreadable agents
+        }
+    }
+    return slices;
+}
+function selectMatchingAgents(prompt, slices) {
+    const lowered = prompt.toLowerCase();
+    const matched = [];
+    const seen = new Set();
+    for (const slice of slices) {
+        if (ALWAYS_ON.includes(slice.name)) {
+            if (!seen.has(slice.name)) {
+                matched.push(slice);
+                seen.add(slice.name);
+            }
+            continue;
+        }
+        if (slice.triggers.length === 0)
+            continue;
+        for (const trig of slice.triggers) {
+            if (trig.length === 0)
+                continue;
+            if (lowered.includes(trig.toLowerCase())) {
+                if (!seen.has(slice.name)) {
+                    matched.push(slice);
+                    seen.add(slice.name);
+                }
+                break;
+            }
+        }
+    }
+    return matched;
+}
+function buildContext(matched) {
+    if (matched.length === 0)
+        return "";
+    const names = matched.map((m) => m.name).join(", ");
+    const header = `[BRAIN-AUTO-LOAD] Loaded agents: ${names}`;
+    const sections = matched.map((m) => `## Agent: ${m.name}\n\n${m.body}`);
+    return `${header}\n\n${sections.join("\n\n---\n\n")}`;
+}
+async function main() {
+    let rawInput = "";
+    try {
+        rawInput = await readStdin();
+    }
+    catch {
+        emitEmpty();
+        return;
+    }
+    const hookInput = parseHookInput(rawInput);
+    const prompt = typeof hookInput.prompt === "string" ? hookInput.prompt : "";
+    try {
+        await initVault();
+        await ensureBrainDir();
+        const slices = await loadAgentSlices();
+        const matched = selectMatchingAgents(prompt, slices);
+        const ctx = buildContext(matched);
+        if (ctx.length === 0) {
+            emitEmpty();
+            return;
+        }
+        emitContext(ctx);
+    }
+    catch (err) {
+        // Never fail the hook — just emit empty JSON so Claude Code proceeds.
+        process.stderr.write(`[brain-auto-load] error: ${err instanceof Error ? err.message : String(err)}\n`);
+        emitEmpty();
+    }
+}
+// Suppress the vault resolution banner on stderr when running as a hook:
+// initVault writes to stderr which would clutter Claude Code logs. We can't
+// fully silence it without a refactor, but Claude Code treats stderr as
+// informational so that's fine.
+void fs; // retained in case future helpers need fs
+main().catch((error) => {
+    process.stderr.write(`[brain-auto-load] fatal: ${error instanceof Error ? error.message : String(error)}\n`);
+    // Exit 0 so the hook doesn't block the prompt.
+    emitEmpty();
+    process.exit(0);
+});

package/dist/cli/doctor.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/doctor.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { resolveVault } from "../vault.js";
+const USE_COLOR = process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
+const c = {
+    green: (s) => (USE_COLOR ? `\x1b[32m${s}\x1b[0m` : s),
+    red: (s) => (USE_COLOR ? `\x1b[31m${s}\x1b[0m` : s),
+    yellow: (s) => (USE_COLOR ? `\x1b[33m${s}\x1b[0m` : s),
+    cyan: (s) => (USE_COLOR ? `\x1b[36m${s}\x1b[0m` : s),
+    dim: (s) => (USE_COLOR ? `\x1b[2m${s}\x1b[0m` : s),
+    bold: (s) => (USE_COLOR ? `\x1b[1m${s}\x1b[0m` : s),
+};
+function icon(status) {
+    switch (status) {
+        case "ok":
+            return c.green("OK  ");
+        case "fail":
+            return c.red("FAIL");
+        case "warn":
+            return c.yellow("WARN");
+    }
+}
+function printCheck(check) {
+    console.log(`  [${icon(check.status)}] ${c.bold(check.name)}`);
+    if (check.detail)
+        console.log(`         ${c.dim(check.detail)}`);
+    if (check.hint)
+        console.log(`         ${c.yellow("hint:")} ${check.hint}`);
+}
+async function checkNodeVersion() {
+    const version = process.versions.node;
+    const major = Number.parseInt(version.split(".")[0], 10);
+    if (Number.isFinite(major) && major >= 18) {
+        return {
+            name: "Node.js version",
+            status: "ok",
+            detail: `v${version} (>=18 required)`,
+        };
+    }
+    return {
+        name: "Node.js version",
+        status: "fail",
+        detail: `v${version} — need Node.js 18 or newer`,
+        hint: "upgrade Node: https://nodejs.org",
+    };
+}
+async function checkPackageVersion() {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.resolve(here, "..", "..", "package.json"),
+            path.resolve(here, "..", "package.json"),
+        ];
+        for (const candidate of candidates) {
+            try {
+                const raw = await fs.readFile(candidate, "utf-8");
+                const pkg = JSON.parse(raw);
+                if (pkg.name === "obsidian-brain-mcp") {
+                    return {
+                        name: "Package version",
+                        status: "ok",
+                        detail: `${pkg.name}@${pkg.version}`,
+                    };
+                }
+            }
+            catch {
+                // try next
+            }
+        }
+        return {
+            name: "Package version",
+            status: "warn",
+            detail: "could not locate package.json",
+        };
+    }
+    catch (error) {
+        return {
+            name: "Package version",
+            status: "warn",
+            detail: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function checkVaultResolution() {
+    try {
+        const resolution = await resolveVault();
+        return {
+            resolution,
+            result: {
+                name: "Vault path resolution",
+                status: "ok",
+                detail: `via ${resolution.strategy}\n         ` +
+                    `vault root: ${resolution.vaultRoot}\n         ` +
+                    `brain base: ${resolution.brainBase}`,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            resolution: null,
+            result: {
+                name: "Vault path resolution",
+                status: "fail",
+                detail: error instanceof Error ? error.message : String(error),
+                hint: 'set OBSIDIAN_BRAIN_VAULT_PATH — example:\n' +
+                    '         export OBSIDIAN_BRAIN_VAULT_PATH="$HOME/Documents/Obsidian Vault/AI Brain"',
+            },
+        };
+    }
+}
+async function checkWritePermission(resolution) {
+    if (!resolution) {
+        return {
+            name: "Vault write permission",
+            status: "warn",
+            detail: "skipped (vault not resolved)",
+        };
+    }
+    const parent = path.dirname(resolution.brainBase);
+    try {
+        await fs.mkdir(resolution.brainBase, { recursive: true });
+    }
+    catch (error) {
+        return {
+            name: "Vault write permission",
+            status: "fail",
+            detail: `cannot create ${resolution.brainBase}: ${error instanceof Error ? error.message : String(error)}`,
+            hint: `check permissions on ${parent}`,
+        };
+    }
+    const probePath = path.join(resolution.brainBase, `.brain-doctor-${process.pid}-${Date.now()}.tmp`);
+    try {
+        await fs.writeFile(probePath, "ok", "utf-8");
+        await fs.unlink(probePath);
+        return {
+            name: "Vault write permission",
+            status: "ok",
+            detail: `wrote + removed ${path.basename(probePath)}`,
+        };
+    }
+    catch (error) {
+        return {
+            name: "Vault write permission",
+            status: "fail",
+            detail: `write probe failed: ${error instanceof Error ? error.message : String(error)}`,
+            hint: `check permissions on ${resolution.brainBase}`,
+        };
+    }
+}
+async function checkBrainStructure(resolution) {
+    if (!resolution) {
+        return {
+            name: "AI Brain structure",
+            status: "warn",
+            detail: "skipped (vault not resolved)",
+        };
+    }
+    const missing = [];
+    const required = [
+        [path.join(resolution.brainBase, "_registry.md"), "_registry.md"],
+        [path.join(resolution.brainBase, "master"), "master/"],
+        [path.join(resolution.brainBase, "master", "beliefs"), "master/beliefs/"],
+        [path.join(resolution.brainBase, "master", "decisions"), "master/decisions/"],
+        [path.join(resolution.brainBase, "master", "patterns"), "master/patterns/"],
+    ];
+    for (const [abs, label] of required) {
+        try {
+            await fs.access(abs);
+        }
+        catch {
+            missing.push(label);
+        }
+    }
+    if (missing.length === 0) {
+        return {
+            name: "AI Brain structure",
+            status: "ok",
+            detail: `_registry.md + master/{beliefs,decisions,patterns} present`,
+        };
+    }
+    return {
+        name: "AI Brain structure",
+        status: "warn",
+        detail: `missing: ${missing.join(", ")}`,
+        hint: "will be auto-created the next time the MCP server starts",
+    };
+}
+async function checkMcpServerLoadable() {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const serverEntry = path.resolve(here, "..", "index.js");
+        try {
+            await fs.access(serverEntry);
+        }
+        catch {
+            return {
+                name: "MCP server entry",
+                status: "fail",
+                detail: `dist/index.js not found at ${serverEntry}`,
+                hint: "run `npm run build`",
+            };
+        }
+        const require = createRequire(import.meta.url);
+        const pkgResolved = require.resolve("@modelcontextprotocol/sdk/package.json");
+        return {
+            name: "MCP server entry",
+            status: "ok",
+            detail: `dist/index.js present; SDK at ${path.dirname(pkgResolved)}`,
+        };
+    }
+    catch (error) {
+        return {
+            name: "MCP server entry",
+            status: "fail",
+            detail: error instanceof Error ? error.message : String(error),
+            hint: "run `npm install && npm run build`",
+        };
+    }
+}
+async function main() {
+    console.log("");
+    console.log(c.cyan(c.bold("  obsidian-brain doctor")));
+    console.log(c.dim(`  running on ${os.platform()} (${os.arch()}) — node ${process.versions.node}`));
+    console.log("");
+    const nodeCheck = await checkNodeVersion();
+    const pkgCheck = await checkPackageVersion();
+    const { result: vaultCheck, resolution } = await checkVaultResolution();
+    const writeCheck = await checkWritePermission(resolution);
+    const structureCheck = await checkBrainStructure(resolution);
+    const serverCheck = await checkMcpServerLoadable();
+    const checks = [
+        nodeCheck,
+        pkgCheck,
+        vaultCheck,
+        writeCheck,
+        structureCheck,
+        serverCheck,
+    ];
+    for (const check of checks) {
+        printCheck(check);
+    }
+    const failures = checks.filter((x) => x.status === "fail").length;
+    const warnings = checks.filter((x) => x.status === "warn").length;
+    console.log("");
+    if (failures === 0 && warnings === 0) {
+        console.log(`  ${c.green("All checks passed.")}`);
+        console.log("");
+        process.exit(0);
+    }
+    if (failures === 0) {
+        console.log(`  ${c.yellow(`Completed with ${warnings} warning${warnings === 1 ? "" : "s"}.`)}`);
+        console.log("");
+        process.exit(0);
+    }
+    console.log(`  ${c.red(`${failures} issue${failures === 1 ? "" : "s"} found`)}` +
+        (warnings > 0
+            ? c.yellow(` (+${warnings} warning${warnings === 1 ? "" : "s"})`)
+            : ""));
+    console.log("");
+    process.exit(1);
+}
+main().catch((error) => {
+    console.error("brain doctor failed:", error);
+    process.exit(1);
+});

package/dist/cli/rebuild-all-indexes.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/rebuild-all-indexes.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { initVault, ensureBrainDir, getAllAgentNames, agentDir, readMarkdown, writeMarkdown, listFiles, rebuildAgentIndex, updateRegistry, computeAgentCounts, } from "../vault.js";
+function extractTitleFromContent(content) {
+    const lines = content.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("# ")) {
+            return trimmed.slice(2).trim();
+        }
+    }
+    return null;
+}
+async function repairFilesInSubdir(agentName, subdir) {
+    const dir = path.join(agentDir(agentName), subdir);
+    const files = await listFiles(dir, ".md");
+    let repaired = 0;
+    for (const file of files) {
+        const full = path.join(dir, file);
+        let data;
+        let content;
+        try {
+            const parsed = await readMarkdown(full);
+            data = parsed.data;
+            content = parsed.content;
+        }
+        catch (err) {
+            process.stderr.write(`  [warn] failed to read ${agentName}/${subdir}/${file}: ${err instanceof Error ? err.message : String(err)}\n`);
+            continue;
+        }
+        const existingTitle = typeof data.title === "string" ? data.title.trim() : "";
+        if (existingTitle.length > 0) {
+            continue;
+        }
+        const basename = file.endsWith(".md") ? file.slice(0, -3) : file;
+        const extracted = extractTitleFromContent(content) ?? (basename.length > 0 ? basename : "Untitled");
+        data.title = extracted;
+        try {
+            await writeMarkdown(full, data, content);
+            repaired += 1;
+            process.stdout.write(`  [fixed] ${agentName}/${subdir}/${file} → title: "${extracted}"\n`);
+        }
+        catch (err) {
+            process.stderr.write(`  [warn] failed to write ${agentName}/${subdir}/${file}: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    return repaired;
+}
+async function main() {
+    process.stdout.write("obsidian-brain-rebuild: starting\n");
+    await initVault();
+    await ensureBrainDir();
+    const agents = await getAllAgentNames();
+    process.stdout.write(`  found ${agents.length} agent(s)\n`);
+    let totalRepaired = 0;
+    let processedAgents = 0;
+    const agentConfigs = [];
+    const countsMap = new Map();
+    for (const name of agents) {
+        process.stdout.write(`\n[agent] ${name}\n`);
+        let repaired = 0;
+        repaired += await repairFilesInSubdir(name, "beliefs");
+        repaired += await repairFilesInSubdir(name, "decisions");
+        repaired += await repairFilesInSubdir(name, "patterns");
+        totalRepaired += repaired;
+        await rebuildAgentIndex(name);
+        processedAgents += 1;
+        try {
+            const { data } = await readMarkdown(path.join(agentDir(name), "_agent.md"));
+            agentConfigs.push({
+                name: data.name ?? name,
+                description: data.description ?? "",
+                scope: data.scope ?? "",
+                created: data.created ?? "",
+            });
+        }
+        catch (err) {
+            process.stderr.write(`  [warn] could not read _agent.md for ${name}: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+        const counts = await computeAgentCounts(name);
+        countsMap.set(name, counts);
+        process.stdout.write(`  [rebuilt] ${name} — beliefs: ${counts.beliefs}, decisions: ${counts.decisions}, patterns: ${counts.patterns} (repaired ${repaired} file(s))\n`);
+    }
+    await updateRegistry(agentConfigs, countsMap);
+    process.stdout.write(`\nobsidian-brain-rebuild: updated _registry.md with counts\n`);
+    process.stdout.write(`obsidian-brain-rebuild: done — ${processedAgents} agent(s), ${totalRepaired} file(s) repaired\n`);
+}
+main().catch((error) => {
+    process.stderr.write(`obsidian-brain-rebuild failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/cli/repair-filenames.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};