mirai-graph 1.5.0 → 2.3.0-alpha.1

package/packages/cli/playground-demo.js

@@ -1,114 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, "utf8"));
-}
-
-function countItems(filePath) {
-  const value = readJson(filePath);
-  return Array.isArray(value) ? value.length : 0;
-}
-
-const packageDir = "benchmarks/synthetic-context-reduction-v0";
-const objectsCount = countItems(`${packageDir}/graph/objects.json`);
-const relationsCount = countItems(`${packageDir}/graph/relations.json`);
-const contextPack = readJson(`${packageDir}/results/context-pack.json`);
-const launchRecord = readJson("examples/launch-record-minimal/results/launch-record.json");
-const transition = readJson("examples/process-transition-minimal/transition-request.json");
-const transitionExplanation = readJson("examples/process-transition-minimal/results/transition-explanation-valid.json");
-const processControl = readJson("examples/process-control-contract-minimal/results/process-control-contract.json");
-const baselineComparison = readJson(`${packageDir}/results/baseline-comparison-result.json`);
-const cockpit = readJson("examples/instrumentation-layer-minimal/results/development-cockpit.json");
-const traceability = readJson("examples/instrumentation-layer-minimal/results/feature-implementation-traceability.json");
-const feedback = readJson("examples/instrumentation-layer-minimal/results/multi-source-quality-feedback.json");
-
-const lines = [
-  "# Mirai Graph Playground Demo Report",
-  "",
-  "Status: deterministic 1.0.0-rc.6 demo",
-  "",
-  "## Control Loop",
-  "",
-  "```text",
-  "seed -> graph -> context -> launch -> transition explanation -> cockpit -> traceability -> multi-source feedback -> evidence -> kaizen -> baseline comparison",
-  "```",
-  "",
-  "## Demo Inputs",
-  "",
-  `- Synthetic package: \`${packageDir}\``,
-  `- Objects: \`${objectsCount}\``,
-  `- Relations: \`${relationsCount}\``,
-  `- Context pack: \`${contextPack.id}\``,
-  `- Launch record: \`${launchRecord.id}\``,
-  `- Transition request: \`${transition.id}\``,
-  `- Transition explanation: \`${transitionExplanation.fixture_id}\``,
-  `- Process-control contract: \`${processControl.id}\``,
-  `- Development cockpit: \`${cockpit.id}\``,
-  `- Feature traceability: \`${traceability.id}\``,
-  `- Multi-source feedback: \`${feedback.id}\``,
-  `- Baseline comparison: \`${baselineComparison.id}\``,
-  "",
-  "## Commands",
-  "",
-  "```bash",
-  "npm run validate:minimal",
-  "npm run seed:preview",
-  "npm run context:generate",
-  "npm run validate:launch-record",
-  "npm run validate:process-transition",
-  "npm run validate:process-transition-report",
-  "npm run validate:process-control",
-  "npm run validate:instrumentation-layer",
-  "npm run validate:instrumentation-report",
-  "npm run validate:implementation-control-cycles",
-  "npm run validate:baseline-comparison",
-  "```",
-  "",
-  "## Transition Explanation",
-  "",
-  `- Requested transition: \`${transitionExplanation.explanation.current_state} -> ${transitionExplanation.explanation.target_state}\``,
-  `- Matched transition: \`${transitionExplanation.explanation.matched_transition ? "true" : "false"}\``,
-  `- Required evidence: \`${transitionExplanation.explanation.required_evidence.join(", ")}\``,
-  `- Missing evidence: \`${transitionExplanation.explanation.missing_evidence.length}\``,
-  `- Kaizen decision: \`${transitionExplanation.explanation.kaizen_decision.status}\``,
-  "",
-  "## Instrumentation",
-  "",
-  `- Cockpit production readiness: \`${cockpit.readiness.production_readiness}\``,
-  `- Cockpit next action: \`${cockpit.next_best_action.action}\``,
-  `- Feature mappings: \`${traceability.coverage_summary.mapped_feature_count}\``,
-  `- Evidence-backed mappings: \`${traceability.coverage_summary.evidence_backed_mapping_count}\``,
-  `- Multi-source feedback verdict: \`${feedback.verdict}\``,
-  `- Blocking findings: \`${feedback.blocking_findings.length}\``,
-  `- Kaizen refs: \`${feedback.kaizen_refs.join(", ")}\``,
-  "",
-  "## Baseline Comparison",
-  "",
-  `- Baseline context units: \`${baselineComparison.baseline.context_units}\``,
-  `- Mirai Graph context units: \`${baselineComparison.mirai_graph.context_units}\``,
-  `- Context reduction: \`${baselineComparison.outcome.context_reduction_percent}%\``,
-  `- Baseline missed dependencies: \`${baselineComparison.baseline.missed_dependencies}\``,
-  `- Mirai Graph missed dependencies: \`${baselineComparison.mirai_graph.missed_dependencies}\``,
-  `- Verdict: \`${baselineComparison.outcome.verdict}\``,
-  "",
-  "## What This Demonstrates",
-  "",
-  "- Mirai Graph can validate a graph package.",
-  "- Mirai Graph can generate task-specific context from graph state.",
-  "- Launch records describe bounded work permission.",
-  "- Process transitions are checked and explained against an executable state machine.",
-  "- Process-control contracts bind launch, evidence, recovery and Kaizen policy.",
-  "- Instrumentation connects cockpit signals, feature traceability and multi-source feedback.",
-  "- Baseline comparison records synthetic measurement boundaries.",
-  "",
-  "## Boundaries",
-  "",
-  "- This is a public-safe synthetic demo.",
-  "- Generated context is not canonical state.",
-  "- Evidence and proposals do not authorize canonical updates.",
-  "- Synthetic evidence is not broad scientific proof."
-];
-
-console.log(lines.join("\n"));

