@work-graph/cli 0.2.0

package/vendor/src/onebaseRestEvidenceAdapter.mjs

@@ -0,0 +1,216 @@
+import { buildEvidenceRecordFromLegacyLine } from './evidenceReadModel.mjs';
+
+export const ONEBASE_REST_EVIDENCE_SOURCE_CHECK = 'onebase.cli.check';
+export const ONEBASE_REST_EVIDENCE_SOURCE_DESCRIBE = 'onebase.cli.describe';
+
+function normalizeCliResult(cliResult) {
+  if (!cliResult || typeof cliResult !== 'object') {
+    return {
+      ok: false,
+      exitCode: 1,
+      command: 'onebase',
+      stdout: '',
+      stderr: '',
+      failureClass: 'cli_error',
+      message: 'invalid cli result',
+    };
+  }
+
+  return cliResult;
+}
+
+export function parseOnebaseDescribePayload(stdout) {
+  const text = String(stdout ?? '').trim();
+  if (text === '') {
+    return { ok: false, error: 'empty describe stdout', payload: null };
+  }
+
+  try {
+    const payload = JSON.parse(text);
+    return { ok: true, error: null, payload };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message, payload: null };
+  }
+}
+
+export function summarizeOnebaseDescribePayload(payload) {
+  if (!payload || typeof payload !== 'object') {
+    return {
+      documents: 0,
+      catalogs: 0,
+      registers: 0,
+      reports: 0,
+      widgets: 0,
+      totalArtifacts: 0,
+    };
+  }
+
+  const counts = {
+    documents: Array.isArray(payload.documents) ? payload.documents.length : 0,
+    catalogs: Array.isArray(payload.catalogs) ? payload.catalogs.length : 0,
+    registers: Array.isArray(payload.registers) ? payload.registers.length : 0,
+    reports: Array.isArray(payload.reports) ? payload.reports.length : 0,
+    widgets: Array.isArray(payload.widgets) ? payload.widgets.length : 0,
+  };
+
+  return {
+    ...counts,
+    totalArtifacts: Object.values(counts).reduce((sum, value) => sum + value, 0),
+  };
+}
+
+export function buildEvidenceRecordsFromOnebaseCheck(taskId, cliResult, options = {}) {
+  const result = normalizeCliResult(cliResult);
+  const sequence = Number.isInteger(options.sequence) ? options.sequence : 1;
+
+  return [{
+    schema: 'evidence-record.v1',
+    id: `${taskId}:onebase-check:${sequence}`,
+    time: options.time ?? null,
+    source: ONEBASE_REST_EVIDENCE_SOURCE_CHECK,
+    taskId,
+    type: 'command',
+    summary: result.ok
+      ? `onebase check passed (${result.command ?? 'onebase check'})`
+      : `onebase check failed: ${result.message ?? result.stderr ?? result.stdout ?? 'unknown error'}`,
+    status: result.ok ? 'succeeded' : 'failed',
+    details: {
+      exitCode: result.exitCode ?? null,
+      failureClass: result.failureClass ?? null,
+      command: result.command ?? null,
+    },
+    artifacts: [{
+      kind: 'cli',
+      command: result.command ?? 'onebase check',
+      stdoutSnippet: String(result.stdout ?? '').slice(0, 500),
+      stderrSnippet: String(result.stderr ?? '').slice(0, 500),
+    }],
+  }];
+}
+
+export function buildEvidenceRecordsFromOnebaseDescribe(taskId, cliResult, options = {}) {
+  const result = normalizeCliResult(cliResult);
+  const parsed = parseOnebaseDescribePayload(result.stdout);
+  const sequence = Number.isInteger(options.sequence) ? options.sequence : 1;
+  const summaryCounts = summarizeOnebaseDescribePayload(parsed.payload);
+
+  const records = [{
+    schema: 'evidence-record.v1',
+    id: `${taskId}:onebase-describe:${sequence}`,
+    time: options.time ?? null,
+    source: ONEBASE_REST_EVIDENCE_SOURCE_DESCRIBE,
+    taskId,
+    type: 'command',
+    summary: parsed.ok
+      ? `onebase describe: ${summaryCounts.totalArtifacts} artifacts (documents=${summaryCounts.documents}, catalogs=${summaryCounts.catalogs})`
+      : `onebase describe failed: ${parsed.error ?? result.message ?? 'invalid JSON'}`,
+    status: result.ok && parsed.ok ? 'succeeded' : 'failed',
+    details: {
+      exitCode: result.exitCode ?? null,
+      failureClass: result.failureClass ?? null,
+      command: result.command ?? null,
+      counts: summaryCounts,
+      parseError: parsed.ok ? null : parsed.error,
+    },
+    artifacts: [{
+      kind: 'cli',
+      command: result.command ?? 'onebase describe --json',
+      stdoutSnippet: String(result.stdout ?? '').slice(0, 500),
+    }],
+  }];
+
+  if (parsed.ok && Array.isArray(parsed.payload?.documents)) {
+    for (const [index, document] of parsed.payload.documents.entries()) {
+      if (!document?.name) {
+        continue;
+      }
+
+      records.push({
+        schema: 'evidence-record.v1',
+        id: `${taskId}:onebase-describe:document:${index + 1}`,
+        time: options.time ?? null,
+        source: ONEBASE_REST_EVIDENCE_SOURCE_DESCRIBE,
+        taskId,
+        type: 'change',
+        summary: `document ${document.name}${document.posting ? ' (posting)' : ''}`,
+        status: 'succeeded',
+        details: {
+          onebaseKind: 'document',
+          name: document.name,
+          posting: document.posting ?? false,
+        },
+        artifacts: [{
+          kind: 'onebase-metadata',
+          name: document.name,
+          restPath: `/documents/${encodeURIComponent(document.name)}`,
+        }],
+      });
+    }
+  }
+
+  return records;
+}
+
+export function buildEvidenceRecordsFromOnebaseCli(subcommand, cliResult, taskId, options = {}) {
+  const normalized = String(subcommand ?? '').trim().toLowerCase();
+  if (normalized === 'check') {
+    return buildEvidenceRecordsFromOnebaseCheck(taskId, cliResult, options);
+  }
+
+  if (normalized === 'describe') {
+    return buildEvidenceRecordsFromOnebaseDescribe(taskId, cliResult, options);
+  }
+
+  return [];
+}
+
+export function buildOnebaseRestEvidenceAdapterResult(subcommand, cliResult, taskId, options = {}) {
+  const records = buildEvidenceRecordsFromOnebaseCli(subcommand, cliResult, taskId, options);
+  const ok = records.length > 0 && records.every((record) => record.status !== 'failed');
+
+  return {
+    schema: 'onebase.rest-evidence.adapter.v1',
+    subcommand,
+    taskId,
+    ok,
+    recordCount: records.length,
+    records,
+    workerEvidence: records.map((record) => ({
+      kind: 'onebase_rest_evidence',
+      source: record.source,
+      result: record.status === 'succeeded' ? 'succeeded' : 'failed',
+      summary: record.summary,
+      evidenceRecordId: record.id,
+    })),
+    legacyLines: records.map((record) => record.summary),
+  };
+}
+
+export function mergeOnebaseRestEvidenceIntoWorkerOutput(output, adapterResult) {
+  if (!output || !adapterResult || adapterResult.recordCount === 0) {
+    return output;
+  }
+
+  const evidence = [
+    ...(Array.isArray(output.evidence) ? output.evidence : []),
+    ...adapterResult.workerEvidence,
+  ];
+
+  return {
+    ...output,
+    evidence,
+  };
+}
+
+export function buildLegacyEvidenceLinesFromRecords(records) {
+  return (records ?? []).map((record) => record.summary).filter(Boolean);
+}
+
+export function coerceOnebaseRestEvidenceRecord(record, taskId, index) {
+  if (record?.schema === 'evidence-record.v1') {
+    return record;
+  }
+
+  return buildEvidenceRecordFromLegacyLine(taskId, String(record ?? ''), index);
+}

