obsidian-brain-mcp 0.1.1 → 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/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 {};

package/dist/cli/repair-filenames.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import { initVault, ensureBrainDir, getAllAgentNames, agentDir, readMarkdown, writeMarkdown, listFiles, rebuildAgentIndex, updateRegistry, computeAgentCounts, safeFilename, } 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;
+}
+/**
+ * Compute the expected filename for a knowledge file based on its title
+ * (and date, for decisions). Returns a basename with ".md" extension.
+ *
+ * This does NOT guarantee uniqueness — the caller must handle collisions.
+ */
+function expectedBasename(subdir, title, date) {
+    const titleBase = safeFilename(title);
+    if (subdir === "decisions") {
+        const datePrefix = typeof date === "string" && date.length > 0 ? `${date}-` : "";
+        return safeFilename(`${datePrefix}${titleBase}`) + ".md";
+    }
+    return `${titleBase}.md`;
+}
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Ensure every knowledge file in one subdirectory has a title in
+ * frontmatter, and rename any half-broken filenames (e.g. ".md",
+ * "2026-04-11-.md") to a meaningful name derived from the title.
+ */
+async function repairSubdir(agentName, subdir, stats) {
+    const dir = path.join(agentDir(agentName), subdir);
+    const files = await listFiles(dir, ".md");
+    for (const file of files) {
+        const current = path.join(dir, file);
+        let data;
+        let content;
+        try {
+            const parsed = await readMarkdown(current);
+            data = parsed.data;
+            content = parsed.content;
+        }
+        catch (err) {
+            const msg = `failed to read ${agentName}/${subdir}/${file}: ${err instanceof Error ? err.message : String(err)}`;
+            stats.warnings.push(msg);
+            process.stderr.write(`  [warn] ${msg}\n`);
+            continue;
+        }
+        // 1. Ensure a title exists in the frontmatter.
+        let title = typeof data.title === "string" && data.title.trim().length > 0
+            ? data.title.trim()
+            : null;
+        if (title === null) {
+            const extracted = extractTitleFromContent(content);
+            const basename = file.endsWith(".md") ? file.slice(0, -3) : file;
+            title =
+                extracted && extracted.length > 0
+                    ? extracted
+                    : basename.length > 0
+                        ? basename
+                        : "Untitled";
+            data.title = title;
+            try {
+                await writeMarkdown(current, data, content);
+                stats.titleRepaired += 1;
+                process.stdout.write(`  [title] ${agentName}/${subdir}/${file} → title: "${title}"\n`);
+            }
+            catch (err) {
+                const msg = `failed to write title for ${agentName}/${subdir}/${file}: ${err instanceof Error ? err.message : String(err)}`;
+                stats.warnings.push(msg);
+                process.stderr.write(`  [warn] ${msg}\n`);
+                continue;
+            }
+        }
+        // 2. Compute the expected filename.
+        const date = typeof data.date === "string" && data.date.length > 0
+            ? data.date
+            : undefined;
+        let expected = expectedBasename(subdir, title, date);
+        if (expected === file) {
+            stats.skipped += 1;
+            continue;
+        }
+        // 3. Resolve collisions manually so we don't overwrite a DIFFERENT file
+        //    that happens to share the expected name.
+        let target = path.join(dir, expected);
+        if (await fileExists(target)) {
+            // If the existing file IS actually ourselves (same inode), skip.
+            try {
+                const currentStat = await fs.stat(current);
+                const targetStat = await fs.stat(target);
+                if (currentStat.ino === targetStat.ino &&
+                    currentStat.dev === targetStat.dev) {
+                    stats.skipped += 1;
+                    continue;
+                }
+            }
+            catch {
+                // ignore
+            }
+            // Append -2, -3, ... until we find a free slot.
+            const withoutExt = expected.slice(0, -3);
+            let counter = 2;
+            let candidate = `${withoutExt}-${counter}.md`;
+            while (await fileExists(path.join(dir, candidate))) {
+                counter += 1;
+                candidate = `${withoutExt}-${counter}.md`;
+            }
+            expected = candidate;
+            target = path.join(dir, expected);
+            stats.warnings.push(`collision: ${agentName}/${subdir}/${file} → ${expected} (original ${withoutExt}.md already taken)`);
+            process.stderr.write(`  [collision] ${agentName}/${subdir}/${file} → ${expected}\n`);
+        }
+        // 4. Rename.
+        try {
+            await fs.rename(current, target);
+            stats.renamed += 1;
+            process.stdout.write(`  [renamed] ${agentName}/${subdir}/${file} → ${expected}\n`);
+        }
+        catch (err) {
+            const msg = `failed to rename ${agentName}/${subdir}/${file} → ${expected}: ${err instanceof Error ? err.message : String(err)}`;
+            stats.warnings.push(msg);
+            process.stderr.write(`  [warn] ${msg}\n`);
+        }
+    }
+}
+async function main() {
+    process.stdout.write("obsidian-brain-repair: starting\n");
+    await initVault();
+    await ensureBrainDir();
+    const agents = await getAllAgentNames();
+    process.stdout.write(`  found ${agents.length} agent(s)\n`);
+    const stats = {
+        renamed: 0,
+        titleRepaired: 0,
+        skipped: 0,
+        warnings: [],
+    };
+    for (const name of agents) {
+        process.stdout.write(`\n[agent] ${name}\n`);
+        await repairSubdir(name, "beliefs", stats);
+        await repairSubdir(name, "decisions", stats);
+        await repairSubdir(name, "patterns", stats);
+    }
+    // Rebuild all indexes + registry so the wiki-link paths in _agent.md
+    // match the renamed files.
+    process.stdout.write(`\nrebuilding indexes\n`);
+    const agentConfigs = [];
+    const countsMap = new Map();
+    for (const name of agents) {
+        await rebuildAgentIndex(name);
+        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) {
+            stats.warnings.push(`could not read _agent.md for ${name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        countsMap.set(name, await computeAgentCounts(name));
+        const c = countsMap.get(name);
+        process.stdout.write(`  [rebuilt] ${name} — beliefs: ${c.beliefs}, decisions: ${c.decisions}, patterns: ${c.patterns}\n`);
+    }
+    await updateRegistry(agentConfigs, countsMap);
+    process.stdout.write(`  [registry] _registry.md updated with counts\n`);
+    process.stdout.write(`\nobsidian-brain-repair: done — renamed ${stats.renamed}, title-repaired ${stats.titleRepaired}, skipped ${stats.skipped}, warnings ${stats.warnings.length}\n`);
+    if (stats.warnings.length > 0) {
+        process.stderr.write("\nWarnings:\n");
+        for (const w of stats.warnings) {
+            process.stderr.write(`  - ${w}\n`);
+        }
+    }
+}
+main().catch((error) => {
+    process.stderr.write(`obsidian-brain-repair failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/cli/seed-initial-triggers.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * One-shot CLI to seed UserPromptSubmit triggers on the existing agents.
+ * Idempotent: re-running overwrites the triggers with the definitive map
+ * below and rebuilds each `_agent.md`.
+ */
+export {};

package/dist/cli/seed-initial-triggers.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+/**
+ * One-shot CLI to seed UserPromptSubmit triggers on the existing agents.
+ * Idempotent: re-running overwrites the triggers with the definitive map
+ * below and rebuilds each `_agent.md`.
+ */
+import path from "node:path";
+import { initVault, ensureBrainDir, getAllAgentNames, agentDir, readMarkdown, writeMarkdown, rebuildAgentIndex, } from "../vault.js";
+const TRIGGER_MAP = {
+    uibuilder: [
+        "UIBuilder",
+        "UIビルダー",
+        "レゴブロック",
+        "コンテナ",
+        "Figma",
+        "プレビュー",
+    ],
+    "protagonist-app": [
+        "Protagonist",
+        "主人公",
+        "音声日記",
+        "物語生成",
+        "ストーリーエンジン",
+        "能力値",
+    ],
+    "love-machine": [
+        "Love Machine",
+        "ラブマシーン",
+        "自律AI",
+        "人格",
+        "Claude Agent SDK",
+        "自律ループ",
+    ],
+    "ios-craft": [
+        "iOS",
+        "SwiftUI",
+        "UIKit",
+        "XcodeGen",
+        "InjectionIII",
+        "Xcode",
+        "Swift",
+        "プロジェクト構成",
+        ".build",
+        ".swiftpm",
+        "project.yml",
+        "Bundle",
+        "Team ID",
+    ],
+    "omc-workflow": [
+        "/team",
+        "/fix",
+        "OMC",
+        "oh-my-claudecode",
+        "チーム",
+        "委任",
+        "采配",
+        "TeamCreate",
+        "SendMessage",
+    ],
+    "product-strategy": [
+        "プロダクト戦略",
+        "市場",
+        "Synapse",
+        "Enact",
+        "Grove",
+        "Hearth",
+        "SDT3",
+        "ホワイトスペース",
+    ],
+    master: [],
+    debugger: [
+        "MCP",
+        "settings.json",
+        "環境変数",
+        "nvm",
+        "Node",
+        "Claude Code 設定",
+        "ホットリロード",
+    ],
+};
+async function main() {
+    process.stdout.write("obsidian-brain-seed-triggers: starting\n");
+    await initVault();
+    await ensureBrainDir();
+    const agents = await getAllAgentNames();
+    process.stdout.write(`  found ${agents.length} agent(s)\n`);
+    let updated = 0;
+    let skipped = 0;
+    for (const name of agents) {
+        const triggers = TRIGGER_MAP[name];
+        if (triggers === undefined) {
+            process.stdout.write(`  [skip] ${name} — no entry in TRIGGER_MAP\n`);
+            skipped += 1;
+            continue;
+        }
+        const agentFilePath = path.join(agentDir(name), "_agent.md");
+        try {
+            const { data, content } = await readMarkdown(agentFilePath);
+            const newData = { ...data, triggers };
+            await writeMarkdown(agentFilePath, newData, content);
+            await rebuildAgentIndex(name);
+            process.stdout.write(`  [set] ${name} — ${triggers.length} trigger(s)${triggers.length === 0 ? " (always-on)" : ""}\n`);
+            updated += 1;
+        }
+        catch (err) {
+            process.stderr.write(`  [error] ${name}: ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+    }
+    process.stdout.write(`\nobsidian-brain-seed-triggers: done — updated ${updated}, skipped ${skipped}\n`);
+}
+main().catch((error) => {
+    process.stderr.write(`obsidian-brain-seed-triggers failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/index.js

@@ -17,6 +17,7 @@ import { detectConflicts } from "./tools/detect-conflicts.js";
 import { consolidateMemory } from "./tools/consolidate-memory.js";
 import { agentDialogue } from "./tools/agent-dialogue.js";
 import { importNotes } from "./tools/import-notes.js";
+import { setTriggers } from "./tools/set-triggers.js";
 const server = new Server({ name: "obsidian-brain-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -29,10 +30,31 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                     name: { type: "string", description: "エージェント名" },
                     description: { type: "string", description: "エージェントの説明" },
                     scope: { type: "string", description: "担当スコープ" },
+                    triggers: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "UserPromptSubmit hook 用の自動ロードキーワード（任意）",
+                    },
                 },
                 required: ["name", "description", "scope"],
             },
         },
+        {
+            name: "set_triggers",
+            description: "既存エージェントの UserPromptSubmit トリガーキーワードを設定",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "エージェント名" },
+                    triggers: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "トリガーキーワードの配列（全置換）",
+                    },
+                },
+                required: ["agent", "triggers"],
+            },
+        },
         {
             name: "list_agents",
             description: "全エージェント一覧と統計",
@@ -232,6 +254,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const result = await createAgent(args);
                 return { content: [{ type: "text", text: result }] };
             }
+            case "set_triggers": {
+                const result = await setTriggers(args);
+                return { content: [{ type: "text", text: result }] };
+            }
             case "list_agents": {
                 const result = await listAgents();
                 return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };

package/dist/tools/consolidate-memory.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { agentDir, agentExists, readMarkdown, writeMarkdown, listFiles, } from "../vault.js";
+import { agentDir, agentExists, readMarkdown, writeMarkdown, listFiles, rebuildAgentIndex, } from "../vault.js";
 export async function consolidateMemory(input) {
     const { agent, dry_run = true } = input;
     if (!(await agentExists(agent))) {
@@ -83,5 +83,6 @@ ${entryLines.join("\n")}
         data.archived = true;
         await writeMarkdown(t.file, data, content);
     }
+    await rebuildAgentIndex(agent);
     return `統合完了: ${targets.length}件を ${filename} に統合しました。元ファイルに archived: true を追記済み。`;
 }

package/dist/tools/create-agent.d.ts

@@ -2,5 +2,6 @@ export interface CreateAgentInput {
     name: string;
     description: string;
     scope: string;
+    triggers?: string[];
 }
 export declare function createAgent(input: CreateAgentInput): Promise<string>;

package/dist/tools/create-agent.js

@@ -1,8 +1,8 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { agentDir, agentExists, writeMarkdown, getAllAgentNames, readMarkdown, updateRegistry, } from "../vault.js";
+import { agentDir, agentExists, writeMarkdown, getAllAgentNames, readMarkdown, updateRegistry, rebuildAgentIndex, computeAgentCounts, } from "../vault.js";
 export async function createAgent(input) {
-    const { name, description, scope } = input;
+    const { name, description, scope, triggers } = input;
     if (await agentExists(name)) {
         throw new Error(`Agent "${name}" already exists.`);
     }
@@ -20,19 +20,37 @@ ${description}
 ${scope}
 
 ## 統計
-- Beliefs: 0
+- Beliefs: 0 (active)
 - Decisions: 0
 - Patterns: 0
+
+## 知識目次
+
+### 信念
+（なし）
+
+### 判断
+（なし）
+
+### パターン
+（なし）
 `;
-    await writeMarkdown(path.join(dir, "_agent.md"), {
+    const frontmatter = {
         name,
         description,
         scope,
         created,
-    }, body);
-    // Update registry with all agents
+    };
+    if (Array.isArray(triggers) && triggers.length > 0) {
+        frontmatter.triggers = triggers;
+    }
+    await writeMarkdown(path.join(dir, "_agent.md"), frontmatter, body);
+    // Rebuild index to normalize (even though empty, ensures consistent state)
+    await rebuildAgentIndex(name);
+    // Update registry with all agents + counts
     const allNames = await getAllAgentNames();
     const agents = [];
+    const counts = new Map();
     for (const n of allNames) {
         const { data } = await readMarkdown(path.join(agentDir(n), "_agent.md"));
         agents.push({
@@ -40,8 +58,10 @@ ${scope}
             description: data.description ?? "",
             scope: data.scope ?? "",
             created: data.created ?? "",
+            triggers: Array.isArray(data.triggers) ? data.triggers : undefined,
         });
+        counts.set(n, await computeAgentCounts(n));
     }
-    await updateRegistry(agents);
+    await updateRegistry(agents, counts);
     return `Agent "${name}" created successfully.`;
 }

package/dist/tools/evolve-belief.js

@@ -1,15 +1,13 @@
 import path from "node:path";
-import slugify from "slugify";
-import { agentDir, agentExists, writeMarkdown, readMarkdown, } from "../vault.js";
+import { agentDir, agentExists, writeMarkdown, readMarkdown, rebuildAgentIndex, safeFilenameUnique, } from "../vault.js";
 export async function evolveBelief(input) {
     const { agent, title, content, reasoning, supersedes } = input;
     if (!(await agentExists(agent))) {
         throw new Error(`Agent "${agent}" not found.`);
     }
     const date = new Date().toISOString().slice(0, 10);
-    const slug = slugify(title, { lower: true, strict: true });
-    const newFilename = `${slug}.md`;
     const beliefsDir = path.join(agentDir(agent), "beliefs");
+    const newFilename = await safeFilenameUnique(beliefsDir, title, ".md");
     const newFilePath = path.join(beliefsDir, newFilename);
     // Handle supersedes
     if (supersedes) {
@@ -29,12 +27,14 @@ ${reasoning}
 `;
         await writeMarkdown(newFilePath, {
             type: "belief",
+            title,
             agent,
             confidence: 0.7,
             formed: date,
             supersedes: oldName,
             evidence_count: 1,
         }, body);
+        await rebuildAgentIndex(agent);
         return `Belief evolved: ${oldName} → ${newFilename}`;
     }
     // New belief (no supersedes)
@@ -47,11 +47,13 @@ ${reasoning}
 `;
     await writeMarkdown(newFilePath, {
         type: "belief",
+        title,
         agent,
         confidence: 0.7,
         formed: date,
         supersedes: null,
         evidence_count: 1,
     }, body);
+    await rebuildAgentIndex(agent);
     return `Belief created: ${newFilename}`;
 }

package/dist/tools/import-notes.js

@@ -1,6 +1,5 @@
 import path from "node:path";
-import slugify from "slugify";
-import { agentDir, agentExists, readMarkdown, writeMarkdown, getVaultBase, } from "../vault.js";
+import { agentDir, agentExists, readMarkdown, writeMarkdown, getVaultBase, safeFilenameUnique, } from "../vault.js";
 export async function importNotes(input) {
     const { agent, note_path, import_as } = input;
     if (!(await agentExists(agent))) {
@@ -15,7 +14,6 @@ export async function importNotes(input) {
     // Derive title
     const title = input.title ?? path.basename(resolvedPath, ".md");
     const today = new Date().toISOString().slice(0, 10);
-    const slug = slugify(title, { lower: true, strict: true });
     // Build frontmatter based on import_as, merge with existing (existing takes priority)
     let baseFrontmatter;
     switch (import_as) {
@@ -57,7 +55,8 @@ export async function importNotes(input) {
     mergedFrontmatter.agent = agent;
     // Save to agent directory
     const destDir = path.join(agentDir(agent), `${import_as}s`);
-    const filename = `${slug}.md`;
+    const titleForFile = import_as === "decision" ? `${today}-${title}` : title;
+    const filename = await safeFilenameUnique(destDir, titleForFile, ".md");
     const destPath = path.join(destDir, filename);
     await writeMarkdown(destPath, mergedFrontmatter, content);
     return `インポート完了: ${path.basename(resolvedPath)} → ${agent}/${import_as}s/${filename}`;

package/dist/tools/link-knowledge.js

@@ -1,6 +1,5 @@
 import path from "node:path";
-import slugify from "slugify";
-import { agentDir, agentExists, writeMarkdown } from "../vault.js";
+import { agentDir, agentExists, writeMarkdown, safeFilenameUnique, } from "../vault.js";
 export async function linkKnowledge(input) {
     const { source_agent, source_file, target_agent, target_file, relationship } = input;
     if (!(await agentExists(source_agent))) {
@@ -10,11 +9,8 @@ export async function linkKnowledge(input) {
         throw new Error(`Agent "${target_agent}" not found.`);
     }
     const linkDir = path.join(agentDir(source_agent), "knowledge-links");
-    const slug = slugify(`${source_file}-${relationship}-${target_file}`, {
-        lower: true,
-        strict: true,
-    });
-    const filename = `${slug}.md`;
+    const titleBase = `${source_file}-${relationship}-${target_file}`;
+    const filename = await safeFilenameUnique(linkDir, titleBase, ".md");
     const filePath = path.join(linkDir, filename);
     const body = `[[${source_file}]] --${relationship}--> [[${target_file}]] (${target_agent})
 `;

package/dist/tools/list-agents.js

@@ -9,6 +9,9 @@ export async function listAgents() {
         const beliefs = await listFiles(path.join(dir, "beliefs"), ".md");
         const decisions = await listFiles(path.join(dir, "decisions"), ".md");
         const patterns = await listFiles(path.join(dir, "patterns"), ".md");
+        const triggers = Array.isArray(data.triggers)
+            ? data.triggers.filter((t) => typeof t === "string")
+            : undefined;
         summaries.push({
             name: data.name ?? name,
             description: data.description ?? "",
@@ -16,6 +19,7 @@ export async function listAgents() {
             beliefCount: beliefs.length,
             decisionCount: decisions.length,
             patternCount: patterns.length,
+            triggers,
         });
     }
     return summaries;

package/dist/tools/promote-pattern.js

@@ -1,14 +1,13 @@
 import path from "node:path";
-import slugify from "slugify";
-import { agentDir, agentExists, writeMarkdown } from "../vault.js";
+import { agentDir, agentExists, writeMarkdown, rebuildAgentIndex, safeFilenameUnique, } from "../vault.js";
 export async function promotePattern(input) {
     const { agent, title, description, conditions, decision_refs, confidence } = input;
     if (!(await agentExists(agent))) {
         throw new Error(`Agent "${agent}" not found.`);
     }
-    const slug = slugify(title, { lower: true, strict: true });
-    const filename = `${slug}.md`;
-    const filePath = path.join(agentDir(agent), "patterns", filename);
+    const patternsDir = path.join(agentDir(agent), "patterns");
+    const filename = await safeFilenameUnique(patternsDir, title, ".md");
+    const filePath = path.join(patternsDir, filename);
     const wikilinks = decision_refs
         .map((ref) => {
         const name = ref.endsWith(".md") ? ref.slice(0, -3) : ref;
@@ -27,10 +26,12 @@ ${wikilinks}
 `;
     await writeMarkdown(filePath, {
         type: "pattern",
+        title,
         agent,
         confidence,
         derived_from: decision_refs,
         min_evidence: decision_refs.length,
     }, body);
+    await rebuildAgentIndex(agent);
     return `Pattern promoted: ${filename} (confidence: ${confidence}, based on ${decision_refs.length} decisions)`;
 }

