obsidian-brain-mcp 0.1.0

package/dist/tools/search-across-agents.js

@@ -0,0 +1,77 @@
+import path from "node:path";
+import { agentDir, getAllAgentNames, readMarkdown, listFiles, } from "../vault.js";
+export async function searchAcrossAgents(input) {
+    const { query } = input;
+    const keywords = query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 1);
+    if (keywords.length === 0) {
+        throw new Error("検索クエリが空です。キーワードを入力してください。");
+    }
+    function matches(text) {
+        const lower = text.toLowerCase();
+        return keywords.some((kw) => lower.includes(kw));
+    }
+    const agents = await getAllAgentNames();
+    const results = new Map();
+    for (const agent of agents) {
+        const dir = agentDir(agent);
+        const items = [];
+        // Search beliefs (active only)
+        const beliefFiles = await listFiles(path.join(dir, "beliefs"), ".md");
+        for (const file of beliefFiles) {
+            const { data, content } = await readMarkdown(path.join(dir, "beliefs", file));
+            if (data.superseded_by)
+                continue;
+            const searchable = `${data.title ?? ""} ${content}`;
+            if (matches(searchable)) {
+                items.push({
+                    type: "belief",
+                    title: data.title ?? file.replace(/\.md$/, ""),
+                    summary: content.trim().slice(0, 120),
+                });
+            }
+        }
+        // Search decisions
+        const decisionFiles = await listFiles(path.join(dir, "decisions"), ".md");
+        for (const file of decisionFiles) {
+            const { data, content } = await readMarkdown(path.join(dir, "decisions", file));
+            const searchable = `${data.title ?? ""} ${content}`;
+            if (matches(searchable)) {
+                items.push({
+                    type: "decision",
+                    title: data.title ?? file.replace(/\.md$/, ""),
+                    summary: (data.decision ?? content.trim()).slice(0, 120),
+                });
+            }
+        }
+        // Search patterns
+        const patternFiles = await listFiles(path.join(dir, "patterns"), ".md");
+        for (const file of patternFiles) {
+            const { data, content } = await readMarkdown(path.join(dir, "patterns", file));
+            const searchable = `${data.title ?? ""} ${content}`;
+            if (matches(searchable)) {
+                items.push({
+                    type: "pattern",
+                    title: data.title ?? file.replace(/\.md$/, ""),
+                    summary: (data.description ?? content.trim()).slice(0, 120),
+                });
+            }
+        }
+        if (items.length > 0) {
+            results.set(agent, items);
+        }
+    }
+    if (results.size === 0) {
+        return `「${query}」に該当する知識はどのエージェントにも見つかりませんでした。`;
+    }
+    const sections = [`## 横断検索結果: "${query}"`];
+    for (const [agent, items] of results) {
+        sections.push(`\n### ${agent}`);
+        for (const item of items) {
+            sections.push(`- [${item.type}] **${item.title}**: ${item.summary}`);
+        }
+    }
+    return sections.join("\n");
+}

package/dist/tools/suggest-agents.d.ts

@@ -0,0 +1,4 @@
+export interface SuggestAgentsInput {
+    task: string;
+}
+export declare function suggestAgents(input: SuggestAgentsInput): Promise<string[]>;

package/dist/tools/suggest-agents.js