package/packages/cli/project-technology.js

@@ -1,149 +0,0 @@
-#!/usr/bin/env node
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const { execute } = require("../project-technology");
-
-function usage() {
-  console.error("Usage: mirai-graph technology <operation> [repository] [options]");
-  console.error("Read-only: explain | status | plan | verify | context");
-  console.error("Transactional: enable | sync | connect | disconnect | provide | disable | repair");
-  console.error("Options: --apply --task <text> --source <file> --target-id <id>");
-  console.error("         --semantic-digest <sha256:...> --provider-revision <sha>");
-  console.error("         --refresh-binding --significant-work --max-objects <count>");
-  console.error("Archive connect: --provider-archive-trust <verified-release-anchor.json>");
-  console.error("Continuity: sync --boundary task_start|stage_complete|task_complete [--evidence <json>] [--expected-graph-digest <sha256:...>]");
-  console.error("            verify --significant-work [--receipt-digest <sha256:...>]");
-  console.error("Context: --phase discover --task <text>");
-  console.error("         --phase expand --input <receipt.json> --select <id> [--select <id>]");
-  console.error("         --phase compile --input <receipt.json> --selection <selection.json>");
-  console.error("         --phase verify --packet <context-pack.json> --evidence <usage-evidence.json>");
-  console.error("Artifacts: artifact inspect <repo> --input <path>");
-  console.error("           artifact release <repo> --input <path> --matter-id <id> --direction inbound|internal|outbound [--parent-release <id>] [--client-note <text>] [--create-export] [--apply]");
-  console.error("           artifact compare <repo> --matter-id <id> --base-release <id> --target-release <id>");
-  console.error("           artifact verify <repo> --matter-id <id> --release-id <id>");
-  console.error("Courses: course compile <repo> --technology <file> [--scenario <id>] [--audience <id>]");
-  console.error("         course verify <repo> --course-pack <file>");
-  console.error("         course reconcile <repo> --course-pack <file> --projection <file>");
-}
-
-function parse(argv) {
-  if (!argv.length) return null;
-  const operation = argv.shift();
-  let artifactAction = null;
-  let courseAction = null;
-  if (operation === "artifact") {
-    artifactAction = argv.shift() || null;
-    if (!new Set(["inspect", "release", "compare", "verify"]).has(artifactAction)) throw new Error("artifact requires inspect, release, compare or verify");
-  }
-  if (operation === "course") {
-    courseAction = argv.shift() || null;
-    if (!new Set(["compile", "verify", "reconcile"]).has(courseAction)) throw new Error("course requires compile, verify or reconcile");
-  }
-  let repository = ".";
-  if (argv[0] && !argv[0].startsWith("--")) repository = argv.shift();
-  const options = {};
-  const values = new Set(["--task", "--source", "--target-id", "--semantic-digest", "--provider-revision", "--max-objects", "--phase", "--input", "--select", "--selection", "--packet", "--evidence", "--selector", "--reason", "--confidence", "--context-budget", "--boundary", "--expected-graph-digest", "--receipt-digest", "--state-root", "--matter-id", "--direction", "--artifact-root", "--release-date", "--release-id", "--parent-release", "--base-release", "--target-release", "--client-note", "--technology", "--scenario", "--audience", "--course-pack", "--projection"]);
-  const flags = new Set(["--apply", "--refresh-binding", "--significant-work", "--create-export"]);
-  values.add("--provider-archive-trust");
-  const names = {
-    "--provider-archive-trust": "providerArchiveTrustFile",
-    "--task": "task", "--source": "source", "--target-id": "targetId",
-    "--semantic-digest": "semanticDigest", "--provider-revision": "providerRevision",
-    "--max-objects": "maxObjects", "--apply": "apply",
-    "--refresh-binding": "refreshBinding", "--significant-work": "significantWork",
-    "--phase": "phase", "--input": "input", "--select": "selectedIds",
-    "--selection": "selectionFile", "--packet": "packetFile", "--evidence": "evidenceFile",
-    "--selector": "selector", "--reason": "reason", "--confidence": "confidence",
-    "--context-budget": "contextBudget",
-    "--boundary": "boundary", "--expected-graph-digest": "expectedGraphDigest",
-    "--receipt-digest": "receiptDigest", "--state-root": "stateRoot",
-    "--matter-id": "matterId", "--direction": "direction", "--artifact-root": "artifactRoot",
-    "--release-date": "releaseDate", "--release-id": "releaseId",
-    "--parent-release": "parentReleaseIds", "--base-release": "baseReleaseId",
-    "--target-release": "targetReleaseId", "--client-note": "clientNote",
-    "--create-export": "createExport",
-    "--technology": "technologyFile", "--scenario": "scenarioIds",
-    "--audience": "audience", "--course-pack": "coursePackFile", "--projection": "projectionFile",
-  };
-  while (argv.length) {
-    const token = argv.shift();
-    if (flags.has(token)) options[names[token]] = true;
-    else if (values.has(token)) {
-      if (!argv.length) throw new Error(`missing value for ${token}`);
-      const value = argv.shift();
-      if (token === "--select") options.selectedIds = [...(options.selectedIds || []), value];
-      else if (token === "--parent-release") options.parentReleaseIds = [...(options.parentReleaseIds || []), value];
-      else if (token === "--scenario") options.scenarioIds = [...(options.scenarioIds || []), value];
-      else options[names[token]] = value;
-    } else throw new Error(`unsupported argument ${token}`);
-  }
-  if (artifactAction) options.artifactAction = artifactAction;
-  if (courseAction) options.courseAction = courseAction;
-  return { operation, repository: path.resolve(repository), options };
-}
-
-function readJsonFile(file) {
-  const absolute = path.resolve(file);
-  if (!fs.existsSync(absolute) || fs.lstatSync(absolute).isSymbolicLink()) throw new Error(`unsafe or missing JSON input ${file}`);
-  return JSON.parse(fs.readFileSync(absolute, "utf8").replace(/^\uFEFF/, ""));
-}
-
-function hydrateContextOptions(request) {
-  if (request.options.providerArchiveTrustFile) {
-    if (request.operation !== "connect") throw new Error("archive trust is only supported by connect");
-    request.options.providerArchive = request.options.providerArchiveTrustFile === "-"
-      ? JSON.parse(fs.readFileSync(0, "utf8")) : readJsonFile(request.options.providerArchiveTrustFile);
-  }
-  if (request.operation === "sync" && request.options.boundary) {
-    if (request.options.boundary !== "task_start" && !request.options.evidenceFile) throw new Error(`${request.options.boundary} requires --evidence`);
-    if (request.options.evidenceFile) request.options.continuityEvidence = readJsonFile(request.options.evidenceFile);
-    return;
-  }
-  if (request.operation !== "context" || !request.options.phase) return;
-  const phase = request.options.phase;
-  if (!new Set(["discover", "expand", "compile", "verify"]).has(phase)) throw new Error(`unsupported context phase ${phase}`);
-  if (["expand", "compile"].includes(phase)) {
-    if (!request.options.input) throw new Error(`${phase} requires --input`);
-    const payload = readJsonFile(request.options.input);
-    request.options.traversalReceipt = payload.traversal_receipt || payload;
-  }
-  if (phase === "compile") {
-    if (!request.options.selectionFile) throw new Error("compile requires --selection");
-    request.options.selection = readJsonFile(request.options.selectionFile);
-  }
-  if (phase === "verify") {
-    if (!request.options.packetFile || !request.options.evidenceFile) throw new Error("verify requires --packet and --evidence");
-    const packet = readJsonFile(request.options.packetFile);
-    request.options.contextPack = packet.context_pack || packet;
-    request.options.usageEvidence = readJsonFile(request.options.evidenceFile);
-  }
-}
-
-let request;
-try { request = parse(process.argv.slice(2)); }
-catch (error) {
-  console.error(error.message); usage(); process.exit(1);
-}
-if (!request) { usage(); process.exit(1); }
-try { hydrateContextOptions(request); }
-catch (error) { console.error(error.message); usage(); process.exit(1); }
-
-let output;
-try { output = execute(request.operation, request.repository, request.options); }
-catch (error) {
-  output = {
-    schema_version: "1.0.0",
-    operation_id: `mirai.project_technology.${request.operation}`,
-    operation_mode: "read_only",
-    status: "fail",
-    changed: false,
-    blockers: ["project_technology_unhandled_error"],
-    warnings: [],
-    next_action: "inspect the local error and retry safely",
-  };
-}
-process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-process.exitCode = output.status === "fail" ? 1 : ["blocked", "needs_more_discovery", "needs_decision"].includes(output.status) ? 2 : 0;