package/dist/tools/record-decision.js

@@ -1,15 +1,15 @@
 import path from "node:path";
-import slugify from "slugify";
-import { agentDir, agentExists, writeMarkdown, readMarkdown, listFiles, } from "../vault.js";
+import { agentDir, agentExists, writeMarkdown, readMarkdown, listFiles, rebuildAgentIndex, safeFilename, safeFilenameUnique, } from "../vault.js";
 export async function recordDecision(input) {
     const { agent, title, context, decision, reasoning, tags } = input;
     if (!(await agentExists(agent))) {
         throw new Error(`Agent "${agent}" not found.`);
     }
     const date = new Date().toISOString().slice(0, 10);
-    const slug = slugify(title, { lower: true, strict: true });
-    const filename = `${date}-${slug}.md`;
-    const filePath = path.join(agentDir(agent), "decisions", filename);
+    const decisionsDir = path.join(agentDir(agent), "decisions");
+    const decisionTitleWithDate = `${date}-${safeFilename(title)}`;
+    const filename = await safeFilenameUnique(decisionsDir, decisionTitleWithDate, ".md");
+    const filePath = path.join(decisionsDir, filename);
     const body = `# ${title}
 
 ## 状況
@@ -26,6 +26,7 @@ pending
 `;
     await writeMarkdown(filePath, {
         type: "decision",
+        title,
         agent,
         tags,
         date,
@@ -51,5 +52,6 @@ pending
             message += `\nパターン昇格の候補があります: タグ[${tag}]で${count}件の判断があります`;
         }
     }
+    await rebuildAgentIndex(agent);
     return message;
 }

