obsidian-brain-mcp 0.1.0

package/dist/tools/create-agent.js

@@ -0,0 +1,47 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { agentDir, agentExists, writeMarkdown, getAllAgentNames, readMarkdown, updateRegistry, } from "../vault.js";
+export async function createAgent(input) {
+    const { name, description, scope } = input;
+    if (await agentExists(name)) {
+        throw new Error(`Agent "${name}" already exists.`);
+    }
+    const dir = agentDir(name);
+    await fs.mkdir(path.join(dir, "beliefs"), { recursive: true });
+    await fs.mkdir(path.join(dir, "decisions"), { recursive: true });
+    await fs.mkdir(path.join(dir, "patterns"), { recursive: true });
+    const created = new Date().toISOString().slice(0, 10);
+    const capitalized = name.charAt(0).toUpperCase() + name.slice(1);
+    const body = `# ${capitalized}
+
+${description}
+
+## スコープ
+${scope}
+
+## 統計
+- Beliefs: 0
+- Decisions: 0
+- Patterns: 0
+`;
+    await writeMarkdown(path.join(dir, "_agent.md"), {
+        name,
+        description,
+        scope,
+        created,
+    }, body);
+    // Update registry with all agents
+    const allNames = await getAllAgentNames();
+    const agents = [];
+    for (const n of allNames) {
+        const { data } = await readMarkdown(path.join(agentDir(n), "_agent.md"));
+        agents.push({
+            name: data.name ?? n,
+            description: data.description ?? "",
+            scope: data.scope ?? "",
+            created: data.created ?? "",
+        });
+    }
+    await updateRegistry(agents);
+    return `Agent "${name}" created successfully.`;
+}

package/dist/tools/detect-conflicts.d.ts

@@ -0,0 +1,4 @@
+export interface DetectConflictsInput {
+    agent?: string;
+}
+export declare function detectConflicts(input: DetectConflictsInput): Promise<string>;

package/dist/tools/detect-conflicts.js

@@ -0,0 +1,75 @@
+import path from "node:path";
+import { agentDir, agentExists, getAllAgentNames, readMarkdown, listFiles, } from "../vault.js";
+function extractKeywords(text) {
+    const words = text
+        .toLowerCase()
+        .split(/[\s,.\-;:!?()[\]{}'"、。・「」（）]+/)
+        .filter((w) => w.length > 1);
+    return new Set(words);
+}
+export async function detectConflicts(input) {
+    const agents = input.agent != null
+        ? [input.agent]
+        : await getAllAgentNames();
+    if (input.agent != null && !(await agentExists(input.agent))) {
+        throw new Error(`Agent "${input.agent}" not found.`);
+    }
+    // Collect all active beliefs with keywords
+    const allBeliefs = [];
+    for (const agent of agents) {
+        const dir = agentDir(agent);
+        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 belief = {
+                title: data.title ?? file.replace(/\.md$/, ""),
+                content: content.trim(),
+                agent: data.agent ?? agent,
+                confidence: data.confidence ?? 0,
+                formed: data.formed ?? "",
+                reasoning: data.reasoning ?? "",
+                supersedes: data.supersedes,
+                superseded_by: data.superseded_by,
+                evidence_count: data.evidence_count ?? 0,
+                filename: file,
+            };
+            const text = `${belief.title} ${belief.content}`;
+            const keywords = extractKeywords(text);
+            allBeliefs.push({ belief, keywords });
+        }
+    }
+    // Find pairs with 3+ shared keywords
+    const conflicts = [];
+    for (let i = 0; i < allBeliefs.length; i++) {
+        for (let j = i + 1; j < allBeliefs.length; j++) {
+            const a = allBeliefs[i];
+            const b = allBeliefs[j];
+            const shared = [];
+            for (const kw of a.keywords) {
+                if (b.keywords.has(kw)) {
+                    shared.push(kw);
+                }
+            }
+            if (shared.length >= 3) {
+                conflicts.push({
+                    a: a.belief,
+                    b: b.belief,
+                    sharedKeywords: shared,
+                    confidenceDiff: Math.abs(a.belief.confidence - b.belief.confidence),
+                });
+            }
+        }
+    }
+    if (conflicts.length === 0) {
+        return "矛盾候補は検出されませんでした。";
+    }
+    // Sort by confidence difference descending
+    conflicts.sort((x, y) => y.confidenceDiff - x.confidenceDiff);
+    const sections = [`## 矛盾候補の検出結果`];
+    for (const c of conflicts) {
+        sections.push(`\n- **${c.a.title}** (${c.a.agent}, confidence: ${c.a.confidence}) vs **${c.b.title}** (${c.b.agent}, confidence: ${c.b.confidence})\n  共有キーワード: ${c.sharedKeywords.join(", ")}`);
+    }
+    return sections.join("\n");
+}

package/dist/tools/evolve-belief.d.ts

@@ -0,0 +1,8 @@
+export interface EvolveBeliefInput {
+    agent: string;
+    title: string;
+    content: string;
+    reasoning: string;
+    supersedes?: string;
+}
+export declare function evolveBelief(input: EvolveBeliefInput): Promise<string>;

package/dist/tools/evolve-belief.js

@@ -0,0 +1,57 @@
+import path from "node:path";
+import slugify from "slugify";
+import { agentDir, agentExists, writeMarkdown, readMarkdown, } 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 newFilePath = path.join(beliefsDir, newFilename);
+    // Handle supersedes
+    if (supersedes) {
+        const oldName = supersedes.endsWith(".md") ? supersedes : `${supersedes}.md`;
+        const oldPath = path.join(beliefsDir, oldName);
+        // Read old belief and mark as superseded
+        const { data: oldData, content: oldContent } = await readMarkdown(oldPath);
+        oldData.superseded_by = newFilename;
+        await writeMarkdown(oldPath, oldData, oldContent);
+        // Create new belief with supersedes reference
+        const body = `# ${title}
+
+${content}
+
+## 根拠
+${reasoning}
+`;
+        await writeMarkdown(newFilePath, {
+            type: "belief",
+            agent,
+            confidence: 0.7,
+            formed: date,
+            supersedes: oldName,
+            evidence_count: 1,
+        }, body);
+        return `Belief evolved: ${oldName} → ${newFilename}`;
+    }
+    // New belief (no supersedes)
+    const body = `# ${title}
+
+${content}
+
+## 根拠
+${reasoning}
+`;
+    await writeMarkdown(newFilePath, {
+        type: "belief",
+        agent,
+        confidence: 0.7,
+        formed: date,
+        supersedes: null,
+        evidence_count: 1,
+    }, body);
+    return `Belief created: ${newFilename}`;
+}