package/packages/cli/readiness-score.js

@@ -1,164 +0,0 @@
-#!/usr/bin/env node
-
-const fs = require("fs");
-const path = require("path");
-
-function usage() {
-  console.error("Usage: node packages/cli/readiness-score.js <package-dir> [--target-mode discovery|canonical|pilot|controlled_runtime|production_runtime] [--write <output-file>]");
-}
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, "utf8"));
-}
-
-function findManifestPath(packageDir) {
-  const current = path.join(packageDir, "graph.json");
-  if (fs.existsSync(current)) return current;
-  return path.join(packageDir, "mirai-graph-package.json");
-}
-
-function exists(filePath) {
-  return fs.existsSync(filePath);
-}
-
-function scorePackage(packageDir, targetMode) {
-  const manifestPath = findManifestPath(packageDir);
-  const graphObjectsPath = path.join(packageDir, "graph", "objects.json");
-  const graphRelationsPath = path.join(packageDir, "graph", "relations.json");
-  const gateResultsPath = path.join(packageDir, "gates", "results.json");
-
-  const evidence = [];
-  const blockers = [];
-  const manifest = exists(manifestPath) ? readJson(manifestPath) : null;
-  let score = 0;
-
-  if (manifest) {
-    score += 10;
-    evidence.push("package manifest exists");
-  } else {
-    blockers.push("missing package manifest");
-  }
-
-  if (exists(graphObjectsPath) && exists(graphRelationsPath)) {
-    const objects = readJson(graphObjectsPath);
-    const relations = readJson(graphRelationsPath);
-    if (Array.isArray(objects) && objects.length > 0) {
-      score += 15;
-      evidence.push(`objects exist: ${objects.length}`);
-    }
-    if (Array.isArray(relations)) {
-      score += 10;
-      evidence.push(`relations exist: ${relations.length}`);
-    }
-    const evidenceObjects = Array.isArray(objects)
-      ? objects.filter((object) => object.kind === "evidence").length
-      : 0;
-    if (evidenceObjects > 0) {
-      score += 15;
-      evidence.push(`evidence objects exist: ${evidenceObjects}`);
-    }
-    const acceptedObjects = Array.isArray(objects)
-      ? objects.filter((object) => object.readiness === "accepted").length
-      : 0;
-    if (acceptedObjects > 0) {
-      score += 10;
-      evidence.push(`accepted objects exist: ${acceptedObjects}`);
-    }
-  } else {
-    blockers.push("missing graph objects or relations");
-  }
-
-  if (exists(gateResultsPath)) {
-    const gateResults = readJson(gateResultsPath);
-    if (Array.isArray(gateResults) && gateResults.length > 0) {
-      score += 15;
-      evidence.push(`gate results exist: ${gateResults.length}`);
-    }
-  }
-
-  const contextPackPath = path.join(packageDir, "expected", "context-pack-compact.md");
-  if (exists(contextPackPath)) {
-    score += 10;
-    evidence.push("context pack example exists");
-  }
-
-  const metricsPath = path.join(packageDir, "metrics", "example-metrics.json");
-  if (exists(metricsPath)) {
-    score += 10;
-    evidence.push("benchmark metric example exists");
-  }
-
-  const caps = [];
-  if (blockers.length > 0) {
-    caps.push({ reason: "structural blockers exist", max_score: 39 });
-  }
-  if (targetMode !== "discovery" && !exists(gateResultsPath)) {
-    caps.push({ reason: "no gate results for non-discovery target", max_score: 59 });
-  }
-  if (["pilot", "controlled_runtime", "production_runtime"].includes(targetMode) && !exists(metricsPath)) {
-    caps.push({ reason: "no benchmark evidence for pilot/runtime target", max_score: 69 });
-  }
-  if (
-    manifest &&
-    typeof manifest.public_safety === "string" &&
-    manifest.public_safety.includes("synthetic") &&
-    ["pilot", "controlled_runtime", "production_runtime"].includes(targetMode)
-  ) {
-    caps.push({ reason: "synthetic-only evidence cannot exceed pilot-ready navigation score", max_score: 69 });
-  }
-  if (["controlled_runtime", "production_runtime"].includes(targetMode)) {
-    caps.push({ reason: "runtime policy is not implemented in public alpha", max_score: 74 });
-  }
-
-  for (const cap of caps) {
-    score = Math.min(score, cap.max_score);
-  }
-
-  return {
-    schema_version: "0.1.0",
-    target_mode: targetMode,
-    score,
-    band: score < 20
-      ? "G0_raw"
-      : score < 40
-        ? "G1_extracted"
-        : score < 60
-          ? "G2_canonical"
-          : score < 75
-            ? "G3_pilot_ready"
-            : score < 90
-              ? "G4_controlled_runtime_candidate"
-              : "G5_runtime_stable",
-    evidence,
-    blockers,
-    caps,
-    note: "Release-candidate readiness score; use as navigation, not approval."
-  };
-}
-
-const packageDir = process.argv[2];
-const targetModeIndex = process.argv.indexOf("--target-mode");
-const writeFlagIndex = process.argv.indexOf("--write");
-const targetMode = targetModeIndex >= 0 ? process.argv[targetModeIndex + 1] : "discovery";
-const outputPath = writeFlagIndex >= 0 ? process.argv[writeFlagIndex + 1] : null;
-
-if (!packageDir || (targetModeIndex >= 0 && !targetMode) || (writeFlagIndex >= 0 && !outputPath)) {
-  usage();
-  process.exit(2);
-}
-
-try {
-  const result = scorePackage(path.resolve(packageDir), targetMode);
-  const output = JSON.stringify(result, null, 2);
-
-  if (outputPath) {
-    const resolvedOutputPath = path.resolve(outputPath);
-    fs.mkdirSync(path.dirname(resolvedOutputPath), { recursive: true });
-    fs.writeFileSync(resolvedOutputPath, `${output}\n`);
-  }
-
-  console.log(output);
-} catch (error) {
-  console.error(error.message);
-  process.exit(1);
-}