@unson/brainbase-mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,185 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { resolveDataDir } from './paths.js';
+import { auditPersonalOsDirectory } from './ontology-ssot.js';
+import { getOntologyImpact, inferPersonalOs, portableOntology, resolveOntologyVersion } from './ontology.js';
+import { loadPersonalOs } from './ssot.js';
+import { getContext, listEntities, onboardingStatus, searchAll, searchPersonalKg } from './tools.js';
+const argsSchema = z.object({
+    dataDir: z.string().optional(),
+    query: z.string().optional(),
+    limit: z.number().int().positive().max(50).optional(),
+    type: z.enum(['person', 'org', 'project', 'relationship', 'decision']).optional(),
+    fromVersion: z.string().optional(),
+    ontologyVersion: z.string().optional(),
+    asOf: z.string().datetime({ offset: true }).optional()
+});
+export const toolDefinitions = [
+    {
+        name: 'get_context',
+        description: 'Return initial AI context from local Graph and Personal KG canonical files.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataDir: { type: 'string' }
+            }
+        }
+    },
+    {
+        name: 'list_entities',
+        description: 'List person, org, project, relationship, and decision entities from local SSOT.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataDir: { type: 'string' },
+                type: { enum: ['person', 'org', 'project', 'relationship', 'decision'] }
+            }
+        }
+    },
+    {
+        name: 'search',
+        description: 'Search canonical local Graph, Personal KG, relationships, and decisions.',
+        inputSchema: {
+            type: 'object',
+            required: ['query'],
+            properties: {
+                dataDir: { type: 'string' },
+                query: { type: 'string' },
+                limit: { type: 'number' }
+            }
+        }
+    },
+    {
+        name: 'search_personal_kg',
+        description: 'Search owner-local Personal KG only.',
+        inputSchema: {
+            type: 'object',
+            required: ['query'],
+            properties: {
+                dataDir: { type: 'string' },
+                query: { type: 'string' },
+                limit: { type: 'number' }
+            }
+        }
+    },
+    {
+        name: 'onboarding_status',
+        description: 'Report seeded areas, first value demo readiness, missing setup, and local connection status.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataDir: { type: 'string' }
+            }
+        }
+    },
+    {
+        name: 'get_ontology',
+        description: 'Return the bundled immutable Brainbase Portable Ontology Kernel release.',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'audit_ontology',
+        description: 'Audit local canonical Personal OS files using the active or recorded historical ontology semantics.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataDir: { type: 'string' },
+                ontologyVersion: { enum: ['0.0.0', '1.0.0'] }
+            }
+        }
+    },
+    {
+        name: 'infer_decisions',
+        description: 'Derive active, superseded, and conflicting decisions using explicit ontology rules.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dataDir: { type: 'string' },
+                asOf: { type: 'string', format: 'date-time' },
+                ontologyVersion: { enum: ['0.0.0', '1.0.0'] }
+            }
+        }
+    },
+    {
+        name: 'ontology_impact',
+        description: 'Describe compatibility, migration, and rollback from an ontology version to the active release.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                fromVersion: { type: 'string' }
+            }
+        }
+    }
+];
+export async function callBrainbaseTool(name, rawArgs = {}) {
+    const args = argsSchema.parse(rawArgs ?? {});
+    const dataDir = resolveDataDir(args.dataDir);
+    switch (name) {
+        case 'get_ontology':
+            return portableOntology;
+        case 'audit_ontology':
+            return auditPersonalOsDirectory(dataDir, { ontologyVersion: resolveOntologyVersion(args.ontologyVersion) });
+        case 'ontology_impact':
+            return getOntologyImpact(args.fromVersion);
+    }
+    const os = await loadPersonalOs(dataDir);
+    switch (name) {
+        case 'get_context':
+            return getContext(os);
+        case 'list_entities':
+            return listEntities(os, args.type);
+        case 'search':
+            if (!args.query) {
+                throw new Error('search requires query');
+            }
+            return { results: searchAll(os, args.query, args.limit) };
+        case 'search_personal_kg':
+            if (!args.query) {
+                throw new Error('search_personal_kg requires query');
+            }
+            return { results: searchPersonalKg(os, args.query, args.limit) };
+        case 'onboarding_status':
+            return onboardingStatus(os);
+        case 'infer_decisions':
+            return inferPersonalOs(os, {
+                asOf: args.asOf,
+                ontologyVersion: resolveOntologyVersion(args.ontologyVersion)
+            });
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+export function createServer() {
+    const server = new Server({
+        name: 'brainbase-mcp',
+        version: '0.1.0'
+    }, {
+        capabilities: {
+            tools: {}
+        }
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [...toolDefinitions]
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const result = await callBrainbaseTool(request.params.name, request.params.arguments);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2)
+                }
+            ]
+        };
+    });
+    return server;
+}
+export async function runMcpServer() {
+    const server = createServer();
+    await server.connect(new StdioServerTransport());
+}