package/dist/tools/get-agent-context.d.ts

@@ -0,0 +1,2 @@
+import { AgentContext } from "../types.js";
+export declare function getAgentContext(agentName: string): Promise<AgentContext>;

package/dist/tools/get-agent-context.js

@@ -0,0 +1,70 @@
+import path from "node:path";
+import { agentDir, agentExists, readMarkdown, listFiles } from "../vault.js";
+export async function getAgentContext(agentName) {
+    if (!(await agentExists(agentName))) {
+        throw new Error(`Agent "${agentName}" not found.`);
+    }
+    const dir = agentDir(agentName);
+    // Identity
+    const { data: agentData } = await readMarkdown(path.join(dir, "_agent.md"));
+    const identity = {
+        name: agentData.name ?? agentName,
+        description: agentData.description ?? "",
+        scope: agentData.scope ?? "",
+        created: agentData.created ?? "",
+    };
+    // Beliefs (active only — exclude superseded)
+    const beliefFiles = await listFiles(path.join(dir, "beliefs"), ".md");
+    const allBeliefs = [];
+    for (const file of beliefFiles) {
+        const { data, content } = await readMarkdown(path.join(dir, "beliefs", file));
+        allBeliefs.push({
+            title: data.title ?? "",
+            content: content.trim(),
+            agent: data.agent ?? agentName,
+            confidence: data.confidence ?? 0,
+            formed: data.formed ?? "",
+            reasoning: data.reasoning ?? "",
+            supersedes: data.supersedes,
+            superseded_by: data.superseded_by,
+            evidence_count: data.evidence_count ?? 0,
+            filename: file,
+        });
+    }
+    const beliefs = allBeliefs.filter((b) => !b.superseded_by);
+    // Decisions (sorted by date descending)
+    const decisionFiles = await listFiles(path.join(dir, "decisions"), ".md");
+    const decisions = [];
+    for (const file of decisionFiles) {
+        const { data, content } = await readMarkdown(path.join(dir, "decisions", file));
+        decisions.push({
+            title: data.title ?? "",
+            agent: data.agent ?? agentName,
+            context: data.context ?? "",
+            decision: data.decision ?? "",
+            reasoning: data.reasoning ?? "",
+            tags: data.tags ?? [],
+            date: data.date ?? "",
+            outcome: data.outcome ?? "",
+            filename: file,
+        });
+    }
+    decisions.sort((a, b) => (b.date > a.date ? 1 : b.date < a.date ? -1 : 0));
+    // Patterns
+    const patternFiles = await listFiles(path.join(dir, "patterns"), ".md");
+    const patterns = [];
+    for (const file of patternFiles) {
+        const { data, content } = await readMarkdown(path.join(dir, "patterns", file));
+        patterns.push({
+            title: data.title ?? "",
+            agent: data.agent ?? agentName,
+            description: data.description ?? "",
+            conditions: data.conditions ?? "",
+            confidence: data.confidence ?? 0,
+            derived_from: data.derived_from ?? [],
+            min_evidence: data.min_evidence ?? 0,
+            filename: file,
+        });
+    }
+    return { identity, beliefs, decisions, patterns };
+}

