@iowarp/clio-coder 0.3.0

package/dist/evolve-YDZSUQYA.js

@@ -0,0 +1,518 @@
+import {
+  listEvidenceOverviews
+} from "./chunk-GNGDQYDU.js";
+import "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  clioDataDir
+} from "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/evolve.ts
+import { resolve } from "node:path";
+
+// src/domains/evolution/manifest.ts
+import { readFile } from "node:fs/promises";
+var CHANGE_MANIFEST_VERSION = 1;
+var FIRST_EXPLORATORY_ITERATION_ID = "exploratory-1";
+var MANIFEST_AUTHORITY_LEVELS = [
+  "prompt",
+  "tool-description",
+  "tool-implementation",
+  "middleware",
+  "memory",
+  "runtime",
+  "safety",
+  "schema",
+  "cli"
+];
+var HIGH_AUTHORITY_LEVELS = [
+  "tool-implementation",
+  "middleware",
+  "runtime",
+  "safety",
+  "schema",
+  "cli"
+];
+var BUDGET_IMPACT_RISKS = ["lower", "same", "higher"];
+async function loadChangeManifestJson(path) {
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") throw new Error(`change manifest not found: ${path}`);
+    throw error;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${path}: invalid JSON: ${message}`);
+  }
+}
+function createChangeManifestTemplate() {
+  return {
+    version: CHANGE_MANIFEST_VERSION,
+    iterationId: FIRST_EXPLORATORY_ITERATION_ID,
+    baseGitSha: "0000000000000000000000000000000000000000",
+    createdAt: "2026-04-29T00:00:00.000Z",
+    changes: [
+      {
+        id: "change-1",
+        componentIds: ["context-file:CLIO-CODER.md"],
+        filesChanged: ["CLIO-CODER.md"],
+        authorityLevel: "prompt",
+        evidenceRefs: [],
+        rootCause: "First exploratory iteration; no evidence corpus exists yet.",
+        targetedFix: "Describe the smallest proposed harness change.",
+        predictedFixes: ["One expected improvement."],
+        predictedRegressions: [],
+        validationPlan: ["npm run test"],
+        rollbackPlan: "Revert the filesChanged entries for this change.",
+        expectedBudgetImpact: {
+          risk: "same"
+        }
+      }
+    ]
+  };
+}
+function isHighAuthorityLevel(level) {
+  return HIGH_AUTHORITY_LEVELS.includes(level);
+}
+function allowsEmptyEvidenceRefs(iterationId) {
+  return iterationId === FIRST_EXPLORATORY_ITERATION_ID;
+}
+function summarizeChangeManifest(manifest) {
+  const authoritySet = /* @__PURE__ */ new Set();
+  const componentIds = /* @__PURE__ */ new Set();
+  const filesChanged = /* @__PURE__ */ new Set();
+  const predictedRegressions = /* @__PURE__ */ new Set();
+  let validationPlanCount = 0;
+  for (const change of manifest.changes) {
+    authoritySet.add(change.authorityLevel);
+    for (const componentId of change.componentIds) componentIds.add(componentId);
+    for (const file of change.filesChanged) filesChanged.add(file);
+    for (const regression of change.predictedRegressions) predictedRegressions.add(regression);
+    validationPlanCount += change.validationPlan.length;
+  }
+  return {
+    iterationId: manifest.iterationId,
+    baseGitSha: manifest.baseGitSha,
+    changeCount: manifest.changes.length,
+    authorityLevels: MANIFEST_AUTHORITY_LEVELS.filter((level) => authoritySet.has(level)),
+    componentIds: [...componentIds].sort(compareStrings),
+    filesChanged: [...filesChanged].sort(compareStrings),
+    predictedRegressions: [...predictedRegressions].sort(compareStrings),
+    validationPlanCount
+  };
+}
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+
+// src/domains/evolution/validate.ts
+var EVIDENCE_REF_PREFIXES = ["run-", "session-"];
+function validateChangeManifest(value, options) {
+  const issues = [];
+  if (!isRecord(value)) {
+    issues.push({ path: "$", message: "expected manifest object" });
+    return invalid(issues);
+  }
+  if (value.version !== CHANGE_MANIFEST_VERSION) {
+    issues.push({ path: "$.version", message: "must equal 1" });
+  }
+  const iterationId = readRequiredString(value, "$.iterationId", issues);
+  const baseGitSha = readRequiredString(value, "$.baseGitSha", issues);
+  const createdAt = readRequiredString(value, "$.createdAt", issues);
+  const changes = readChanges(value, iterationId, issues, options);
+  if (issues.length > 0 || iterationId === null || baseGitSha === null || createdAt === null || changes === null) {
+    return invalid(issues);
+  }
+  return {
+    valid: true,
+    manifest: {
+      version: CHANGE_MANIFEST_VERSION,
+      iterationId,
+      baseGitSha,
+      createdAt,
+      changes
+    },
+    issues: []
+  };
+}
+function readChanges(record, iterationId, issues, options) {
+  const value = record.changes;
+  if (!Array.isArray(value)) {
+    issues.push({ path: "$.changes", message: "expected array" });
+    return null;
+  }
+  const changes = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const change = readChange(value[index], `$.changes[${index}]`, iterationId, issues, options);
+    if (change !== null) changes.push(change);
+  }
+  return changes;
+}
+function readChange(value, path, iterationId, issues, options) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: "expected object" });
+    return null;
+  }
+  const id = readRequiredString(value, `${path}.id`, issues);
+  const componentIds = readRequiredStringArray(value, `${path}.componentIds`, issues);
+  const filesChanged = readRequiredStringArray(value, `${path}.filesChanged`, issues);
+  const authorityLevel = readAuthorityLevel(value, `${path}.authorityLevel`, issues);
+  const evidenceRefs = readRequiredStringArray(value, `${path}.evidenceRefs`, issues);
+  const rootCause = readRequiredString(value, `${path}.rootCause`, issues);
+  const targetedFix = readRequiredString(value, `${path}.targetedFix`, issues);
+  const predictedFixes = readRequiredStringArray(value, `${path}.predictedFixes`, issues);
+  const predictedRegressions = readRequiredStringArray(value, `${path}.predictedRegressions`, issues);
+  const validationPlan = readRequiredStringArray(value, `${path}.validationPlan`, issues);
+  const rollbackPlan = readRequiredString(value, `${path}.rollbackPlan`, issues);
+  const expectedBudgetImpact = readExpectedBudgetImpact(value, `${path}.expectedBudgetImpact`, issues);
+  if (componentIds !== null && filesChanged !== null && componentIds.length === 0 && filesChanged.length === 0) {
+    issues.push({ path, message: "requires at least one componentIds or filesChanged entry" });
+  }
+  if (authorityLevel !== null && predictedRegressions !== null && isHighAuthorityLevel(authorityLevel)) {
+    if (predictedRegressions.length === 0) {
+      issues.push({ path: `${path}.predictedRegressions`, message: "high-authority changes require an entry" });
+    }
+  }
+  if (evidenceRefs !== null && evidenceRefs.length === 0) {
+    if (iterationId === null || !allowsEmptyEvidenceRefs(iterationId)) {
+      issues.push({
+        path: `${path}.evidenceRefs`,
+        message: "empty evidence refs are allowed only for exploratory-1"
+      });
+    }
+  }
+  if (evidenceRefs !== null && evidenceRefs.length > 0 && options?.resolveEvidenceRef !== void 0) {
+    checkEvidenceRefs(evidenceRefs, `${path}.evidenceRefs`, options.resolveEvidenceRef, issues);
+  }
+  if (id === null || componentIds === null || filesChanged === null || authorityLevel === null || evidenceRefs === null || rootCause === null || targetedFix === null || predictedFixes === null || predictedRegressions === null || validationPlan === null || rollbackPlan === null) {
+    return null;
+  }
+  const change = {
+    id,
+    componentIds,
+    filesChanged,
+    authorityLevel,
+    evidenceRefs,
+    rootCause,
+    targetedFix,
+    predictedFixes,
+    predictedRegressions,
+    validationPlan,
+    rollbackPlan
+  };
+  if (expectedBudgetImpact !== void 0) change.expectedBudgetImpact = expectedBudgetImpact;
+  return change;
+}
+function checkEvidenceRefs(evidenceRefs, path, resolveEvidenceRef, issues) {
+  for (let index = 0; index < evidenceRefs.length; index += 1) {
+    const ref = evidenceRefs[index];
+    if (ref === void 0) continue;
+    if (!isEvidenceRefFormat(ref)) {
+      issues.push({ path: `${path}[${index}]`, message: "expected a run-<id> or session-<id> bundle id" });
+      continue;
+    }
+    if (!resolveEvidenceRef(ref)) {
+      issues.push({ path: `${path}[${index}]`, message: `evidence bundle not found: ${ref}` });
+    }
+  }
+}
+function isEvidenceRefFormat(ref) {
+  for (const prefix of EVIDENCE_REF_PREFIXES) {
+    if (ref.startsWith(prefix) && ref.length > prefix.length) return true;
+  }
+  return false;
+}
+function readRequiredString(record, path, issues) {
+  const field = path.slice(path.lastIndexOf(".") + 1);
+  const value = record[field];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    issues.push({ path, message: "expected non-empty string" });
+    return null;
+  }
+  return value;
+}
+function readRequiredStringArray(record, path, issues) {
+  const field = path.slice(path.lastIndexOf(".") + 1);
+  const value = record[field];
+  if (!Array.isArray(value)) {
+    issues.push({ path, message: "expected string array" });
+    return null;
+  }
+  const strings = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const item = value[index];
+    if (typeof item !== "string" || item.trim().length === 0) {
+      issues.push({ path: `${path}[${index}]`, message: "expected non-empty string" });
+      continue;
+    }
+    strings.push(item);
+  }
+  return strings;
+}
+function readAuthorityLevel(record, path, issues) {
+  const value = record.authorityLevel;
+  if (typeof value !== "string" || !isManifestAuthorityLevel(value)) {
+    issues.push({ path, message: `expected one of ${MANIFEST_AUTHORITY_LEVELS.join(", ")}` });
+    return null;
+  }
+  return value;
+}
+function readExpectedBudgetImpact(record, path, issues) {
+  if (!Object.hasOwn(record, "expectedBudgetImpact")) return void 0;
+  const value = record.expectedBudgetImpact;
+  if (!isRecord(value)) {
+    issues.push({ path, message: "expected object" });
+    return void 0;
+  }
+  const risk = value.risk;
+  if (typeof risk !== "string" || !isBudgetImpactRisk(risk)) {
+    issues.push({ path: `${path}.risk`, message: `expected one of ${BUDGET_IMPACT_RISKS.join(", ")}` });
+    return void 0;
+  }
+  const impact = { risk };
+  const tokenDelta = readOptionalNumber(value, `${path}.tokenDelta`, issues);
+  const wallTimeDeltaMs = readOptionalNumber(value, `${path}.wallTimeDeltaMs`, issues);
+  if (tokenDelta !== void 0) impact.tokenDelta = tokenDelta;
+  if (wallTimeDeltaMs !== void 0) impact.wallTimeDeltaMs = wallTimeDeltaMs;
+  return impact;
+}
+function readOptionalNumber(record, path, issues) {
+  const field = path.slice(path.lastIndexOf(".") + 1);
+  if (!Object.hasOwn(record, field)) return void 0;
+  const value = record[field];
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    issues.push({ path, message: "expected finite number" });
+    return void 0;
+  }
+  return value;
+}
+function isManifestAuthorityLevel(value) {
+  return MANIFEST_AUTHORITY_LEVELS.includes(value);
+}
+function isBudgetImpactRisk(value) {
+  return BUDGET_IMPACT_RISKS.includes(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function invalid(issues) {
+  return { valid: false, issues };
+}
+
+// src/cli/evolve.ts
+var HELP = `clio-coder evolve manifest init
+clio-coder evolve manifest validate <path>
+clio-coder evolve manifest summarize <path>
+
+Create, validate, or summarize a Clio Coder change manifest. validate and
+summarize resolve each non-empty evidenceRef (run-<id> / session-<id>) against
+the local evidence store, so a manifest that points at a missing bundle fails.
+`;
+async function loadEvidenceRefResolver() {
+  let knownIds;
+  try {
+    const overviews = await listEvidenceOverviews(clioDataDir());
+    knownIds = new Set(overviews.map((overview) => overview.evidenceId));
+  } catch {
+    return { resolveEvidenceRef: () => false, knownCount: 0, resolvable: false };
+  }
+  return {
+    resolveEvidenceRef: (ref) => knownIds.has(ref),
+    knownCount: knownIds.size,
+    resolvable: true
+  };
+}
+function countEvidenceRefs(changes) {
+  let total = 0;
+  for (const change of changes) total += change.evidenceRefs.length;
+  return total;
+}
+function parseEvolveArgs(args) {
+  const parsed = { manifest: false, help: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (!parsed.manifest) {
+      if (arg !== "manifest") throw new Error(`unknown evolve argument: ${arg}`);
+      parsed.manifest = true;
+      continue;
+    }
+    if (parsed.command === void 0) {
+      if (arg === "init" || arg === "validate" || arg === "summarize") {
+        parsed.command = arg;
+        continue;
+      }
+      throw new Error(`unknown evolve manifest command: ${arg}`);
+    }
+    if (parsed.path === void 0 && (parsed.command === "validate" || parsed.command === "summarize")) {
+      if (arg.startsWith("-")) throw new Error(`${parsed.command} requires a path`);
+      parsed.path = arg;
+      continue;
+    }
+    throw new Error(`unexpected evolve argument: ${arg}`);
+  }
+  if (parsed.help) return parsed;
+  if (!parsed.manifest) throw new Error("evolve requires manifest");
+  if (parsed.command === void 0) throw new Error("manifest requires init, validate, or summarize");
+  if (parsed.command === "init" && parsed.path !== void 0) throw new Error("init does not accept a path");
+  if ((parsed.command === "validate" || parsed.command === "summarize") && parsed.path === void 0) {
+    throw new Error(`${parsed.command} requires a path`);
+  }
+  return parsed;
+}
+async function runEvolveCommand(args) {
+  let parsed;
+  try {
+    parsed = parseEvolveArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (parsed.command === "init") {
+    process.stdout.write(`${JSON.stringify(createChangeManifestTemplate(), null, 2)}
+`);
+    return 0;
+  }
+  if (parsed.command === "validate") return runValidate(parsed);
+  if (parsed.command === "summarize") return runSummarize(parsed);
+  printError("manifest requires init, validate, or summarize");
+  return 2;
+}
+async function runValidate(parsed) {
+  const manifestPath = parsed.path;
+  if (manifestPath === void 0) {
+    printError("validate requires a path");
+    return 2;
+  }
+  let value;
+  const resolvedPath = resolve(manifestPath);
+  try {
+    value = await loadChangeManifestJson(resolvedPath);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  const resolver = await loadEvidenceRefResolver();
+  const result = validateChangeManifest(value, { resolveEvidenceRef: resolver.resolveEvidenceRef });
+  if (!result.valid) {
+    renderInvalid(result.issues);
+    return 1;
+  }
+  const refCount = countEvidenceRefs(result.manifest.changes);
+  printOk(`manifest valid (${formatCount(result.manifest.changes.length, "change")})`);
+  reportRefResolution(refCount, resolver);
+  return 0;
+}
+async function runSummarize(parsed) {
+  const manifestPath = parsed.path;
+  if (manifestPath === void 0) {
+    printError("summarize requires a path");
+    return 2;
+  }
+  let value;
+  const resolvedPath = resolve(manifestPath);
+  try {
+    value = await loadChangeManifestJson(resolvedPath);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  const resolver = await loadEvidenceRefResolver();
+  const result = validateChangeManifest(value, { resolveEvidenceRef: resolver.resolveEvidenceRef });
+  if (!result.valid) {
+    printError("manifest invalid; cannot summarize");
+    renderIssues(result.issues);
+    return 1;
+  }
+  const refCount = countEvidenceRefs(result.manifest.changes);
+  renderSummary(summarizeChangeManifest(result.manifest));
+  reportRefResolution(refCount, resolver);
+  return 0;
+}
+function reportRefResolution(refCount, resolver) {
+  if (!resolver.resolvable) {
+    process.stdout.write("evidence refs: could not read the local evidence store; refs were not resolved\n");
+    return;
+  }
+  if (refCount === 0) {
+    process.stdout.write("evidence refs: none to resolve\n");
+    return;
+  }
+  process.stdout.write(
+    `evidence refs: ${formatCount(refCount, "ref")} resolved against ${formatCount(resolver.knownCount, "local bundle")}
+`
+  );
+}
+function renderInvalid(issues) {
+  printError(`manifest invalid (${formatCount(issues.length, "issue", "issues")})`);
+  renderIssues(issues);
+}
+function renderIssues(issues) {
+  for (const issue of issues) process.stderr.write(`  ${issue.path}: ${issue.message}
+`);
+}
+function renderSummary(summary) {
+  process.stdout.write(`iteration: ${summary.iterationId}
+`);
+  process.stdout.write(`base sha: ${summary.baseGitSha}
+`);
+  process.stdout.write(`changes: ${summary.changeCount}
+`);
+  process.stdout.write(`authority levels: ${formatList(summary.authorityLevels)}
+`);
+  process.stdout.write(`components: ${formatList(summary.componentIds)}
+`);
+  process.stdout.write(`files changed: ${formatList(summary.filesChanged)}
+`);
+  process.stdout.write(`predicted regressions: ${formatList(summary.predictedRegressions)}
+`);
+  process.stdout.write(`validation steps: ${summary.validationPlanCount}
+`);
+}
+function formatList(values) {
+  return values.length === 0 ? "none" : values.join(", ");
+}
+function formatCount(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+export {
+  runEvolveCommand
+};
+//# sourceMappingURL=evolve-YDZSUQYA.js.map