@unson/brainbase-mcp 0.6.0 → 0.8.0

package/dist/cli.d.ts

@@ -7,6 +7,8 @@ interface CliIo {
     stderr?: {
         write(chunk: string): unknown;
     };
+    /** Stops a long-running command such as web:serve (besides SIGINT/SIGTERM). */
+    signal?: AbortSignal;
 }
 export declare function runCli(argv?: string[], io?: CliIo): Promise<number>;
 export declare function isCliEntrypoint(moduleUrl: string, invokedPath: string | undefined): boolean;

package/dist/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { createPortableGraph, portableGraphDigest } from './portable-graph.js';
 import { createOrganizationGraphConfig, createOrganizationGraphClient } from './organization-graph.js';
+import { listLocalMemories, memoryListJson, registerSelectedMemories, registrationPreviewJson, renderMemoryList, renderRegistrationPreview, renderRegistrationResult, selectLocalMemories } from './personal-memory-handover.js';
 import { constants, realpathSync } from 'node:fs';
 import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { delimiter, dirname, isAbsolute, join } from 'node:path';
@@ -19,6 +20,8 @@ import { buildProjectRegistrationPlan, parseProjectSource, parseProjectStakehold
 import { renderGuidedFirstRun } from './guided-onboarding.js';
 import { blockedJudgmentOutput, processJudgmentHook } from './judgment-host.js';
 import { applyCanonicalWrites, buildCanonicalEdge } from './canonical-edge-builder.js';
+import { defaultJudgmentJournalRoot } from './judgment-value-proof-review.js';
+import { createLocalWebHost, LOCAL_WEB_DEFAULT_PORT } from './local-web-host.js';
 export async function runCli(argv = process.argv.slice(2), io = process) {
     const parsed = parseArgs(argv);
     try {
@@ -41,6 +44,27 @@ export async function runCli(argv = process.argv.slice(2), io = process) {
                     sourceFilesUnchanged: true, graphId: config.graphId }) + '\n');
                 return 0;
             }
+            case 'graph:bundles': {
+                const config = createOrganizationGraphConfig();
+                if (!config)
+                    throw new Error('graph:bundles requires all BRAINBASE_ORGANIZATION_* settings');
+                const format = first(parsed, 'format') ?? 'text';
+                if (format !== 'text' && format !== 'json')
+                    throw new Error('graph:bundles --format must be text or json');
+                const list = await createOrganizationGraphClient(config).listPortableGraphs();
+                if (format === 'json')
+                    write(io, `${JSON.stringify(list, null, 2)}\n`);
+                else if (list.bundles.length === 0)
+                    write(io, 'No Graph bundles have been uploaded to this organization yet.\n');
+                else
+                    write(io, list.bundles.map((entry) => `${entry.createdAt}  ${entry.projectCode}  ${entry.graphId}  ${entry.digest}\n`).join('')
+                        + (list.truncated ? `Only the newest ${list.bundles.length} bundle(s) are shown.\n` : ''));
+                return 0;
+            }
+            case 'memory:list':
+                return await memoryList(parsed, io);
+            case 'memory:register':
+                return await memoryRegister(parsed, io);
             case 'onboard:init':
                 return await onboardInit(parsed, io);
             case 'onboard:seed':