@@ -0,0 +1,28 @@
+import path from "node:path";
+import { agentDir, getAllAgentNames, readMarkdown } from "../vault.js";
+export async function suggestAgents(input) {
+    const names = await getAllAgentNames();
+    const taskWords = input.task
+        .toLowerCase()
+        .split(/[\s,.\-_/]+/)
+        .filter((w) => w.length > 1);
+    const scored = [];
+    for (const name of names) {
+        const { data } = await readMarkdown(path.join(agentDir(name), "_agent.md"));
+        const haystack = `${data.scope ?? ""} ${data.description ?? ""}`.toLowerCase();
+        let score = 0;
+        for (const word of taskWords) {
+            if (haystack.includes(word)) {
+                score++;
+            }
+        }
+        if (score > 0) {
+            scored.push({ name, score });
+        }
+    }
+    if (scored.length === 0) {
+        return ["master"];
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.map((s) => s.name);
+}

package/dist/types.d.ts

@@ -0,0 +1,70 @@
+export interface AgentConfig {
+    name: string;
+    description: string;
+    scope: string;
+    created: string;
+}
+export interface Belief {
+    title: string;
+    content: string;
+    agent: string;
+    confidence: number;
+    formed: string;
+    reasoning: string;
+    supersedes?: string;
+    superseded_by?: string;
+    evidence_count: number;
+    filename: string;
+}
+export interface Decision {
+    title: string;
+    agent: string;
+    context: string;
+    decision: string;
+    reasoning: string;
+    tags: string[];
+    date: string;
+    outcome: string;
+    filename: string;
+}
+export interface Pattern {
+    title: string;
+    agent: string;
+    description: string;
+    conditions: string;
+    confidence: number;
+    derived_from: string[];
+    min_evidence: number;
+    filename: string;
+}
+export interface AgentContext {
+    identity: AgentConfig;
+    beliefs: Belief[];
+    decisions: Decision[];
+    patterns: Pattern[];
+}
+export interface AgentSummary {
+    name: string;
+    description: string;
+    scope: string;
+    beliefCount: number;
+    decisionCount: number;
+    patternCount: number;
+}
+export interface KnowledgeLink {
+    source_agent: string;
+    source_file: string;
+    target_agent: string;
+    target_file: string;
+    relationship: string;
+    created: string;
+    filename: string;
+}
+export interface Consolidation {
+    agent: string;
+    source_count: number;
+    date_range: string;
+    created: string;
+    sources?: string[];
+    filename: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vault.d.ts

@@ -0,0 +1,13 @@
+import { AgentConfig } from "./types.js";
+export declare const VAULT_BASE: string;
+export declare function agentDir(name: string): string;
+export declare function readMarkdown(filePath: string): Promise<{
+    data: Record<string, any>;
+    content: string;
+}>;
+export declare function writeMarkdown(filePath: string, frontmatter: Record<string, any>, body: string): Promise<void>;
+export declare function listFiles(dir: string, ext?: string): Promise<string[]>;
+export declare function agentExists(name: string): Promise<boolean>;
+export declare function updateRegistry(agents: AgentConfig[]): Promise<void>;
+export declare function getAllAgentNames(): Promise<string[]>;
+export declare function ensureBrainDir(): Promise<void>;

package/dist/vault.js

@@ -0,0 +1,131 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import matter from "gray-matter";
+function getVaultBase() {
+    const vaultPath = process.env.OBSIDIAN_BRAIN_VAULT_PATH;
+    if (!vaultPath) {
+        throw new Error("OBSIDIAN_BRAIN_VAULT_PATH environment variable is not set. " +
+            "Set it to your Obsidian vault path where agent brains will be stored. " +
+            'Example: export OBSIDIAN_BRAIN_VAULT_PATH="/path/to/your/vault/AI Brain"');
+    }
+    return vaultPath;
+}
+export const VAULT_BASE = getVaultBase();
+const MASTER_AGENT = {
+    name: "master",
+    description: "Root agent that oversees all domain agents and manages cross-cutting concerns",
+    scope: "Global coordination, agent management, cross-domain knowledge",
+    created: "2026-04-11",
+};
+export function agentDir(name) {
+    return path.join(VAULT_BASE, name);
+}
+export async function readMarkdown(filePath) {
+    const raw = await fs.readFile(filePath, "utf-8");
+    const parsed = matter(raw);
+    return { data: parsed.data, content: parsed.content };
+}
+export async function writeMarkdown(filePath, frontmatter, body) {
+    const content = matter.stringify(body, frontmatter);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, content, "utf-8");
+}
+export async function listFiles(dir, ext) {
+    try {
+        const entries = await fs.readdir(dir);
+        if (ext) {
+            return entries.filter((e) => e.endsWith(ext));
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+export async function agentExists(name) {
+    try {
+        await fs.access(path.join(agentDir(name), "_agent.md"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function updateRegistry(agents) {
+    const rows = agents
+        .map((a) => `| [[${a.name}/_agent\\|${a.name}]] | ${a.description} | ${a.scope} |`)
+        .join("\n");
+    const body = `# Claude Agents Brain
+
+個人の判断・信念・パターンを構造化するエージェント群
+
+## エージェント一覧
+
+| エージェント | 説明 | スコープ |
+|---|---|---|
+${rows}
+`;
+    await fs.writeFile(path.join(VAULT_BASE, "_registry.md"), body, "utf-8");
+}
+export async function getAllAgentNames() {
+    try {
+        const entries = await fs.readdir(VAULT_BASE, { withFileTypes: true });
+        const names = [];
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const agentFile = path.join(VAULT_BASE, entry.name, "_agent.md");
+                try {
+                    await fs.access(agentFile);
+                    names.push(entry.name);
+                }
+                catch {
+                    // not an agent directory
+                }
+            }
+        }
+        return names;
+    }
+    catch {
+        return [];
+    }
+}
+export async function ensureBrainDir() {
+    await fs.mkdir(VAULT_BASE, { recursive: true });
+    const masterExists = await agentExists("master");
+    if (!masterExists) {
+        const masterPath = agentDir("master");
+        await fs.mkdir(path.join(masterPath, "beliefs"), { recursive: true });
+        await fs.mkdir(path.join(masterPath, "decisions"), { recursive: true });
+        await fs.mkdir(path.join(masterPath, "patterns"), { recursive: true });
+        const agentBody = `# Master
+
+核となる人格・価値観・アイデンティティ
+
+## スコープ
+人としての根本的な価値観、美意識、思考の癖、人生の方向性
+
+## 統計
+- Beliefs: 0
+- Decisions: 0
+- Patterns: 0
+`;
+        await writeMarkdown(path.join(masterPath, "_agent.md"), {
+            name: MASTER_AGENT.name,
+            description: MASTER_AGENT.description,
+            scope: MASTER_AGENT.scope,
+            created: MASTER_AGENT.created,
+        }, agentBody);
+    }
+    // Ensure _registry.md exists
+    const registryPath = path.join(VAULT_BASE, "_registry.md");
+    try {
+        await fs.access(registryPath);
+    }
+    catch {
+        const agents = [];
+        if (await agentExists("master")) {
+            agents.push(MASTER_AGENT);
+        }
+        await updateRegistry(agents);
+    }
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "obsidian-brain-mcp",
+  "version": "0.1.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"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mcp",
+    "obsidian",
+    "ai",
+    "agent",
+    "knowledge-management",
+    "model-context-protocol",
+    "claude"
+  ],
+  "license": "MIT",
+  "author": "HikaruHonda",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AtsushiHosaka/obsidian-brain-mcp"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "gray-matter": "^4.0.3",
+    "slugify": "^1.6.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}