package/dist/tools/import-notes.d.ts

@@ -0,0 +1,7 @@
+export interface ImportNotesInput {
+    agent: string;
+    note_path: string;
+    import_as: "belief" | "decision" | "pattern";
+    title?: string;
+}
+export declare function importNotes(input: ImportNotesInput): Promise<string>;

package/dist/tools/import-notes.js

@@ -0,0 +1,64 @@
+import path from "node:path";
+import slugify from "slugify";
+import { agentDir, agentExists, readMarkdown, writeMarkdown, VAULT_BASE, } from "../vault.js";
+export async function importNotes(input) {
+    const { agent, note_path, import_as } = input;
+    if (!(await agentExists(agent))) {
+        throw new Error(`Agent "${agent}" not found.`);
+    }
+    // Resolve note path
+    const resolvedPath = path.isAbsolute(note_path)
+        ? note_path
+        : path.join(VAULT_BASE, note_path);
+    // Read the source note
+    const { data: existingData, content } = await readMarkdown(resolvedPath);
+    // 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) {
+        case "belief":
+            baseFrontmatter = {
+                type: "belief",
+                agent,
+                confidence: 0.7,
+                formed: today,
+                evidence_count: 1,
+                title,
+            };
+            break;
+        case "decision":
+            baseFrontmatter = {
+                type: "decision",
+                agent,
+                date: today,
+                tags: [],
+                outcome: "imported",
+                title,
+            };
+            break;
+        case "pattern":
+            baseFrontmatter = {
+                type: "pattern",
+                agent,
+                confidence: 0.5,
+                derived_from: [note_path],
+                min_evidence: 1,
+                title,
+            };
+            break;
+    }
+    // Merge: existing frontmatter fields take priority over base
+    const mergedFrontmatter = { ...baseFrontmatter, ...existingData };
+    // Ensure type and agent are always set correctly
+    mergedFrontmatter.type = import_as;
+    mergedFrontmatter.agent = agent;
+    // Save to agent directory
+    const destDir = path.join(agentDir(agent), `${import_as}s`);
+    const filename = `${slug}.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.d.ts

@@ -0,0 +1,8 @@
+export interface LinkKnowledgeInput {
+    source_agent: string;
+    source_file: string;
+    target_agent: string;
+    target_file: string;
+    relationship: string;
+}
+export declare function linkKnowledge(input: LinkKnowledgeInput): Promise<string>;

package/dist/tools/link-knowledge.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import slugify from "slugify";
+import { agentDir, agentExists, writeMarkdown } from "../vault.js";
+export async function linkKnowledge(input) {
+    const { source_agent, source_file, target_agent, target_file, relationship } = input;
+    if (!(await agentExists(source_agent))) {
+        throw new Error(`Agent "${source_agent}" not found.`);
+    }
+    if (!(await agentExists(target_agent))) {
+        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 filePath = path.join(linkDir, filename);
+    const body = `[[${source_file}]] --${relationship}--> [[${target_file}]] (${target_agent})
+`;
+    await writeMarkdown(filePath, {
+        type: "link",
+        source_agent,
+        source_file,
+        target_agent,
+        target_file,
+        relationship,
+        created: new Date().toISOString().slice(0, 10),
+    }, body);
+    return `Knowledge link created: ${filename} (${source_agent}/${source_file} --${relationship}--> ${target_agent}/${target_file})`;
+}

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

@@ -0,0 +1,2 @@
+import { AgentSummary } from "../types.js";
+export declare function listAgents(): Promise<AgentSummary[]>;

package/dist/tools/list-agents.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { agentDir, getAllAgentNames, readMarkdown, listFiles, } from "../vault.js";
+export async function listAgents() {
+    const names = await getAllAgentNames();
+    const summaries = [];
+    for (const name of names) {
+        const dir = agentDir(name);
+        const { data } = await readMarkdown(path.join(dir, "_agent.md"));
+        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");
+        summaries.push({
+            name: data.name ?? name,
+            description: data.description ?? "",
+            scope: data.scope ?? "",
+            beliefCount: beliefs.length,
+            decisionCount: decisions.length,
+            patternCount: patterns.length,
+        });
+    }
+    return summaries;
+}

package/dist/tools/promote-pattern.d.ts

@@ -0,0 +1,9 @@
+export interface PromotePatternInput {
+    agent: string;
+    title: string;
+    description: string;
+    conditions: string;
+    decision_refs: string[];
+    confidence: number;
+}
+export declare function promotePattern(input: PromotePatternInput): Promise<string>;

package/dist/tools/promote-pattern.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import slugify from "slugify";
+import { agentDir, agentExists, writeMarkdown } 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 wikilinks = decision_refs
+        .map((ref) => {
+        const name = ref.endsWith(".md") ? ref.slice(0, -3) : ref;
+        return `- [[${name}]]`;
+    })
+        .join("\n");
+    const body = `# ${title}
+
+${description}
+
+## 適用条件
+${conditions}
+
+## 根拠となる判断
+${wikilinks}
+`;
+    await writeMarkdown(filePath, {
+        type: "pattern",
+        agent,
+        confidence,
+        derived_from: decision_refs,
+        min_evidence: decision_refs.length,
+    }, body);
+    return `Pattern promoted: ${filename} (confidence: ${confidence}, based on ${decision_refs.length} decisions)`;
+}

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

@@ -0,0 +1,5 @@
+export interface QueryAgentInput {
+    agent: string;
+    question: string;
+}
+export declare function queryAgent(input: QueryAgentInput): Promise<string>;

package/dist/tools/query-agent.js

@@ -0,0 +1,109 @@
+import path from "node:path";
+import { agentDir, agentExists, readMarkdown, listFiles, } from "../vault.js";
+export async function queryAgent(input) {
+    const { agent, question } = input;
+    if (!(await agentExists(agent))) {
+        throw new Error(`Agent "${agent}" not found.`);
+    }
+    const dir = agentDir(agent);
+    const keywords = question
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 1);
+    function matches(text) {
+        const lower = text.toLowerCase();
+        return keywords.some((kw) => lower.includes(kw));
+    }
+    // Read patterns
+    const patternFiles = await listFiles(path.join(dir, "patterns"), ".md");
+    const matchedPatterns = [];
+    for (const file of patternFiles) {
+        const { data, content } = await readMarkdown(path.join(dir, "patterns", file));
+        const tags = (data.tags ?? []).join(" ");
+        const searchable = `${data.title ?? ""} ${data.description ?? ""} ${tags} ${content}`;
+        if (matches(searchable)) {
+            matchedPatterns.push({
+                title: data.title ?? file.replace(/\.md$/, ""),
+                agent: data.agent ?? agent,
+                description: data.description ?? content.trim(),
+                conditions: data.conditions ?? "",
+                confidence: data.confidence ?? 0,
+                derived_from: data.derived_from ?? [],
+                min_evidence: data.min_evidence ?? 0,
+                filename: file,
+            });
+        }
+    }
+    // Read beliefs (active only)
+    const beliefFiles = await listFiles(path.join(dir, "beliefs"), ".md");
+    const matchedBeliefs = [];
+    for (const file of beliefFiles) {
+        const { data, content } = await readMarkdown(path.join(dir, "beliefs", file));
+        if (data.superseded_by)
+            continue;
+        const tags = (data.tags ?? []).join(" ");
+        const searchable = `${data.title ?? ""} ${tags} ${content}`;
+        if (matches(searchable)) {
+            matchedBeliefs.push({
+                title: data.title ?? file.replace(/\.md$/, ""),
+                content: content.trim(),
+                agent: data.agent ?? agent,
+                confidence: data.confidence ?? 0,
+                formed: data.formed ?? "",
+                reasoning: data.reasoning ?? "",
+                supersedes: data.supersedes,
+                superseded_by: data.superseded_by,
+                evidence_count: data.evidence_count ?? 0,
+                filename: file,
+            });
+        }
+    }
+    // Read decisions
+    const decisionFiles = await listFiles(path.join(dir, "decisions"), ".md");
+    const matchedDecisions = [];
+    for (const file of decisionFiles) {
+        const { data, content } = await readMarkdown(path.join(dir, "decisions", file));
+        const tags = (data.tags ?? []).join(" ");
+        const searchable = `${data.title ?? ""} ${tags} ${content}`;
+        if (matches(searchable)) {
+            matchedDecisions.push({
+                title: data.title ?? file.replace(/\.md$/, ""),
+                agent: data.agent ?? agent,
+                context: data.context ?? "",
+                decision: data.decision ?? "",
+                reasoning: data.reasoning ?? "",
+                tags: data.tags ?? [],
+                date: data.date ?? "",
+                outcome: data.outcome ?? "",
+                filename: file,
+            });
+        }
+    }
+    matchedDecisions.sort((a, b) => b.date > a.date ? 1 : b.date < a.date ? -1 : 0);
+    // Build response
+    const sections = [`## ${agent} の知識`];
+    if (matchedPatterns.length > 0) {
+        sections.push("\n### パターン");
+        for (const p of matchedPatterns) {
+            sections.push(`- ${p.title}: ${p.description} (confidence: ${p.confidence})`);
+        }
+    }
+    if (matchedBeliefs.length > 0) {
+        sections.push("\n### 信念");
+        for (const b of matchedBeliefs) {
+            sections.push(`- ${b.title}: ${b.content} (confidence: ${b.confidence})`);
+        }
+    }
+    if (matchedDecisions.length > 0) {
+        sections.push("\n### 関連する判断");
+        for (const d of matchedDecisions) {
+            sections.push(`- [${d.date}] ${d.title}: ${d.decision}`);
+        }
+    }
+    if (matchedPatterns.length === 0 &&
+        matchedBeliefs.length === 0 &&
+        matchedDecisions.length === 0) {
+        sections.push(`\n「${question}」に関連する知識は見つかりませんでした。`);
+    }
+    return sections.join("\n");
+}