package/dist/tools/set-triggers.d.ts

@@ -0,0 +1,5 @@
+export interface SetTriggersInput {
+    agent: string;
+    triggers: string[];
+}
+export declare function setTriggers(input: SetTriggersInput): Promise<string>;

package/dist/tools/set-triggers.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { agentDir, agentExists, readMarkdown, writeMarkdown, rebuildAgentIndex, } from "../vault.js";
+export async function setTriggers(input) {
+    const { agent, triggers } = input;
+    if (!(await agentExists(agent))) {
+        throw new Error(`Agent "${agent}" not found.`);
+    }
+    if (!Array.isArray(triggers)) {
+        throw new Error(`triggers must be an array of strings.`);
+    }
+    const cleaned = triggers
+        .filter((t) => typeof t === "string")
+        .map((t) => t.trim())
+        .filter((t) => t.length > 0);
+    const agentFilePath = path.join(agentDir(agent), "_agent.md");
+    const { data, content } = await readMarkdown(agentFilePath);
+    const newData = { ...data, triggers: cleaned };
+    await writeMarkdown(agentFilePath, newData, content);
+    // Rebuild to regenerate body with the new trigger list.
+    await rebuildAgentIndex(agent);
+    return `Triggers updated for "${agent}": ${cleaned.length} trigger(s).`;
+}