package/dist/skills.d.ts

@@ -0,0 +1,30 @@
+export type SkillTarget = 'codex' | 'claude' | 'portable';
+export type BrainbaseSkillId = 'brainbase-personal-onboarding' | 'brainbase-source-import' | 'brainbase-candidate-review' | 'brainbase-daily-routines';
+export interface BrainbaseSkillDefinition {
+    id: BrainbaseSkillId;
+    title: string;
+    description: string;
+    body: string;
+}
+export interface SkillFile {
+    id: BrainbaseSkillId;
+    description: string;
+    relativePath: string;
+    recommendedPath: string;
+    content: string;
+}
+export interface SkillBundle {
+    target: SkillTarget;
+    goal: string;
+    canonicalWrites: false;
+    liveConfigWrites: false;
+    skills: SkillFile[];
+    safetyRules: string[];
+    nextSteps: string[];
+}
+export declare const ALL_BRAINBASE_SKILLS: BrainbaseSkillId[];
+export declare function parseSkillTarget(value: string | undefined): SkillTarget;
+export declare function parseSkillIds(value: string | undefined): BrainbaseSkillId[];
+export declare function buildSkillBundle(target: SkillTarget, ids?: BrainbaseSkillId[]): SkillBundle;
+export declare function renderSkillsMarkdown(bundle: SkillBundle, outDir?: string): string;
+export declare function assertPublicSafeSkillBundle(bundle: SkillBundle): void;

package/dist/skills.js