@@ -86,6 +110,10 @@ export async function runCli(argv = process.argv.slice(2), io = process) {
                 return await judgmentInstall(parsed, io);
             case 'doctor':
                 return await doctor(parsed, io);
+            case 'web:serve':
+            case 'review:serve':
+                // review:serve is kept as an alias of the same local Web host.
+                return await webServe(parsed, io, parsed.command);
             case 'mcp':
                 await import('./index.js');
                 return 0;
@@ -175,6 +203,36 @@ async function readHookStdin(input) {
         text += typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf8');
     return text;
 }
+function textOrJsonFormat(parsed, command) {
+    const format = first(parsed, 'format') ?? 'text';
+    if (format !== 'text' && format !== 'json')
+        throw new Error(`${command} --format must be text or json`);
+    return format;
+}
+async function memoryList(parsed, io) {
+    const format = textOrJsonFormat(parsed, 'memory:list');
+    const memories = await listLocalMemories(first(parsed, 'dir'));
+    write(io, format === 'json' ? `${JSON.stringify(memoryListJson(memories), null, 2)}\n` : renderMemoryList(memories));
+    return 0;
+}
+async function memoryRegister(parsed, io) {
+    const format = textOrJsonFormat(parsed, 'memory:register');
+    const ids = parsed.values.get('id') ?? [];
+    if (ids.length === 0)
+        throw new Error('memory:register requires at least one --id <id> (see brainbase memory:list)');
+    const dataDir = first(parsed, 'dir');
+    if (!parsed.flags.has('write')) {
+        const selected = selectLocalMemories(await listLocalMemories(dataDir), ids);
+        write(io, format === 'json' ? `${JSON.stringify(registrationPreviewJson(selected), null, 2)}\n` : renderRegistrationPreview(selected));
+        return 0;
+    }
+    const config = createOrganizationGraphConfig();
+    if (!config)
+        throw new Error('memory:register --write requires all BRAINBASE_ORGANIZATION_* settings; nothing was sent');
+    const result = await registerSelectedMemories({ dataDir, ids, organization: { url: config.url, token: config.token } });
+    write(io, format === 'json' ? `${JSON.stringify({ status: 'registered', ...result }, null, 2)}\n` : renderRegistrationResult(result));
+    return 0;
+}
 async function onboardInit(parsed, io) {
     const dataDir = resolveDataDir(first(parsed, 'dir'));
     await initializePersonalOs(dataDir);
@@ -976,6 +1034,50 @@ async function doctor(parsed, io) {
 function graphDiagnosisExitCode(status) {
     return status === 'invalid' || status === 'unavailable' || status === 'migration_required' ? 1 : 0;
 }
+async function webServe(parsed, io, command) {
+    const dataDir = resolveDataDir(first(parsed, 'dir'));
+    const journalRoot = first(parsed, 'journal')
+        ?? process.env.BRAINBASE_JUDGMENT_JOURNAL_DIR
+        ?? defaultJudgmentJournalRoot(dataDir);
+    const port = Number(first(parsed, 'port') ?? String(LOCAL_WEB_DEFAULT_PORT));
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new Error(`${command} requires --port to be an integer between 0 and 65535`);
+    }
+    const { server } = createLocalWebHost({ dataDir, journalRoot });
+    await new Promise((resolveListen, rejectListen) => {
+        server.once('error', rejectListen);
+        server.listen(port, '127.0.0.1', () => resolveListen());
+    });
+    const address = server.address();
+    const actualPort = typeof address === 'object' && address ? address.port : port;
+    const origin = `http://127.0.0.1:${actualPort}`;
+    write(io, [
+        `Brainbase: ${origin}/`,
+        `- 今日（判断の見返し）: ${origin}/#today`,
+        `- 目的と現状: ${origin}/#objectives`,
+        `- プロジェクトと関係者: ${origin}/#projects`,
+        `- 情報と関係: ${origin}/#graph`,
+        `データ: ${dataDir}`,
+        `判断journal: ${journalRoot}`,
+        '終了: Ctrl+C',
+        ''
+    ].join('\n'));
+    await new Promise((resolveClose) => {
+        const stop = () => {
+            process.off('SIGINT', stop);
+            process.off('SIGTERM', stop);
+            io.signal?.removeEventListener('abort', stop);
+            server.close(() => resolveClose());
+        };
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+        if (io.signal?.aborted)
+            stop();
+        else
+            io.signal?.addEventListener('abort', stop, { once: true });
+    });
+    return 0;
+}
 function parseArgs(argv) {
     const [firstToken, ...remaining] = argv;
     const command = firstToken?.startsWith('--') ? undefined : firstToken;
@@ -1104,10 +1206,15 @@ function usage() {
   brainbase ontology:show
   brainbase ontology:audit [--dir path] [--ontology-version 0.0.0|1.0.0|2.0.0]
   brainbase graph:upgrade [--dir path]
+  brainbase graph:bundles [--format text|json]
+  brainbase memory:list [--dir path] [--format text|json]
+  brainbase memory:register --id id [--id id...] [--dir path] [--write] [--format text|json]
   brainbase ontology:migrate [--dir path] [--write --expected-input-digest digest]
   brainbase judgment:install --target codex [--autonomy-mode off|canary|on] [--autonomy-project code] [--dry-run] [--output path]
   brainbase judgment:hook [--autonomy-mode off|canary|on] [--autonomy-project code]
   brainbase doctor [--dir path] [--judgment-hooks path]
+  brainbase web:serve [--dir path] [--journal path] [--port n]
+  brainbase review:serve [--dir path] [--journal path] [--port n]  （web:serveの別名）
 `;
 }
 function shellArg(value) {

package/dist/company-os-evaluation.d.ts

@@ -0,0 +1,193 @@
+import type { FoundationAcl, FoundationEvaluationDescriptor, FoundationScope, ObjectiveCriterion } from './ontology-foundation.js';
+import { type FoundationRef } from './foundation-catalog.js';
+import type { FoundationRevisionStore, FoundationStoreContext } from './foundation-store.js';
+import type { FoundationCatalogRecord } from './types.js';
+import { type JudgmentProblemReferenceProvider, type JudgmentProblemSnapshotAccessContext, type JudgmentProblemSnapshotAccessProvider } from './judgment-problem-snapshot.js';
+/**
+ * Evaluation is an evidence record over a pinned Problem.  It does not own
+ * Objective or Variable definitions and it does not close an OutcomeCase.
+ */
+export declare const COMPANY_OS_EVALUATION_CONTRACT_VERSION: "0.1.0";
+export declare const COMPANY_OS_EVALUATION_RECORD_CATALOG_VERSION: 1;
+export declare const COMPANY_OS_EVALUATION_SIDECAR: "evidence/company-os-evaluation.json";
+export type EvaluationMeasurementStatus = 'observed' | 'missing' | 'not_arrived';
+export type EvaluationJudgmentValidity = 'valid' | 'invalid' | 'indeterminate';
+export type EvaluationResultStatus = 'achieved' | 'not_achieved' | 'indeterminate';
+export type PredictionComparisonStatus = 'matched' | 'missed' | 'indeterminate';
+export type EvaluationScalar = string | number | boolean;
+export interface EvaluationMeasurementDescriptor extends Omit<FoundationEvaluationDescriptor, 'variableRef'> {
+}
+export interface EvaluationConversionProvenance {
+    /** Stable evidence or transformation identifier, not a free-form assertion. */
+    readonly id: string;
+    readonly description: string;
+}
+export interface EvaluationMeasurementConversion {
+    /** The input measurement's exact source definition. */
+    readonly sourceRef: FoundationRef;
+    /** The exact criterion definition used after the conversion. */
+    readonly targetRef: FoundationRef;
+    readonly provenance: EvaluationConversionProvenance;
+}
+export interface EvaluationMeasurementInput {
+    readonly variableRef: FoundationRef;
+    /** The descriptor describes the effective (possibly converted) definition. */
+    readonly descriptor: EvaluationMeasurementDescriptor;
+    readonly status: EvaluationMeasurementStatus;
+    readonly value?: EvaluationScalar;
+    readonly recordedAt: string;
+    readonly evidenceRef?: string;
+    readonly conversion?: EvaluationMeasurementConversion;
+}
+export interface EvaluationMeasurement extends EvaluationMeasurementInput {
+    readonly effectiveVariableRef: FoundationRef;
+}
+export interface JudgmentValidityInput {
+    readonly status: EvaluationJudgmentValidity;
+    readonly basis: string;
+    readonly evidenceRefs?: readonly string[];
+}
+export interface JudgmentValidity extends JudgmentValidityInput {
+}
+/**
+ * A port owned by OSS and implemented by an OutcomeCase provider.  The port
+ * deliberately has a read operation only: closure, approval, and case
+ * mutation remain outside this repository.
+ */
+export interface OutcomeCaseReference {
+    readonly id: string;
+    readonly revision?: string;
+    readonly digest?: string;
+}
+export interface OutcomeCaseCanonicalReference {
+    readonly id: string;
+    readonly revision: string;
+    readonly digest: string;
+}
+export type OutcomeCaseOwnerUnknownReason = 'not_recorded' | 'legacy_untyped' | 'source_unavailable';
+export interface OutcomeCaseEntityReference {
+    readonly id: string;
+    readonly type: string;
+    readonly revision?: string;
+    readonly digest?: string;
+}
+export type OutcomeCaseOwnerReference = {
+    readonly status: 'typed';
+    readonly ref: OutcomeCaseEntityReference;
+} | {
+    readonly status: 'unknown';
+    readonly reason: OutcomeCaseOwnerUnknownReason;
+};
+export type OutcomeCaseConditionValue = string | number | boolean | null | readonly OutcomeCaseConditionValue[] | {
+    readonly [key: string]: OutcomeCaseConditionValue;
+};
+export type OutcomeCaseConditions = Readonly<Record<string, OutcomeCaseConditionValue>>;
+/**
+ * Trusted source-owned metadata returned with an OutcomeCase read.  The
+ * adapter must use this projection when creating a receipt link; caller
+ * supplied receipt state, owners, or conditions are lookup input only.
+ */
+export interface OutcomeCaseCanonicalSource {
+    readonly state: string;
+    readonly owner_refs: readonly OutcomeCaseOwnerReference[];
+    readonly conditions?: OutcomeCaseConditions;
+}
+export interface OutcomeCaseRead {
+    readonly reference: OutcomeCaseCanonicalReference;
+    /** Current source-owned identity/state projection, checked at read time. */
+    readonly source: OutcomeCaseCanonicalSource;
+    /** Current ACL, evaluated at read time. */
+    readonly acl: FoundationAcl;
+    readonly scope: FoundationScope;
+}
+export interface EvaluationAccessContext extends JudgmentProblemSnapshotAccessContext {
+    readonly scope?: FoundationScope;
+}
+export interface OutcomeCasePort {
+    read(reference: OutcomeCaseReference, actor: EvaluationAccessContext): Promise<OutcomeCaseRead>;
+}
+/**
+ * Exact definition read used by evaluation.  A caller cannot supply an
+ * Objective or criterion body as an evaluation input; this port resolves the
+ * requested revision and verifies its digest from the canonical store.
+ */
+export interface FoundationDefinitionLoadPort {
+    readExact(reference: FoundationRef, context: FoundationStoreContext): Promise<FoundationCatalogRecord | null>;
+}
+export declare function createFoundationDefinitionLoadPort(store: Pick<FoundationRevisionStore, 'read'>): FoundationDefinitionLoadPort;
+export interface CriterionEvaluation {
+    readonly criterionIndex: number;
+    readonly variableRef: FoundationRef;
+    readonly operator: ObjectiveCriterion['operator'];
+    readonly target?: string | number | boolean;
+    readonly status: EvaluationResultStatus;
+    readonly reason: string;
+}
+export interface PredictionComparison {
+    readonly criterionIndex: number;
+    readonly variableRef: FoundationRef;
+    readonly status: PredictionComparisonStatus;
+    readonly reason: string;
+    readonly predictionStatus?: EvaluationMeasurementStatus;
+    readonly actualStatus?: EvaluationMeasurementStatus;
+    readonly predictionValue?: EvaluationScalar;
+    readonly actualValue?: EvaluationScalar;
+}
+export interface CompanyOsEvaluationRecord {
+    readonly version: typeof COMPANY_OS_EVALUATION_RECORD_CATALOG_VERSION;
+    readonly id: string;
+    readonly snapshot: {
+        readonly snapshotId: string;
+        readonly problemId: string;
+        readonly revision: string;
+        readonly digest: string;
+    };
+    readonly objectiveRef: FoundationRef;
+    readonly outcomeCaseRef: OutcomeCaseCanonicalReference;
+    readonly predictions: readonly EvaluationMeasurement[];
+    readonly actuals: readonly EvaluationMeasurement[];
+    readonly criteria: readonly CriterionEvaluation[];
+    readonly predictionComparisons: readonly PredictionComparison[];
+    readonly achievement: EvaluationResultStatus;
+    readonly judgmentAtTimeValidity: JudgmentValidity;
+    readonly evaluatedAt: string;
+}
+export interface EvaluateCompanyOsProblemRequest {
+    readonly id: string;
+    readonly snapshot: {
+        readonly root: string;
+        readonly snapshotId?: string;
+        readonly problemId?: string;
+        readonly revision?: string;
+        readonly accessProvider?: JudgmentProblemSnapshotAccessProvider;
+        readonly referenceProvider: JudgmentProblemReferenceProvider;
+    };
+    readonly access: EvaluationAccessContext;
+    readonly outcomeCase: OutcomeCaseReference;
+    readonly predictions: readonly EvaluationMeasurementInput[];
+    readonly actuals: readonly EvaluationMeasurementInput[];
+    readonly judgmentAtTimeValidity: JudgmentValidityInput;
+    readonly evaluatedAt: string;
+}
+export interface CompanyOsEvaluationStore {
+    evaluate(request: EvaluateCompanyOsProblemRequest): Promise<CompanyOsEvaluationRecord>;
+    read(id: string, access: EvaluationAccessContext): Promise<CompanyOsEvaluationRecord | null>;
+    list(access: EvaluationAccessContext): Promise<readonly CompanyOsEvaluationRecord[]>;
+}
+export interface CompanyOsEvaluationStoreOptions {
+    readonly dataDir: string;
+    readonly foundation: FoundationDefinitionLoadPort;
+    readonly outcomeCase: OutcomeCasePort;
+    /**
+     * Resolver used when a stored evaluation is read back.  The evaluation
+     * record only stores a snapshot reference, so reads must resolve that exact
+     * snapshot again under the provider's current ACL/digest checks.
+     */
+    readonly snapshotReferenceProvider: JudgmentProblemReferenceProvider;
+}
+export type CompanyOsEvaluationErrorCode = 'invalid_input' | 'not_found' | 'authorization_denied' | 'scope_violation' | 'integrity_mismatch' | 'incompatible_measurement' | 'revision_conflict' | 'unsupported_graph' | 'corrupt_record' | 'readback_mismatch';
+export declare class CompanyOsEvaluationError extends Error {
+    readonly code: CompanyOsEvaluationErrorCode;
+    constructor(code: CompanyOsEvaluationErrorCode, message: string);
+}
+export declare function createCompanyOsEvaluationStore(options: CompanyOsEvaluationStoreOptions): CompanyOsEvaluationStore;