package/dist/types.d.ts

@@ -3,6 +3,7 @@ export interface AgentConfig {
     description: string;
     scope: string;
     created: string;
+    triggers?: string[];
 }
 export interface Belief {
     title: string;
@@ -50,6 +51,7 @@ export interface AgentSummary {
     beliefCount: number;
     decisionCount: number;
     patternCount: number;
+    triggers?: string[];
 }
 export interface KnowledgeLink {
     source_agent: string;

package/dist/vault.d.ts

@@ -17,7 +17,27 @@ export declare function readMarkdown(filePath: string): Promise<{
 }>;
 export declare function writeMarkdown(filePath: string, frontmatter: Record<string, any>, body: string): Promise<void>;
 export declare function listFiles(dir: string, ext?: string): Promise<string[]>;
+/**
+ * Build a safe filesystem-friendly filename from a title.
+ * Preserves Japanese characters, alphanumerics, hyphens and underscores.
+ * Sanitizes OS-unsafe characters and control characters.
+ */
+export declare function safeFilename(title: string): string;
+/**
+ * Given a target directory, a title and an extension (e.g. ".md"),
+ * return a unique basename (without the directory prefix) that does
+ * not collide with any existing file. If a collision is found, append
+ * "-2", "-3", ... to the safe filename.
+ */
+export declare function safeFilenameUnique(dir: string, title: string, extension: string): Promise<string>;
 export declare function agentExists(name: string): Promise<boolean>;
-export declare function updateRegistry(agents: AgentConfig[]): Promise<void>;
+export interface AgentCounts {
+    beliefs: number;
+    decisions: number;
+    patterns: number;
+}
+export declare function updateRegistry(agents: AgentConfig[], counts?: Map<string, AgentCounts>): Promise<void>;
+export declare function rebuildAgentIndex(agentName: string): Promise<void>;
+export declare function computeAgentCounts(agentName: string): Promise<AgentCounts>;
 export declare function getAllAgentNames(): Promise<string[]>;
 export declare function ensureBrainDir(): Promise<void>;

package/dist/vault.js

@@ -138,6 +138,66 @@ export async function listFiles(dir, ext) {
         return [];
     }
 }
+/**
+ * Build a safe filesystem-friendly filename from a title.
+ * Preserves Japanese characters, alphanumerics, hyphens and underscores.
+ * Sanitizes OS-unsafe characters and control characters.
+ */
+export function safeFilename(title) {
+    if (typeof title !== "string") {
+        title = String(title ?? "");
+    }
+    // Strip control characters (U+0000..U+001F and U+007F).
+    let out = "";
+    for (const ch of title) {
+        const code = ch.charCodeAt(0);
+        if (code < 0x20 || code === 0x7f)
+            continue;
+        out += ch;
+    }
+    // Replace OS-unsafe characters with underscore.
+    out = out.replace(/[\/\\:*?"<>|]/g, "_");
+    // Collapse whitespace runs into a single hyphen.
+    out = out.replace(/\s+/g, "-");
+    // Trim leading / trailing whitespace, dots and hyphens.
+    out = out.replace(/^[\s._-]+|[\s._-]+$/g, "");
+    // Truncate to 100 characters (character count, not byte count).
+    if ([...out].length > 100) {
+        out = [...out].slice(0, 100).join("");
+        // Re-trim after truncation in case we ended on a separator.
+        out = out.replace(/[\s._-]+$/g, "");
+    }
+    if (out.length === 0) {
+        const rand = Math.floor(Math.random() * 0xffffff)
+            .toString(16)
+            .padStart(6, "0");
+        out = `untitled-${rand}`;
+    }
+    return out;
+}
+/**
+ * Given a target directory, a title and an extension (e.g. ".md"),
+ * return a unique basename (without the directory prefix) that does
+ * not collide with any existing file. If a collision is found, append
+ * "-2", "-3", ... to the safe filename.
+ */
+export async function safeFilenameUnique(dir, title, extension) {
+    const ext = extension.startsWith(".") ? extension : `.${extension}`;
+    const base = safeFilename(title);
+    let candidate = `${base}${ext}`;
+    let counter = 2;
+    while (true) {
+        const full = path.join(dir, candidate);
+        try {
+            await fs.access(full);
+            candidate = `${base}-${counter}${ext}`;
+            counter += 1;
+        }
+        catch {
+            return candidate;
+        }
+    }
+}
 export async function agentExists(name) {
     try {
         await fs.access(path.join(agentDir(name), "_agent.md"));
@@ -147,9 +207,19 @@ export async function agentExists(name) {
         return false;
     }
 }
-export async function updateRegistry(agents) {
+export async function updateRegistry(agents, counts) {
+    const hasCounts = counts !== undefined && counts.size > 0;
+    const header = hasCounts
+        ? "| エージェント | 説明 | スコープ | Beliefs | Decisions | Patterns |\n|---|---|---|---|---|---|"
+        : "| エージェント | 説明 | スコープ |\n|---|---|---|";
     const rows = agents
-        .map((a) => `| [[${a.name}/_agent\\|${a.name}]] | ${a.description} | ${a.scope} |`)
+        .map((a) => {
+        const base = `| [[${a.name}/_agent\\|${a.name}]] | ${a.description} | ${a.scope} |`;
+        if (!hasCounts)
+            return base;
+        const c = counts.get(a.name) ?? { beliefs: 0, decisions: 0, patterns: 0 };
+        return `${base} ${c.beliefs} | ${c.decisions} | ${c.patterns} |`;
+    })
         .join("\n");
     const body = `# Claude Agents Brain
 
@@ -157,12 +227,163 @@ export async function updateRegistry(agents) {
 
 ## エージェント一覧
 
-| エージェント | 説明 | スコープ |
-|---|---|---|
+${header}
 ${rows}
 `;
     await fs.writeFile(path.join(getVaultBase(), "_registry.md"), body, "utf-8");
 }
+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 collectEntries(agentName, subdir) {
+    const dir = path.join(agentDir(agentName), subdir);
+    const files = await listFiles(dir, ".md");
+    const entries = [];
+    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 {
+            continue;
+        }
+        const basename = file.endsWith(".md") ? file.slice(0, -3) : file;
+        const title = (typeof data.title === "string" && data.title.trim().length > 0
+            ? data.title
+            : null) ??
+            extractTitleFromContent(content) ??
+            basename;
+        entries.push({ basename, title, frontmatter: data });
+    }
+    return entries;
+}
+export async function rebuildAgentIndex(agentName) {
+    const dir = agentDir(agentName);
+    const agentFilePath = path.join(dir, "_agent.md");
+    let existing;
+    try {
+        existing = await readMarkdown(agentFilePath);
+    }
+    catch {
+        return;
+    }
+    const beliefs = await collectEntries(agentName, "beliefs");
+    const decisions = await collectEntries(agentName, "decisions");
+    const patterns = await collectEntries(agentName, "patterns");
+    const activeBeliefs = beliefs.filter((b) => {
+        const sb = b.frontmatter.superseded_by;
+        return sb === undefined || sb === null || sb === "";
+    });
+    const sortedBeliefs = [...activeBeliefs].sort((a, b) => a.title.localeCompare(b.title, "ja"));
+    const sortedDecisions = [...decisions].sort((a, b) => {
+        const da = (a.frontmatter.date ?? "");
+        const db = (b.frontmatter.date ?? "");
+        if (da === db)
+            return a.title.localeCompare(b.title, "ja");
+        return db.localeCompare(da);
+    });
+    const sortedPatterns = [...patterns].sort((a, b) => a.title.localeCompare(b.title, "ja"));
+    const beliefsList = sortedBeliefs.length === 0
+        ? "（なし）"
+        : sortedBeliefs
+            .map((e) => `- [[${agentName}/beliefs/${e.basename}|${e.title}]]`)
+            .join("\n");
+    const decisionsList = sortedDecisions.length === 0
+        ? "（なし）"
+        : sortedDecisions
+            .map((e) => {
+            const date = (e.frontmatter.date ?? "");
+            const prefix = date ? `${date} · ` : "";
+            return `- ${prefix}[[${agentName}/decisions/${e.basename}|${e.title}]]`;
+        })
+            .join("\n");
+    const patternsList = sortedPatterns.length === 0
+        ? "（なし）"
+        : sortedPatterns
+            .map((e) => {
+            const confidence = e.frontmatter.confidence;
+            const confStr = typeof confidence === "number" ? ` (confidence: ${confidence})` : "";
+            return `- [[${agentName}/patterns/${e.basename}|${e.title}]]${confStr}`;
+        })
+            .join("\n");
+    const name = existing.data.name ?? agentName;
+    const description = existing.data.description ?? "";
+    const scope = existing.data.scope ?? "";
+    const triggers = Array.isArray(existing.data.triggers)
+        ? existing.data.triggers.filter((t) => typeof t === "string")
+        : [];
+    const capitalized = name.charAt(0).toUpperCase() + name.slice(1);
+    const today = new Date().toISOString().slice(0, 10);
+    const triggersList = triggers.length === 0
+        ? "（なし）"
+        : triggers.map((t) => `- \`${t}\``).join("\n");
+    const newBody = `# ${capitalized}
+
+${description}
+
+## スコープ
+${scope}
+
+## トリガー
+${triggersList}
+
+## 統計
+- Beliefs: ${activeBeliefs.length} (active)
+- Decisions: ${decisions.length}
+- Patterns: ${patterns.length}
+
+## 知識目次
+
+### 信念
+${beliefsList}
+
+### 判断
+${decisionsList}
+
+### パターン
+${patternsList}
+`;
+    const newFrontmatter = {
+        ...existing.data,
+        updated: today,
+    };
+    await writeMarkdown(agentFilePath, newFrontmatter, newBody);
+}
+export async function computeAgentCounts(agentName) {
+    const dir = agentDir(agentName);
+    const beliefFiles = await listFiles(path.join(dir, "beliefs"), ".md");
+    let activeBeliefs = 0;
+    for (const f of beliefFiles) {
+        try {
+            const { data } = await readMarkdown(path.join(dir, "beliefs", f));
+            const sb = data.superseded_by;
+            if (sb === undefined || sb === null || sb === "") {
+                activeBeliefs += 1;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const decisionFiles = await listFiles(path.join(dir, "decisions"), ".md");
+    const patternFiles = await listFiles(path.join(dir, "patterns"), ".md");
+    return {
+        beliefs: activeBeliefs,
+        decisions: decisionFiles.length,
+        patterns: patternFiles.length,
+    };
+}
 export async function getAllAgentNames() {
     try {
         const entries = await fs.readdir(getVaultBase(), { withFileTypes: true });

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "obsidian-brain-mcp",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "MCP server that turns your Obsidian vault into a domain-specific AI brain with dynamic agent creation, knowledge management, and cross-agent intelligence",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
     "obsidian-brain-mcp": "dist/index.js",
-    "obsidian-brain-doctor": "dist/cli/doctor.js"
+    "obsidian-brain-doctor": "dist/cli/doctor.js",
+    "obsidian-brain-rebuild": "dist/cli/rebuild-all-indexes.js",
+    "obsidian-brain-repair": "dist/cli/repair-filenames.js",
+    "obsidian-brain-auto-load": "dist/cli/brain-auto-load.js",
+    "obsidian-brain-seed-triggers": "dist/cli/seed-initial-triggers.js"
   },
   "files": [
     "dist",
@@ -41,8 +45,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "gray-matter": "^4.0.3",
-    "slugify": "^1.6.6"
+    "gray-matter": "^4.0.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",