@unson/brainbase-mcp 0.2.4 → 0.3.1

package/dist/tools.js

@@ -1,14 +1,16 @@
+import { isActiveAt } from './canonical-graph.js';
 import { buildOperationalizationPlan } from './operationalization.js';
-export function getContext(os) {
+import { getCanonicalRelation } from './relation-registry.js';
+export function getContext(os, options = {}) {
     const selfEntries = os.personalKg.filter((entry) => entry.type === 'self' || entry.type === 'value' || entry.type === 'judgment');
     const workEntries = os.personalKg.filter((entry) => entry.type === 'work' || entry.type === 'experience');
-    const projects = os.graph.entities.filter((entity) => entity.type === 'project').map((entity) => ({
-        id: entity.id,
-        name: entity.name,
-        summary: entity.summary,
-        goal: readMetadataString(entity.metadata, 'goal'),
-        status: readMetadataString(entity.metadata, 'status'),
-        role: readMetadataString(entity.metadata, 'role'),
+    const scoped = scopedRecords(os, options);
+    const visibleIds = os.graph.version === 2 ? new Set(scoped.records.map((record) => record.entity.id)) : undefined;
+    const projects = os.graph.entities
+        .filter((entity) => entity.type === 'project' && (!visibleIds || visibleIds.has(entity.id)))
+        .map((entity) => ({
+        id: entity.id, name: entity.name, summary: entity.summary,
+        goal: readMetadataString(entity.metadata, 'goal'), status: readMetadataString(entity.metadata, 'status'), role: readMetadataString(entity.metadata, 'role'),
         sources: Array.isArray(entity.metadata?.sources) ? entity.metadata.sources : [],
         taskSources: Array.isArray(entity.metadata?.taskSources) ? entity.metadata.taskSources : [],
         decisionPrinciples: Array.isArray(entity.metadata?.decisionPrinciples) ? entity.metadata.decisionPrinciples : []
@@ -17,175 +19,210 @@ export function getContext(os) {
         owner: os.graph.owner ?? {},
         self: selfEntries.map((entry) => entry.text),
         projects,
-        work: [
-            ...projects.map((project) => project.summary ? `${project.name}: ${project.summary}` : project.name),
-            ...workEntries.map((entry) => entry.text)
-        ],
-        relationships: os.relationships.relationships.map((relationship) => ({
-            person: relationship.person,
-            role: relationship.role,
-            context: relationship.context
-        })),
-        decisions: os.decisions.map((decision) => ({
-            title: decision.title,
-            decision: decision.decision,
-            rationale: decision.rationale
-        })),
+        work: [...projects.map((project) => project.summary ? `${project.name}: ${project.summary}` : project.name), ...workEntries.map((entry) => entry.text)],
+        relationships: os.relationships.relationships.map((relationship) => ({ person: relationship.person, role: relationship.role, context: relationship.context })),
+        decisions: os.decisions.map((decision) => ({ title: decision.title, decision: decision.decision, rationale: decision.rationale })),
         canonicalFiles: ['graph.json', 'personal-kg.jsonl', 'relationships.json', 'decisions.jsonl'],
-        note: 'Canonical local SSOT data is preferred over raw sources.'
+        note: 'Canonical local SSOT data is preferred over raw sources.',
+        ...(os.graph.version === 2 ? { canonicalGraph: {
+                schemaVersion: 2,
+                ontology: os.graph.ontology,
+                authority: 'local_graph',
+                asOf: scoped.asOf,
+                project: scoped.project ? { id: scoped.project.id, name: scoped.project.name } : null,
+                records: scoped.records.map(({ entity, relationPath }) => ({
+                    ...entity, canonicalEntityId: entity.id, recordClass: 'canonical', relationPath, authority: 'local_graph'
+                }))
+            } } : {})
     };
 }
 export function listEntities(os, type) {
     const graphEntities = os.graph.entities.filter((entity) => !type || entity.type === type);
-    const relationshipEntities = type && type !== 'relationship'
-        ? []
-        : os.relationships.relationships.map((relationship) => ({
-            id: relationship.id,
-            type: 'relationship',
-            name: relationship.person,
-            summary: relationship.context,
-            tags: relationship.tags
-        }));
-    const decisionEntities = type && type !== 'decision'
-        ? []
-        : os.decisions.map((decision) => ({
-            id: decision.id,
-            type: 'decision',
-            name: decision.title,
-            summary: decision.decision,
-            tags: decision.tags
-        }));
-    return {
-        entities: [...graphEntities, ...relationshipEntities, ...decisionEntities]
-    };
+    const relationshipEntities = type && type !== 'relationship' ? [] : os.relationships.relationships.map((relationship) => ({
+        id: relationship.id, type: 'relationship', name: relationship.person, summary: relationship.context, tags: relationship.tags
+    }));
+    const decisionEntities = type && type !== 'decision' ? [] : os.decisions.map((decision) => ({
+        id: decision.id, type: 'decision', name: decision.title, summary: decision.decision, tags: decision.tags
+    }));
+    return { entities: [...graphEntities, ...relationshipEntities, ...decisionEntities] };
 }
 export function searchPersonalKg(os, query, limit = 10) {
     return rank(os.personalKg.map((entry) => ({
-        source: 'personal-kg',
-        id: entry.id,
-        title: entry.type,
-        text: entry.text,
-        score: scoreText(query, [entry.id, entry.type, entry.text, ...(entry.tags ?? [])])
+        source: 'personal-kg', id: entry.id, title: entry.type, text: entry.text,
+        score: scoreText(query, [entry.id, entry.type, entry.text, ...(entry.tags ?? [])]),
+        recordClass: 'unresolved', authority: 'personal_kg'
     })), limit);
 }
-export function searchAll(os, query, limit = 10) {
-    const graphResults = os.graph.entities.map((entity) => ({
-        source: 'graph',
-        id: entity.id,
-        title: entity.name,
+export function searchAll(os, query, limit = 10, options = {}) {
+    const scoped = scopedRecords(os, options);
+    const graphRecords = os.graph.version === 2
+        ? scoped.records
+        : os.graph.entities.map((entity) => ({ entity: entity, relationPath: [] }));
+    const graphResults = graphRecords.map(({ entity, relationPath }) => ({
+        source: 'graph', id: entity.id, title: entity.name,
         text: [entity.summary ?? entity.name, metadataText(entity.metadata)].filter(Boolean).join('\n'),
-        score: scoreText(query, [entity.id, entity.type, entity.name, entity.summary ?? '', metadataText(entity.metadata), ...(entity.tags ?? [])])
+        score: scoreText(query, [entity.id, entity.type, entity.name, ...(entity.aliases ?? []), entity.summary ?? '', metadataText(entity.metadata), ...(entity.tags ?? [])]),
+        canonicalEntityId: entity.id, recordClass: 'canonical', relationPath, authority: 'local_graph'
     }));
-    const relationshipResults = os.relationships.relationships.map((relationship) => ({
-        source: 'relationships',
-        id: relationship.id,
-        title: relationship.person,
-        text: relationship.context,
-        score: scoreText(query, [relationship.id, relationship.person, relationship.role ?? '', relationship.context, ...(relationship.tags ?? [])])
-    }));
-    const decisionResults = os.decisions.map((decision) => ({
-        source: 'decisions',
-        id: decision.id,
-        title: decision.title,
-        text: [decision.decision, decision.rationale ?? ''].filter(Boolean).join('\n'),
-        score: scoreText(query, [decision.id, decision.title, decision.decision, decision.rationale ?? '', ...(decision.tags ?? [])])
-    }));
-    return rank([...graphResults, ...searchPersonalKg(os, query, limit), ...relationshipResults, ...decisionResults], limit);
+    const visibleIds = new Set(scoped.records.map((record) => record.entity.id));
+    const targets = os.graph.version === 2 ? projectionTargets(os.graph, scoped.asOf, visibleIds) : undefined;
+    const relationshipResults = os.relationships.relationships.map((relationship) => {
+        const projectionOf = targets?.person.get(normalize(relationship.person));
+        return {
+            source: 'relationships', id: relationship.id, title: relationship.person, text: relationship.context,
+            score: scoreText(query, [relationship.id, relationship.person, relationship.role ?? '', relationship.context, ...(relationship.tags ?? [])]),
+            ...(projectionOf ? { canonicalEntityId: projectionOf, projectionOf } : {}),
+            recordClass: projectionOf ? 'projection' : 'unresolved', authority: 'legacy_relationships'
+        };
+    });
+    const decisionResults = os.decisions.map((decision) => {
+        const projectionOf = targets?.decision.get(decision.id) ?? targets?.decision.get(normalize(decision.title));
+        return {
+            source: 'decisions', id: decision.id, title: decision.title,
+            text: [decision.decision, decision.rationale ?? ''].filter(Boolean).join('\n'),
+            score: scoreText(query, [decision.id, decision.title, decision.decision, decision.rationale ?? '', ...(decision.tags ?? [])]),
+            ...(projectionOf ? { canonicalEntityId: projectionOf, projectionOf } : {}),
+            recordClass: projectionOf ? 'projection' : 'unresolved', authority: 'legacy_decisions'
+        };
+    });
+    const additional = [...relationshipResults, ...decisionResults, ...(options.project ? [] : searchPersonalKg(os, query, limit))]
+        .filter((result) => !options.project || Boolean(result.projectionOf));
+    const canonicalById = new Map(graphResults.map((result) => [result.id, result]));
+    const retained = [];
+    for (const result of additional) {
+        const canonical = result.projectionOf ? canonicalById.get(result.projectionOf) : undefined;
+        if (canonical) {
+            canonical.score = Math.max(canonical.score, result.score);
+            if (result.source === 'relationships' || result.source === 'decisions') {
+                canonical.projectionSources = [...new Set([...(canonical.projectionSources ?? []), result.source])];
+            }
+        }
+        else
+            retained.push(result);
+    }
+    return rank([...graphResults, ...retained], limit);
 }
 export function onboardingStatus(os) {
     const seeded = {
         self: Boolean(os.graph.owner?.name) || os.personalKg.some((entry) => entry.type === 'self'),
         work: os.graph.entities.some((entity) => entity.type === 'project') || os.personalKg.some((entry) => entry.type === 'work'),
-        relationships: os.relationships.relationships.length > 0
+        relationships: os.relationships.relationships.length > 0 || (os.graph.version === 2 && os.graph.edges.length > 0)
     };
-    const missing = Object.entries(seeded)
-        .filter(([, value]) => !value)
-        .map(([key]) => key);
+    const missing = Object.entries(seeded).filter(([, value]) => !value).map(([key]) => key);
     const valueDemoReady = missing.length === 0;
-    const operationalization = buildOperationalizationPlan({
-        dataDir: os.dataDir,
-        firstValueReady: valueDemoReady
-    });
+    const operationalization = buildOperationalizationPlan({ dataDir: os.dataDir, firstValueReady: valueDemoReady });
     return {
-        dataDir: os.dataDir,
-        localBackend: {
-            connected: true,
-            backend: 'local'
-        },
-        agentMcp: {
-            status: 'not_verified',
-            verification: 'MCP設定を反映した新しいエージェントセッションで get_context / search を確認してください。'
-        },
-        operationallyReady: false,
-        seeded,
-        missing,
-        valueDemo: {
-            scope: 'local_cli_sample',
-            ready: valueDemoReady,
-            missing,
-            command: `brainbase onboard:demo --dir ${shellArg(os.dataDir)} --scenario "<real request>"`,
-            completionSignal: valueDemoReady ? 'cli_sample_ready' : 'needs_seed'
-        },
+        dataDir: os.dataDir, localBackend: { connected: true, backend: 'local' },
+        agentMcp: { status: 'not_verified', verification: 'MCP設定を反映した新しいエージェントセッションで resolve_entity / get_context / search を確認してください。' },
+        operationallyReady: false, seeded, missing,
+        valueDemo: { scope: 'local_cli_sample', ready: valueDemoReady, missing, command: `brainbase onboard:demo --dir ${shellArg(os.dataDir)} --scenario "<real request>"`, completionSignal: valueDemoReady ? 'cli_sample_ready' : 'needs_seed' },
         operationalization,
-        counts: {
-            graphEntities: os.graph.entities.length,
-            personalKgEntries: os.personalKg.length,
-            relationships: os.relationships.relationships.length,
-            decisions: os.decisions.length,
-            rawSources: os.sourceCount
-        }
+        counts: { graphEntities: os.graph.entities.length, graphEdges: os.graph.version === 2 ? os.graph.edges.length : 0, personalKgEntries: os.personalKg.length, relationships: os.relationships.relationships.length, decisions: os.decisions.length, rawSources: os.sourceCount }
+    };
+}
+function scopedRecords(os, options) {
+    const asOf = options.asOf ?? new Date().toISOString();
+    if (os.graph.version !== 2)
+        return { records: [], asOf };
+    const graph = os.graph;
+    const active = graph.entities.filter((entity) => isActiveAt(entity, asOf));
+    const activeIds = new Set(active.map((entity) => entity.id));
+    const project = options.project ? resolveProject(active, options.project) : undefined;
+    if (options.project && !project)
+        return { records: [], asOf };
+    if (!project)
+        return { records: active.map((entity) => ({ entity, relationPath: [] })), asOf };
+    const edges = graph.edges.filter((edge) => isActiveAt(edge, asOf) && activeIds.has(edge.fromId) && activeIds.has(edge.toId));
+    return {
+        records: active.flatMap((entity) => {
+            const relationPath = pathToProject(entity.id, project.id, edges);
+            return relationPath === undefined ? [] : [{ entity, relationPath }];
+        }), project, asOf
     };
 }
-function shellArg(value) {
-    return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : JSON.stringify(value);
+function pathToProject(entityId, projectId, edges) {
+    if (entityId === projectId)
+        return [];
+    const queue = [{ id: entityId, path: [] }];
+    const visited = new Set([entityId]);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        for (const edge of edges) {
+            const relation = getCanonicalRelation(edge.relation);
+            if (relation.scopeTraversal === 'none' || relation.traversalDirection === 'none')
+                continue;
+            const next = relation.traversalDirection === 'forward' ? (edge.fromId === current.id ? edge.toId : undefined) : (edge.toId === current.id ? edge.fromId : undefined);
+            if (!next)
+                continue;
+            const path = [...current.path, edge.id];
+            if (next === projectId)
+                return path;
+            if (relation.scopeTraversal === 'project_transitive' && !visited.has(next)) {
+                visited.add(next);
+                queue.push({ id: next, path });
+            }
+        }
+    }
+    return undefined;
+}
+function resolveProject(entities, value) {
+    const needle = normalize(value);
+    const matches = entities.filter((entity) => entity.type === 'project' && [entity.id, entity.name, ...(entity.aliases ?? [])].some((candidate) => normalize(candidate) === needle));
+    return matches.length === 1 ? matches[0] : undefined;
+}
+function projectionTargets(graph, asOf, visibleIds) {
+    const person = new Map();
+    const decision = new Map();
+    const ambiguous = new Set();
+    for (const entity of graph.entities.filter((candidate) => visibleIds.has(candidate.id) && isActiveAt(candidate, asOf))) {
+        const target = entity.type === 'person' ? person : entity.type === 'decision' ? decision : undefined;
+        if (!target)
+            continue;
+        for (const value of [entity.id, entity.name, ...(entity.aliases ?? [])]) {
+            const key = value === entity.id ? value : normalize(value);
+            if (target.has(key) && target.get(key) !== entity.id)
+                ambiguous.add(`${entity.type}:${key}`);
+            else
+                target.set(key, entity.id);
+        }
+    }
+    for (const marker of ambiguous) {
+        const [kind, ...parts] = marker.split(':');
+        (kind === 'person' ? person : decision).delete(parts.join(':'));
+    }
+    return { person, decision };
 }
 function rank(results, limit) {
-    return results
-        .filter((result) => result.score > 0)
-        .sort((a, b) => b.score - a.score || a.title.localeCompare(b.title))
+    const priority = { canonical: 0, projection: 1, unresolved: 2 };
+    return results.filter((result) => result.score > 0)
+        .sort((a, b) => b.score - a.score || priority[a.recordClass] - priority[b.recordClass] || a.title.localeCompare(b.title))
         .slice(0, Math.max(1, limit));
 }
 function scoreText(query, fields) {
-    const terms = searchTokens(query);
-    if (terms.length === 0) {
-        return 0;
-    }
-    const haystack = fields.join('\n').toLowerCase();
-    const phrase = query.trim().toLowerCase();
-    const matchedTerms = terms.filter((term) => haystack.includes(term));
-    if (phrase && haystack.includes(phrase)) {
-        return terms.length + 20;
+    let best = 0;
+    for (const variant of queryAliases(query)) {
+        const terms = searchTokens(variant);
+        if (terms.length === 0)
+            continue;
+        const haystack = fields.join('\n').normalize('NFKC').toLowerCase();
+        const phrase = variant.trim().normalize('NFKC').toLowerCase();
+        const matched = terms.filter((term) => haystack.includes(term));
+        best = Math.max(best, phrase && haystack.includes(phrase) ? terms.length + 20 : matched.length === terms.length ? terms.length + 10 : matched.length);
     }
-    if (matchedTerms.length === terms.length) {
-        return terms.length + 10;
-    }
-    return matchedTerms.length;
+    return best;
+}
+function queryAliases(query) {
+    const canonical = query.normalize('NFKC').trim();
+    const alias = canonical.replace(/(?:さん|様|氏|くん|君|ちゃん)$/u, '').trim();
+    return alias && alias !== canonical ? [canonical, alias] : [canonical];
 }
 function searchTokens(query) {
     const seen = new Set();
-    return query
-        .normalize('NFKC')
-        .replace(/[|/\\,;:()[\]{}"'`“”‘’、。・･，．：；（）［］｛｝「」『』【】]/g, ' ')
-        .replace(/[-_]+/g, ' ')
-        .toLowerCase()
-        .split(/\s+/)
-        .map((term) => term.trim())
-        .filter(Boolean)
-        .filter((term) => {
-        if (seen.has(term)) {
-            return false;
-        }
-        seen.add(term);
-        return true;
-    });
-}
-function metadataText(metadata) {
-    if (!metadata) {
-        return '';
-    }
-    return JSON.stringify(metadata);
-}
-function readMetadataString(metadata, key) {
-    const value = metadata?.[key];
-    return typeof value === 'string' ? value : undefined;
+    return query.normalize('NFKC').replace(/[|/\\,;:()[\]{}"'`“”‘’、。・･，．：；（）［］｛｝「」『』【】]/g, ' ')
+        .replace(/[-_]+/g, ' ').toLowerCase().split(/\s+/).map((term) => term.trim()).filter(Boolean)
+        .filter((term) => seen.has(term) ? false : (seen.add(term), true));
 }
+function normalize(value) { return value.normalize('NFKC').replace(/\s+/g, '').toLowerCase(); }
+function metadataText(metadata) { return metadata ? JSON.stringify(metadata) : ''; }
+function readMetadataString(metadata, key) { const value = metadata?.[key]; return typeof value === 'string' ? value : undefined; }
+function shellArg(value) { return /^[A-Za-z0-9_./:@%+=,-]+$/.test(value) ? value : JSON.stringify(value); }

package/dist/types.d.ts

@@ -1,4 +1,6 @@
 export type EntityKind = 'person' | 'org' | 'project' | 'relationship' | 'decision';
+export type CanonicalEntityKind = 'person' | 'org' | 'project' | 'decision';
+export type CoreRelation = 'member_of' | 'participates_in' | 'accountable_for' | 'owned_by' | 'governs' | 'supersedes';
 export interface GraphEntity {
     id: string;
     type: Exclude<EntityKind, 'decision'>;
@@ -7,7 +9,7 @@ export interface GraphEntity {
     tags?: string[];
     metadata?: Record<string, unknown>;
 }
-export interface GraphFile {
+export interface GraphFileV1 {
     version: 1;
     owner?: {
         name?: string;
@@ -15,6 +17,49 @@ export interface GraphFile {
     };
     entities: GraphEntity[];
 }
+export interface CanonicalEntity {
+    id: string;
+    type: CanonicalEntityKind;
+    name: string;
+    aliases?: string[];
+    summary?: string;
+    tags?: string[];
+    validFrom?: string;
+    validTo?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface CanonicalEdge {
+    id: string;
+    fromId: string;
+    relation: CoreRelation;
+    toId: string;
+    role?: string;
+    context?: string;
+    validFrom?: string;
+    validTo?: string;
+    provenance?: {
+        sourceKind: 'user_approved' | 'migration' | 'import' | 'onboarding';
+        sourceId?: string;
+        evidenceHash?: string;
+    };
+}
+export interface GraphFileV2 {
+    version: 2;
+    ontology: {
+        id: 'brainbase-personal-os';
+        version: string;
+        releaseDigest: string;
+    };
+    owner?: {
+        id?: string;
+        name?: string;
+        summary?: string;
+    };
+    entities: CanonicalEntity[];
+    edges: CanonicalEdge[];
+}
+export type GraphFile = GraphFileV1 | GraphFileV2;
+export type CanonicalGraphFile = GraphFile;
 export interface PersonalKgEntry {
     id: string;
     type: 'self' | 'work' | 'relationship' | 'value' | 'judgment' | 'experience' | 'sns_context';
@@ -60,4 +105,10 @@ export interface SearchResult {
     title: string;
     text: string;
     score: number;
+    canonicalEntityId?: string;
+    recordClass: 'canonical' | 'projection' | 'unresolved';
+    projectionOf?: string;
+    projectionSources?: Array<'relationships' | 'decisions'>;
+    relationPath?: string[];
+    authority: 'local_graph' | 'personal_kg' | 'legacy_relationships' | 'legacy_decisions';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unson/brainbase-mcp",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "Local-first Brainbase MCP server and personal onboarding kit.",
   "type": "module",
   "license": "MIT",
@@ -26,7 +26,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "test": "vitest run",
-    "test:integration": "vitest run tests/mcp-contract.test.ts tests/ontology-cli.test.ts tests/npm-release-validation.integration.test.ts",
+    "test:integration": "vitest run tests/mcp-contract.test.ts tests/ontology-cli.test.ts tests/npm-release-validation.integration.test.ts tests/npm-consumer-smoke.integration.test.ts",
+    "test:consumer-smoke": "vitest run tests/npm-consumer-smoke.integration.test.ts",
     "test:integration:release-evidence": "vitest run tests/npm-release-validation.integration.test.ts tests/npm-prepublication-evidence.integration.test.ts",
     "test:e2e": "vitest run tests/e2e/brainbase-mcp-only-acceptance.spec.ts tests/e2e/story-brainbase-portable-ontology-kernel-acceptance.spec.ts",
     "docs:dev": "vitepress dev docs",
@@ -61,5 +62,5 @@
   "engines": {
     "node": ">=20"
   },
-  "gitHead": "c40de6a3037cc6a67b2f2eab5d9487093193d314"
+  "gitHead": "0ff2753a492aef09235be2792570000ef03dfa4b"
 }