@@ -0,0 +1,236 @@
+export const ALL_BRAINBASE_SKILLS = [
+    'brainbase-personal-onboarding',
+    'brainbase-source-import',
+    'brainbase-candidate-review',
+    'brainbase-daily-routines'
+];
+const TARGET_BASE_PATHS = {
+    codex: '~/.agents/skills',
+    claude: '.claude/skills',
+    portable: 'skills'
+};
+const SECRET_RULE = 'OAuthトークン、パスワード、APIキー、リフレッシュトークンをチャットに貼るようユーザーに依頼しない。';
+const SKILL_DEFINITIONS = {
+    'brainbase-personal-onboarding': {
+        id: 'brainbase-personal-onboarding',
+        title: 'Brainbase個人オンボーディング',
+        description: '公開版Brainbaseの個人オンボーディング面談とローカルMCP設定を、安全に進める。',
+        body: [
+            '## 目的',
+            '',
+            'ユーザーがCodex、Claude Code、または他のコーディングエージェントからBrainbaseを使い始める時に使う。',
+            '',
+            '## 手順',
+            '',
+            '1. 最初に `brainbase onboard:agent` を実行し、メール、カレンダー、ドライブ/ドキュメント、タスク、権限、承認についてエージェントに確認させる。',
+            '2. `brainbase onboard:init` でローカルPersonal OSディレクトリを作成する。',
+            '3. ソースデータを集める前に、ユーザーの回答を使って `brainbase onboard:diagnose-sources` を実行する。',
+            '4. `brainbase onboard:projects` で、現在のプロジェクト名、目的、状態、役割、関係者、許可されたソースをレビュー可能な形にする。',
+            '5. `brainbase onboard:candidates --write`、またはsource import/extractの流れでレビュー候補を作る。',
+            '6. ユーザーが明示的に承認した事実だけを `brainbase onboard:seed`、`brainbase onboard:projects --write`、または `brainbase onboard:apply --write` でcanonical SSOTへ昇格する。',
+            '7. `brainbase onboard:install --target codex|claude|codecode --dry-run` でMCP設定スニペットを生成し、ユーザーに確認してもらう。',
+            '',
+            '## 安全ルール',
+            '',
+            `- ${SECRET_RULE}`,
+            '- Brainbaseはローカルファーストで扱う。ユーザーが別のローカルパスを明示しない限り、ローカルMCPサーバーと `~/.brainbase/personal-os/` を使う。',
+            '- メール、カレンダー、ドライブ、タスク、メモの生データは `sources/` 配下の二次材料として扱う。',
+            '- canonical contextは、ユーザー確認後の `graph.json`、`relationships.json`、`personal-kg.jsonl`、`decisions.jsonl` だけから作る。'
+        ].join('\n')
+    },
+    'brainbase-source-import': {
+        id: 'brainbase-source-import',
+        title: 'Brainbaseソース取り込み',
+        description: 'ローカルソースのメタデータを集め、Brainbase sourcesへ取り込み、レビュー候補を抽出する。',
+        body: [
+            '## 目的',
+            '',
+            'ユーザーがBrainbaseオンボーディングでメール、カレンダー、ドライブ/ドキュメント、タスク、ローカルメモを対象にした時に使う。',
+            '',
+            '## 手順',
+            '',
+            '1. ドライブフォルダ、ローカルフォルダ、カレンダー、タスクプロジェクト、メールアカウントを読む前に、明示的な許可範囲を確認する。',
+            '2. まずメタデータ優先で集める。Google Workspaceでは、利用可能ならローカルのGoG系コレクタを使い、出力は `sources/` 配下に置く。',
+            '3. 集めたJSONを `brainbase onboard:import --source gmail|calendar|drive|local --from <file>` で取り込む。',
+            '4. `brainbase onboard:extract --self-email <email> --write` で決定的なレビュー候補を抽出する。',
+            '5. 昇格前に、候補id、provenance count、source areaをユーザーに見せる。',
+            '',
+            '## 安全ルール',
+            '',
+            `- ${SECRET_RULE}`,
+            '- ユーザーが抜粋の利用を明示的に承認しない限り、メール本文全体、予定説明全文、ファイル本文を集めない。',
+            '- ドライブ全体やホームディレクトリ全体をスキャンしない。明示的な許可リストを使う。',
+            '- import/extractはcanonical memoryではない。二次ソース記録とレビュー候補を作るだけにする。'
+        ].join('\n')
+    },
+    'brainbase-candidate-review': {
+        id: 'brainbase-candidate-review',
+        title: 'Brainbase候補レビュー',
+        description: 'Brainbase候補をユーザーと確認し、承認されたものだけを個人SSOTへ昇格する。',
+        body: [
+            '## 目的',
+            '',
+            '面談やsource extractionからBrainbase候補が作られた時に使う。',
+            '',
+            '## 手順',
+            '',
+            '1. 候補をself、value、project、person、organization、relationship、decision、next actionに分類する。',
+            '2. private sourceの生データをそのまま出さず、候補id、平易な要約、provenanceを提示する。',
+            '3. どの候補idを承認、却下、修正するかをユーザーに確認する。',
+            '4. まず `brainbase onboard:apply --from <candidate-file> --select <id>` でdry-runする。手入力の事実には `brainbase onboard:seed` を使う。',
+            '5. `--write` は明示的な承認後にだけ使い、canonical filesへ書き込む。',
+            '6. `brainbase doctor` を実行し、必要に応じてBrainbase MCPの `get_context` または `search` で承認済み事実が見えることを確認する。',
+            '',
+            '## 安全ルール',
+            '',
+            `- ${SECRET_RULE}`,
+            '- 頻出しているだけの候補を自動昇格しない。',
+            '- 却下または不確実な候補はcanonical SSOTに入れない。',
+            '- source由来の推測と、ユーザー承認済みのdurable memoryを分ける。'
+        ].join('\n')
+    },
+    'brainbase-daily-routines': {
+        id: 'brainbase-daily-routines',
+        title: 'Brainbase日次ルーティン',
+        description: 'ユーザーのエージェントスケジューラ向けに、個人用Brainbase ohayo、oyasumi、retroを生成する。',
+        body: [
+            '## 目的',
+            '',
+            'ユーザーがBrainbaseを一度きりの設定ではなく、継続的な個人オペレーティングループにしたい時に使う。',
+            '',
+            '## 手順',
+            '',
+            '1. `brainbase onboard:routines --target codex|claude` でルーティン定義を生成する。',
+            '2. 必要に応じて `--routines ohayo,oyasumi,retro` またはsubsetを使う。',
+            '3. `--ohayo-hour`、`--oyasumi-hour`、`--retro-dow`、`--retro-hour` で実行時刻を調整する。',
+            '4. スケジューラに登録する前に、生成されたpromptとscheduleをユーザーと確認する。',
+            '5. 各ルーティンは、ユーザー自身のローカルBrainbase MCP contextと承認済みソースだけに限定する。',
+            '',
+            '## 安全ルール',
+            '',
+            `- ${SECRET_RULE}`,
+            '- 明示的な確認なしに、メッセージ送信、公開、カレンダー変更、レコード削除をしない。',
+            '- 認証やcollectorの失敗は「データ未取得」と扱い、「対象ゼロ」とは扱わない。',
+            '- ルーティン生成はlive scheduler登録ではない。登録はユーザーが別ステップとして行う。'
+        ].join('\n')
+    }
+};
+const BANNED_PUBLIC_TERMS = [
+    'slack',
+    'sns',
+    'nocodb',
+    'vibepro',
+    'infisical',
+    'lightsail',
+    'hosted backend',
+    'server operations',
+    'server operation',
+    'unson'
+];
+export function parseSkillTarget(value) {
+    if (value === 'codex' || value === 'claude' || value === 'portable') {
+        return value;
+    }
+    throw new Error('onboard:skills requires --target codex|claude|portable');
+}
+export function parseSkillIds(value) {
+    if (!value) {
+        return [...ALL_BRAINBASE_SKILLS];
+    }
+    const requested = new Set(value.split(',').map((part) => part.trim()).filter(Boolean));
+    const unknown = [...requested].filter((id) => !isBrainbaseSkillId(id));
+    if (unknown.length > 0) {
+        throw new Error(`Unknown Brainbase skill id(s): ${unknown.join(', ')}. Expected one of: ${ALL_BRAINBASE_SKILLS.join(', ')}`);
+    }
+    const selected = ALL_BRAINBASE_SKILLS.filter((id) => requested.has(id));
+    if (selected.length === 0) {
+        throw new Error(`--skills must include at least one of: ${ALL_BRAINBASE_SKILLS.join(', ')}`);
+    }
+    return selected;
+}
+export function buildSkillBundle(target, ids = ALL_BRAINBASE_SKILLS) {
+    const skills = ids.map((id) => buildSkillFile(target, SKILL_DEFINITIONS[id]));
+    return {
+        target,
+        goal: '個人のコーディングエージェント運用向けに、公開safeなBrainbaseオンボーディングskillsを生成する。',
+        canonicalWrites: false,
+        liveConfigWrites: false,
+        skills,
+        safetyRules: [
+            SECRET_RULE,
+            '生成されるskillsは個人スコープかつローカルファーストに限定する。',
+            '生成されるskillsは内部Brainbase運用からコピーしない。',
+            'このコマンドはportableなSKILL.mdを表示または書き出すだけで、live agent configurationは変更しない。'
+        ],
+        nextSteps: [
+            `生成された ${target} skill files を確認する。`,
+            '対象エージェントのskill directoryへ配置するか、生成ディレクトリをエージェントに参照させる。',
+            '`brainbase onboard:agent` を実行し、オンボーディング面談を続ける。'
+        ]
+    };
+}
+export function renderSkillsMarkdown(bundle, outDir) {
+    const lines = ['# Brainbase公開オンボーディングSkills', ''];
+    lines.push(`- 対象: ${bundle.target}`);
+    lines.push(`- Skills: ${bundle.skills.map((skill) => skill.id).join(', ')}`);
+    lines.push(`- canonical writes: ${bundle.canonicalWrites}`);
+    lines.push(`- live config writes: ${bundle.liveConfigWrites}`);
+    if (outDir) {
+        lines.push(`- 出力ディレクトリ: ${outDir}`);
+    }
+    lines.push('', '## ファイル');
+    for (const skill of bundle.skills) {
+        lines.push('', `### ${skill.id}`, '');
+        lines.push(`- 推奨パス: ${skill.recommendedPath}`);
+        lines.push(`- 相対パス: ${skill.relativePath}`);
+        lines.push('', '```markdown', skill.content.trimEnd(), '```');
+    }
+    lines.push('', '## 安全ルール');
+    for (const rule of bundle.safetyRules) {
+        lines.push(`- ${rule}`);
+    }
+    lines.push('', '## 次のステップ');
+    for (const step of bundle.nextSteps) {
+        lines.push(`- ${step}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function assertPublicSafeSkillBundle(bundle) {
+    const haystack = bundle.skills.map((skill) => skill.content).join('\n').toLowerCase();
+    for (const term of BANNED_PUBLIC_TERMS) {
+        if (haystack.includes(term)) {
+            throw new Error(`Generated public Brainbase skills contain banned internal term: ${term}`);
+        }
+    }
+    for (const skill of bundle.skills) {
+        if (!skill.content.includes(SECRET_RULE)) {
+            throw new Error(`Generated skill ${skill.id} is missing the no-secrets safety rule.`);
+        }
+    }
+}
+function buildSkillFile(target, definition) {
+    const relativePath = `${definition.id}/SKILL.md`;
+    return {
+        id: definition.id,
+        description: definition.description,
+        relativePath,
+        recommendedPath: `${TARGET_BASE_PATHS[target]}/${relativePath}`,
+        content: renderSkillContent(definition)
+    };
+}
+function renderSkillContent(definition) {
+    return [
+        '---',
+        `name: ${definition.id}`,
+        `description: ${definition.description}`,
+        '---',
+        '',
+        `# ${definition.title}`,
+        '',
+        definition.body,
+        ''
+    ].join('\n');
+}
+function isBrainbaseSkillId(value) {
+    return ALL_BRAINBASE_SKILLS.includes(value);
+}

package/dist/ssot.d.ts

@@ -0,0 +1,4 @@
+import type { PersonalOs } from './types.js';
+export declare function initializePersonalOs(dataDir: string): Promise<void>;
+export declare function loadPersonalOs(dataDir: string): Promise<PersonalOs>;
+export declare function mutatePersonalOs(dataDir: string, mutator: (current: PersonalOs) => PersonalOs | Promise<PersonalOs>): Promise<PersonalOs>;