package/dist/tools/record-decision.d.ts

@@ -0,0 +1,9 @@
+export interface RecordDecisionInput {
+    agent: string;
+    title: string;
+    context: string;
+    decision: string;
+    reasoning: string;
+    tags: string[];
+}
+export declare function recordDecision(input: RecordDecisionInput): Promise<string>;

package/dist/tools/record-decision.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import slugify from "slugify";
+import { agentDir, agentExists, writeMarkdown, readMarkdown, listFiles, } 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 body = `# ${title}
+
+## 状況
+${context}
+
+## 判断
+${decision}
+
+## 理由
+${reasoning}
+
+## 結果
+pending
+`;
+    await writeMarkdown(filePath, {
+        type: "decision",
+        agent,
+        tags,
+        date,
+        outcome: "pending",
+    }, body);
+    // Check for pattern promotion candidates
+    let message = `Decision recorded: ${filename}`;
+    const decisionDir = path.join(agentDir(agent), "decisions");
+    const files = await listFiles(decisionDir, ".md");
+    const tagCounts = new Map();
+    for (const file of files) {
+        const { data } = await readMarkdown(path.join(decisionDir, file));
+        const fileTags = data.tags ?? [];
+        for (const tag of tags) {
+            if (fileTags.includes(tag)) {
+                tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
+            }
+        }
+    }
+    const promotionCandidates = [...tagCounts.entries()].filter(([, count]) => count >= 3);
+    if (promotionCandidates.length > 0) {
+        for (const [tag, count] of promotionCandidates) {
+            message += `\nパターン昇格の候補があります: タグ[${tag}]で${count}件の判断があります`;
+        }
+    }
+    return message;
+}

package/dist/tools/search-across-agents.d.ts

@@ -0,0 +1,4 @@
+export interface SearchAcrossAgentsInput {
+    query: string;
+}
+export declare function searchAcrossAgents(input: SearchAcrossAgentsInput): Promise<string>;