package/vendor/src/onebaseVectorDslCodegenReadiness.mjs

@@ -0,0 +1,137 @@
+import { access, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { readWorkItemsFromIntentTree } from './intentTreeWorkItems.mjs';
+import { RELEASE_GATE_ROWS } from './releaseGateMatrix.mjs';
+import { buildOneBaseMcpParityMatrix } from './onebaseWorkItemTemplate.mjs';
+
+export const ONEBASE_VECTOR_DSL_CODEGEN_READINESS_SCHEMA = 'onebase.vector-dsl.codegen-readiness.v1';
+export const ONEBASE_CODEGEN_PILOT_WORK_ID = 'onebase-vector-dsl-codegen-pilot';
+
+const DONE_STATUSES = new Set(['done', 'verified']);
+const APPROVED_PILOT_STATUSES = new Set(['ready', 'claimed', 'doing', 'in_progress', 'verify', 'done', 'verified']);
+
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function itemById(items) {
+  return new Map(items.map((item) => [item.id, item]));
+}
+
+function hasGoldenPathEvidence(items) {
+  const goldenPathIds = [
+    'onebase-implement-gross-profit-warehouse-dimension',
+    'onebase-posting-rule-golden-path',
+    'onebase-posting-scenario-design',
+  ];
+  return goldenPathIds.some((id) => {
+    const item = items.find((entry) => entry.id === id);
+    return item && DONE_STATUSES.has(item.status);
+  });
+}
+
+/**
+ * @param {{ cwd?: string, items?: import('./workGraphRuntime.mjs').WorkItem[], releaseGateRows?: typeof RELEASE_GATE_ROWS, deferStepPath?: string }} [options]
+ */
+export async function evaluateOnebaseVectorDslCodegenReadiness(options = {}) {
+  const cwd = resolve(options.cwd ?? process.cwd());
+  const items = options.items ?? await readWorkItemsFromIntentTree({ cwd });
+  const byId = itemById(items);
+  const releaseGateRows = options.releaseGateRows ?? RELEASE_GATE_ROWS;
+  const deferStepPath = resolve(cwd, options.deferStepPath ?? 'domains/onebase/defer-vector-dsl-codegen.bvc');
+
+  const phase7 = byId.get('phase-7-onebase-vertical');
+  const templatePath = resolve(cwd, 'domains/onebase/workitem-template.bvc');
+  const mcpParityPath = resolve(cwd, 'protocols/onebase-mcp-parity-v1.bvc');
+  const pilotItem = byId.get(ONEBASE_CODEGEN_PILOT_WORK_ID);
+
+  const phase7Closed = Boolean(phase7 && DONE_STATUSES.has(phase7.status));
+  const templateExists = await pathExists(templatePath);
+  const mcpParityExists = await pathExists(mcpParityPath);
+  const parityMatrix = buildOneBaseMcpParityMatrix();
+  const goldenPathRepeatable = hasGoldenPathEvidence(items);
+  const optionalOnebaseGate = releaseGateRows.some((row) => row.command === 'npm run test:optional:onebase');
+  const compilerRoundtripGate = releaseGateRows.some((row) => row.id === 'compiler-roundtrip-fixture');
+  const pilotApproved = Boolean(
+    pilotItem
+    && APPROVED_PILOT_STATUSES.has(pilotItem.status)
+    && String(pilotItem.labels?.['migration.strategy'] ?? '').trim() !== 'defer',
+  );
+
+  const triggers = [
+    {
+      id: 'phase-7-closed-with-bridge-artifacts',
+      label: 'phase-7-onebase-vertical closed with template + MCP parity + ≥1 repeatable golden path',
+      met: phase7Closed && templateExists && mcpParityExists && goldenPathRepeatable,
+      evidence: [
+        phase7 ? `phase-7 status=${phase7.status}` : 'phase-7 missing',
+        templateExists ? templatePath : 'missing workitem template',
+        mcpParityExists ? mcpParityPath : 'missing MCP parity protocol',
+        goldenPathRepeatable ? 'golden-path work item done' : 'no done golden-path work item',
+      ],
+    },
+    {
+      id: 'optional-onebase-ci-tier',
+      label: 'npm run test:optional:onebase registered in optional CI tier',
+      met: optionalOnebaseGate,
+      evidence: optionalOnebaseGate
+        ? 'releaseGateMatrix optional-env onebase-go-optional'
+        : 'release gate row missing',
+    },
+    {
+      id: 'compiler-roundtrip-wired',
+      label: 'Compiler round-trip evidence contract wired for compiler-mode steps',
+      met: compilerRoundtripGate,
+      evidence: compilerRoundtripGate
+        ? 'releaseGateMatrix compiler-roundtrip-fixture'
+        : 'compiler roundtrip gate missing',
+    },
+    {
+      id: 'codegen-pilot-approved',
+      label: `Explicit WorkItem ${ONEBASE_CODEGEN_PILOT_WORK_ID} approved (not auto-promotion)`,
+      met: pilotApproved,
+      evidence: pilotApproved
+        ? `${ONEBASE_CODEGEN_PILOT_WORK_ID} status=${pilotItem.status}`
+        : `create/promote ${ONEBASE_CODEGEN_PILOT_WORK_ID} when reopening codegen`,
+    },
+  ];
+
+  const deferStepText = await readFile(deferStepPath, 'utf8');
+  const recommendation = triggers.every((trigger) => trigger.met) ? 'reopen-codegen-pilot' : 'keep-deferred';
+
+  return {
+    schema: ONEBASE_VECTOR_DSL_CODEGEN_READINESS_SCHEMA,
+    recommendation,
+    readyToReopenCodegen: recommendation === 'reopen-codegen-pilot',
+    deferStepPath,
+    parityCapabilityCount: parityMatrix?.rows?.length ?? 0,
+    triggerCount: triggers.length,
+    metCount: triggers.filter((trigger) => trigger.met).length,
+    triggers,
+    checklist: triggers.map((trigger) => ({
+      criterion: trigger.label,
+      met: trigger.met,
+      evidence: trigger.evidence,
+    })),
+    deferStepReferencesReadiness: deferStepText.includes('evaluateOnebaseVectorDslCodegenReadiness')
+      || deferStepText.includes('onebaseVectorDslCodegenReadiness'),
+  };
+}
+
+export function formatOnebaseVectorDslCodegenReadinessReport(report) {
+  const lines = [
+    `onebase vector-dsl codegen readiness: ${report.recommendation} (${report.metCount}/${report.triggerCount} triggers met)`,
+  ];
+
+  for (const trigger of report.triggers) {
+    lines.push(`${trigger.met ? 'ok' : 'pending'}: ${trigger.label}`);
+  }
+
+  return lines.join('\n');
+}

package/vendor/src/onebaseWorkItemTemplate.mjs

@@ -0,0 +1,154 @@
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+export const ONEBASE_WORKITEM_TEMPLATE_V1 = {
+  schema: 'onebase.workitem.template.v1',
+  department: 'product-architecture',
+  domainId: 'onebase',
+  verificationCwd: '../onebase',
+  preflightCommand: 'go version',
+  primaryCommand: 'go test ./...',
+  workGraphVerifyCommand: 'npm run test:optional:onebase',
+  staticGateCommand: 'verifyOnebaseGrossProfitWarehouseArtifacts',
+};
+
+export function buildOneBaseWorkItemDraft(input) {
+  if (input === undefined || input === null || typeof input !== 'object') {
+    throw new TypeError('input must be an object');
+  }
+
+  const workId = String(input.workId ?? '').trim();
+  if (workId === '') {
+    throw new Error('workId is required');
+  }
+
+  const document = String(input.document ?? input.onebaseDocument ?? '').trim();
+  const rule = String(input.rule ?? input.onebaseRule ?? '').trim();
+  const title = String(input.title ?? `OneBase: ${rule || document || workId}`).trim();
+  const targetFiles = [...(input.targetFiles ?? [])].map(String).filter(Boolean).sort(compareText);
+  const rollbackNotes = String(input.rollbackNotes ?? '').trim();
+  const restEvidenceRefs = [...(input.restEvidenceRefs ?? [])].map(String).filter(Boolean).sort(compareText);
+
+  const basis = input.basis ?? `OneBase change for ${document || rule || workId}.`;
+  const vector = input.vector ?? 'Update bounded YAML/.os/report artifacts per domains/onebase/artifact-mapping.bvc.';
+  const goal = input.goal ?? 'Repeatable domain change with deterministic verification evidence.';
+
+  const checks = [
+    'metadata scan или artifact-mapping выполнен до правок',
+    'target YAML/.os/report/widget files перечислены в work.target_files',
+    'go version preflight + go test ./... или blocked environment evidence записаны',
+    'rollback notes и preserved invariants задокументированы',
+  ];
+
+  if (restEvidenceRefs.length > 0) {
+    checks.push('REST evidence refs записаны или помечены blocked');
+  }
+
+  return {
+    schema: 'onebase.workitem.draft.v1',
+    template: ONEBASE_WORKITEM_TEMPLATE_V1.schema,
+    atomName: `#OneBase_${workId.replace(/-/gu, '_')}<[`,
+    sections: {
+      basis,
+      vector,
+      goal,
+      checks,
+      evidenceHints: [
+        ONEBASE_WORKITEM_TEMPLATE_V1.workGraphVerifyCommand,
+        `${ONEBASE_WORKITEM_TEMPLATE_V1.preflightCommand} + ${ONEBASE_WORKITEM_TEMPLATE_V1.primaryCommand}`,
+        ONEBASE_WORKITEM_TEMPLATE_V1.staticGateCommand,
+      ],
+      rollbackNotes,
+    },
+    labels: {
+      'atom.profile': 'work_item',
+      'work.id': workId,
+      'work.title': title,
+      'work.status': input.status ?? 'backlog',
+      'work.department': ONEBASE_WORKITEM_TEMPLATE_V1.department,
+      'work.owner_role': input.ownerRole ?? 'domain_architect',
+      'work.target_files': targetFiles.join(', '),
+      'domain.id': ONEBASE_WORKITEM_TEMPLATE_V1.domainId,
+      'onebase.document': document,
+      'onebase.rule': rule,
+      'verification.primary_command': ONEBASE_WORKITEM_TEMPLATE_V1.primaryCommand,
+      'verification.preflight_command': ONEBASE_WORKITEM_TEMPLATE_V1.preflightCommand,
+      'verification.cwd': ONEBASE_WORKITEM_TEMPLATE_V1.verificationCwd,
+      ...(restEvidenceRefs.length > 0 ? { 'onebase.rest_evidence_refs': restEvidenceRefs.join(', ') } : {}),
+      ...(rollbackNotes ? { 'onebase.rollback_notes': rollbackNotes.slice(0, 200) } : {}),
+      'trace.status': 'pending',
+      'migration.strategy': input.migrationStrategy ?? 'port',
+    },
+    dependsOn: [...(input.dependsOn ?? ['onebase-posting-rule-golden-path'])].sort(compareText),
+  };
+}
+
+export function buildOneBaseMcpParityMatrix() {
+  return {
+    schema: 'onebase.access.parity.v1',
+    rows: [
+      {
+        capability: 'metadata_scan',
+        builtInTool: 'onebaseListMetadata',
+        mcpTool: 'list_metadata',
+        workGraphCli: 'verifyOnebaseGrossProfitWarehouseArtifacts',
+        ciGate: false,
+        notes: 'list_metadata prefers onebase describe --json with scan fallback',
+      },
+      {
+        capability: 'describe_config',
+        builtInTool: null,
+        mcpTool: 'describe_config',
+        workGraphCli: 'onebase describe --json',
+        ciGate: false,
+      },
+      {
+        capability: 'check_config',
+        builtInTool: null,
+        mcpTool: 'check_config',
+        workGraphCli: 'onebase check',
+        ciGate: false,
+        notes: 'optional operator/DoD gate when OneBase CLI supports check',
+      },
+      {
+        capability: 'ai_guide',
+        builtInTool: null,
+        mcpTool: 'ai_guide',
+        workGraphCli: 'onebase ai-guide',
+        ciGate: false,
+      },
+      {
+        capability: 'read_config_file',
+        builtInTool: 'workspace read + scan',
+        mcpTool: 'read_config_file',
+        workGraphCli: 'static artifact verify',
+        ciGate: false,
+      },
+      {
+        capability: 'rest_read',
+        builtInTool: 'onebaseRestCall',
+        mcpTool: 'rest_get',
+        workGraphCli: 'optional manual',
+        ciGate: false,
+      },
+      {
+        capability: 'dev_health',
+        builtInTool: 'onebaseDevStatus',
+        mcpTool: 'env ONEBASE_* in MCP server',
+        workGraphCli: 'go version preflight',
+        ciGate: true,
+      },
+      {
+        capability: 'deterministic_verify',
+        builtInTool: null,
+        mcpTool: null,
+        workGraphCli: 'npm run test:optional:onebase',
+        ciGate: true,
+      },
+    ],
+    rules: [
+      'CI/done gate uses work graph CLI only',
+      'MCP and built-in tools are discovery/agent paths',
+      'REST evidence is optional and may be blocked',
+    ],
+  };
+}