@iowarp/clio-coder 0.3.0

package/dist/components-JVHMUBEB.js

@@ -0,0 +1,653 @@
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import {
+  resolvePackageRoot
+} from "./chunk-DXQNI4PC.js";
+
+// src/cli/components.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve as resolve2 } from "node:path";
+
+// src/domains/components/diff.ts
+var COMPONENT_FIELDS = [
+  "id",
+  "kind",
+  "path",
+  "ownerDomain",
+  "mutable",
+  "authority",
+  "reloadClass",
+  "contentHash",
+  "description"
+];
+function diffComponentSnapshots(from, to) {
+  const fromById = indexComponents(from.components, "from");
+  const toById = indexComponents(to.components, "to");
+  const added = [];
+  const removed = [];
+  const changed = [];
+  let unchanged = 0;
+  for (const before of from.components) {
+    const after = toById.get(before.id);
+    if (!after) {
+      removed.push(before);
+      continue;
+    }
+    const changedFields = changedComponentFields(before, after);
+    if (changedFields.length === 0) {
+      unchanged += 1;
+      continue;
+    }
+    changed.push({ id: before.id, before, after, changedFields });
+  }
+  for (const after of to.components) {
+    if (!fromById.has(after.id)) added.push(after);
+  }
+  return {
+    version: 1,
+    from: {
+      root: from.root,
+      generatedAt: from.generatedAt,
+      componentCount: from.components.length
+    },
+    to: {
+      root: to.root,
+      generatedAt: to.generatedAt,
+      componentCount: to.components.length
+    },
+    summary: {
+      added: added.length,
+      removed: removed.length,
+      changed: changed.length,
+      unchanged
+    },
+    added: sortComponents(added),
+    removed: sortComponents(removed),
+    changed: changed.sort((a, b) => a.id.localeCompare(b.id))
+  };
+}
+function indexComponents(components, label) {
+  const map = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    if (map.has(component.id)) {
+      throw new Error(`component diff ${label} snapshot has duplicate id: ${component.id}`);
+    }
+    map.set(component.id, component);
+  }
+  return map;
+}
+function changedComponentFields(before, after) {
+  const changed = [];
+  for (const field of COMPONENT_FIELDS) {
+    if (before[field] !== after[field]) changed.push(field);
+  }
+  return changed;
+}
+function sortComponents(components) {
+  return [...components].sort((a, b) => {
+    const idOrder = a.id.localeCompare(b.id);
+    if (idOrder !== 0) return idOrder;
+    return a.path.localeCompare(b.path);
+  });
+}
+
+// src/domains/components/scan.ts
+import { readdir, readFile, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+
+// src/domains/components/hash.ts
+import { createHash } from "node:crypto";
+function sha256Hex(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function stableJson(value) {
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map((item) => stableJson(item)).join(",")}]`;
+  if (isRecord(value)) {
+    const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
+  }
+  return JSON.stringify(null);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/domains/components/scan.ts
+var KIND_ORDER = [
+  "prompt-fragment",
+  "agent-recipe",
+  "tool-implementation",
+  "tool-helper",
+  "runtime-descriptor",
+  "safety-rule-pack",
+  "config-schema",
+  "session-schema",
+  "receipt-schema",
+  "context-file",
+  "doc-spec",
+  "middleware",
+  "memory",
+  "eval-suite"
+];
+var AUTHORITY_BY_KIND = {
+  "prompt-fragment": "advisory",
+  "context-file": "advisory",
+  "tool-implementation": "enforcing",
+  "tool-helper": "enforcing",
+  middleware: "enforcing",
+  "agent-recipe": "advisory",
+  "runtime-descriptor": "runtime-critical",
+  "safety-rule-pack": "enforcing",
+  "config-schema": "runtime-critical",
+  "session-schema": "runtime-critical",
+  "receipt-schema": "runtime-critical",
+  memory: "advisory",
+  "eval-suite": "descriptive",
+  "doc-spec": "descriptive"
+};
+var RELOAD_BY_KIND = {
+  "prompt-fragment": "hot",
+  "context-file": "hot",
+  "tool-implementation": "hot",
+  "tool-helper": "restart-required",
+  middleware: "restart-required",
+  "agent-recipe": "next-dispatch",
+  "runtime-descriptor": "restart-required",
+  "safety-rule-pack": "restart-required",
+  "config-schema": "restart-required",
+  "session-schema": "restart-required",
+  "receipt-schema": "restart-required",
+  memory: "hot",
+  "eval-suite": "static",
+  "doc-spec": "static"
+};
+var OWNER_BY_KIND = {
+  "prompt-fragment": "prompts",
+  "context-file": "repository",
+  "tool-implementation": "tools",
+  "tool-helper": "tools",
+  middleware: "middleware",
+  "agent-recipe": "agents",
+  "runtime-descriptor": "providers",
+  "safety-rule-pack": "safety",
+  "config-schema": "config",
+  "session-schema": "session",
+  "receipt-schema": "dispatch",
+  memory: "memory",
+  "eval-suite": "eval",
+  "doc-spec": "docs"
+};
+var TOOL_HELPER_FILES = /* @__PURE__ */ new Set(["src/tools/bootstrap.ts", "src/tools/registry.ts", "src/tools/truncate-utf8.ts"]);
+var CONFIG_SCHEMA_FILES = [
+  "src/core/defaults.ts",
+  "src/core/config.ts",
+  "src/domains/config/schema.ts"
+];
+var SESSION_SCHEMA_FILES = [
+  "src/domains/session/entries.ts",
+  "src/domains/session/contract.ts",
+  "src/engine/session.ts"
+];
+var RECEIPT_SCHEMA_FILES = [
+  "src/domains/dispatch/types.ts",
+  "src/domains/dispatch/receipt-integrity.ts"
+];
+var CONTEXT_FILES = ["CLIO-CODER.md", "CONTRIBUTING.md", "SECURITY.md"];
+async function scanComponents(root) {
+  const absoluteRoot = resolve(root);
+  const components = [];
+  components.push(...await collectRecursive(absoluteRoot, "src/domains/prompts/fragments", ".md", "prompt-fragment"));
+  components.push(...await collectRecursive(absoluteRoot, "src/domains/agents/builtins", ".md", "agent-recipe"));
+  components.push(...await collectTools(absoluteRoot));
+  components.push(
+    ...await collectRecursive(absoluteRoot, "src/domains/providers/runtimes", ".ts", "runtime-descriptor")
+  );
+  components.push(...await collectSafetyRulePacks(absoluteRoot));
+  components.push(...await collectKnownFiles(absoluteRoot, CONFIG_SCHEMA_FILES, "config-schema"));
+  components.push(...await collectKnownFiles(absoluteRoot, SESSION_SCHEMA_FILES, "session-schema"));
+  components.push(...await collectKnownFiles(absoluteRoot, RECEIPT_SCHEMA_FILES, "receipt-schema"));
+  components.push(...await collectKnownFiles(absoluteRoot, CONTEXT_FILES, "context-file"));
+  components.push(...await collectRecursive(absoluteRoot, "docs/specs", ".md", "doc-spec"));
+  return sortComponents2(components);
+}
+async function createComponentSnapshot(options) {
+  const root = resolve(options.root);
+  const generatedAt = (options.generatedAt ?? /* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    generatedAt,
+    root,
+    components: await scanComponents(root)
+  };
+}
+async function collectRecursive(root, dirPath, extension, kind) {
+  const files = await listFiles(join(root, dirPath));
+  const matching = files.map((filePath) => toRepoPath(root, filePath)).filter((repoPath) => repoPath.endsWith(extension)).sort((a, b) => a.localeCompare(b));
+  return collectKnownFiles(root, matching, kind);
+}
+async function collectTools(root) {
+  const files = await listFiles(join(root, "src/tools"));
+  const repoPaths = files.map((filePath) => toRepoPath(root, filePath)).filter((repoPath) => repoPath.startsWith("src/tools/") && repoPath.endsWith(".ts")).sort((a, b) => a.localeCompare(b));
+  const components = [];
+  for (const repoPath of repoPaths) {
+    const kind = TOOL_HELPER_FILES.has(repoPath) ? "tool-helper" : "tool-implementation";
+    const component = await componentFromFile(root, repoPath, kind);
+    if (component) components.push(component);
+  }
+  return components;
+}
+async function collectKnownFiles(root, paths, kind) {
+  const components = [];
+  for (const repoPath of [...paths].sort((a, b) => a.localeCompare(b))) {
+    const component = await componentFromFile(root, repoPath, kind);
+    if (component) components.push(component);
+  }
+  return components;
+}
+async function componentFromFile(root, repoPath, kind) {
+  const absolutePath = join(root, repoPath);
+  if (!await isFile(absolutePath)) return null;
+  const content = await readFile(absolutePath);
+  return baseComponent({
+    id: `${kind}:${repoPath}`,
+    kind,
+    path: repoPath,
+    contentHash: sha256Hex(content)
+  });
+}
+async function collectSafetyRulePacks(root) {
+  const repoPath = "damage-control-rules.yaml";
+  const absolutePath = join(root, repoPath);
+  if (!await isFile(absolutePath)) return [];
+  const content = await readFile(absolutePath, "utf8");
+  const packs = parseSafetyPacks(content);
+  return packs.map(
+    (pack) => baseComponent({
+      id: `safety-rule-pack:${pack.id}`,
+      kind: "safety-rule-pack",
+      path: repoPath,
+      contentHash: sha256Hex(stableJson(pack.value)),
+      description: `damage-control rule pack: ${pack.id}`
+    })
+  ).sort((a, b) => a.id.localeCompare(b.id));
+}
+function parseSafetyPacks(content) {
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch {
+    return [];
+  }
+  if (!isRecord2(parsed)) return [];
+  const version = parsed.version;
+  if (version === 1) {
+    return [{ id: "base", value: { version, rules: parsed.rules ?? [] } }];
+  }
+  if (version !== 2 || !Array.isArray(parsed.packs)) return [];
+  const packs = [];
+  for (const pack of parsed.packs) {
+    if (!isRecord2(pack) || typeof pack.id !== "string" || pack.id.length === 0) continue;
+    packs.push({ id: pack.id, value: pack });
+  }
+  return packs.sort((a, b) => a.id.localeCompare(b.id));
+}
+function baseComponent(input) {
+  const component = {
+    id: input.id,
+    kind: input.kind,
+    path: input.path,
+    ownerDomain: OWNER_BY_KIND[input.kind],
+    mutable: true,
+    authority: AUTHORITY_BY_KIND[input.kind],
+    reloadClass: RELOAD_BY_KIND[input.kind],
+    contentHash: input.contentHash
+  };
+  if (input.description !== void 0) component.description = input.description;
+  return component;
+}
+async function listFiles(dirPath) {
+  let entries;
+  try {
+    entries = await readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of [...entries].sort((a, b) => a.name.localeCompare(b.name))) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles(fullPath));
+      continue;
+    }
+    if (entry.isFile()) files.push(fullPath);
+  }
+  return files;
+}
+async function isFile(path) {
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+function toRepoPath(root, filePath) {
+  const rel = relative(root, filePath);
+  const normalized = rel.split(sep).join("/");
+  return isAbsolute(normalized) ? normalized : normalized;
+}
+function sortComponents2(components) {
+  const kindRank = new Map(KIND_ORDER.map((kind, index) => [kind, index]));
+  return [...components].sort((a, b) => {
+    const rankA = kindRank.get(a.kind) ?? KIND_ORDER.length;
+    const rankB = kindRank.get(b.kind) ?? KIND_ORDER.length;
+    if (rankA !== rankB) return rankA - rankB;
+    const pathOrder = a.path.localeCompare(b.path);
+    if (pathOrder !== 0) return pathOrder;
+    return a.id.localeCompare(b.id);
+  });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/domains/components/snapshot.ts
+import { readFile as readFile2 } from "node:fs/promises";
+
+// src/domains/components/types.ts
+var COMPONENT_KINDS = [
+  "prompt-fragment",
+  "context-file",
+  "tool-implementation",
+  "tool-helper",
+  "middleware",
+  "agent-recipe",
+  "runtime-descriptor",
+  "safety-rule-pack",
+  "config-schema",
+  "session-schema",
+  "receipt-schema",
+  "memory",
+  "eval-suite",
+  "doc-spec"
+];
+var COMPONENT_AUTHORITIES = ["advisory", "descriptive", "enforcing", "runtime-critical"];
+var COMPONENT_RELOAD_CLASSES = ["hot", "next-dispatch", "restart-required", "static"];
+
+// src/domains/components/snapshot.ts
+async function loadComponentSnapshot(path) {
+  let raw;
+  try {
+    raw = await readFile2(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") throw new Error(`component snapshot not found: ${path}`);
+    throw error;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${path}: invalid JSON: ${message}`);
+  }
+  return parseComponentSnapshot(parsed, path);
+}
+function parseComponentSnapshot(value, source = "snapshot") {
+  if (!isRecord3(value)) throw new Error(`${source}: expected object`);
+  if (value.version !== 1) throw new Error(`${source}: expected version 1`);
+  if (typeof value.generatedAt !== "string" || value.generatedAt.length === 0) {
+    throw new Error(`${source}: expected generatedAt string`);
+  }
+  if (typeof value.root !== "string" || value.root.length === 0) {
+    throw new Error(`${source}: expected root string`);
+  }
+  if (!Array.isArray(value.components)) throw new Error(`${source}: expected components array`);
+  return {
+    version: 1,
+    generatedAt: value.generatedAt,
+    root: value.root,
+    components: value.components.map(
+      (component, index) => parseHarnessComponent(component, `${source}:components[${index}]`)
+    )
+  };
+}
+function parseHarnessComponent(value, source) {
+  if (!isRecord3(value)) throw new Error(`${source}: expected object`);
+  const id = readString(value, source, "id");
+  const kind = readEnum(value, source, "kind", COMPONENT_KINDS);
+  const path = readString(value, source, "path");
+  const ownerDomain = readString(value, source, "ownerDomain");
+  const mutable = readBoolean(value, source, "mutable");
+  const authority = readEnum(value, source, "authority", COMPONENT_AUTHORITIES);
+  const reloadClass = readEnum(value, source, "reloadClass", COMPONENT_RELOAD_CLASSES);
+  const contentHash = readString(value, source, "contentHash");
+  if (!/^[a-f0-9]{64}$/.test(contentHash)) throw new Error(`${source}: expected contentHash sha256 hex`);
+  const component = {
+    id,
+    kind,
+    path,
+    ownerDomain,
+    mutable,
+    authority,
+    reloadClass,
+    contentHash
+  };
+  if (Object.hasOwn(value, "description")) {
+    if (typeof value.description !== "string") throw new Error(`${source}: expected description string`);
+    component.description = value.description;
+  }
+  return component;
+}
+function readString(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${source}: expected ${field} string`);
+  return value;
+}
+function readBoolean(record, source, field) {
+  const value = record[field];
+  if (typeof value !== "boolean") throw new Error(`${source}: expected ${field} boolean`);
+  return value;
+}
+function readEnum(record, source, field, values) {
+  const value = record[field];
+  if (typeof value !== "string" || !values.includes(value)) {
+    throw new Error(`${source}: expected ${field} to be one of ${values.join(", ")}`);
+  }
+  return value;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/cli/components.ts
+var HELP = `clio-coder components [list] [--json]
+clio-coder components snapshot --out <path>
+clio-coder components diff --from <snapshot-a.json> --to <snapshot-b.json> [--json]
+
+List read-only Clio Coder harness components, write a snapshot, or diff two snapshots. The bare \`clio-coder components\` form and \`clio-coder components list\` are equivalent.
+`;
+function parseComponentsArgs(args) {
+  const parsed = { command: "list", json: false, help: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--json") {
+      parsed.json = true;
+      continue;
+    }
+    if (arg === "list") {
+      parsed.command = "list";
+      continue;
+    }
+    if (arg === "snapshot") {
+      parsed.command = "snapshot";
+      continue;
+    }
+    if (arg === "diff") {
+      parsed.command = "diff";
+      continue;
+    }
+    if (arg === "--out") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) throw new Error("--out requires a path");
+      parsed.out = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--from") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) throw new Error("--from requires a path");
+      parsed.from = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--to") {
+      const value = args[i + 1];
+      if (!value || value.startsWith("-")) throw new Error("--to requires a path");
+      parsed.to = value;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    throw new Error(`unknown components argument: ${arg}`);
+  }
+  if (parsed.command !== "snapshot" && parsed.out !== void 0) throw new Error("--out is only valid with snapshot");
+  if (parsed.command !== "diff" && parsed.from !== void 0) throw new Error("--from is only valid with diff");
+  if (parsed.command !== "diff" && parsed.to !== void 0) throw new Error("--to is only valid with diff");
+  if (parsed.command === "snapshot" && parsed.json) throw new Error("--json is only valid with list");
+  if (parsed.command === "snapshot" && parsed.out === void 0) throw new Error("snapshot requires --out <path>");
+  if (parsed.command === "diff" && (parsed.from === void 0 || parsed.to === void 0)) {
+    throw new Error("diff requires --from <path> and --to <path>");
+  }
+  return parsed;
+}
+async function runComponentsCommand(args) {
+  let parsed;
+  try {
+    parsed = parseComponentsArgs(args);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (parsed.command === "diff") return runDiff(parsed);
+  const snapshot = await createComponentSnapshot({ root: resolvePackageRoot() });
+  if (parsed.command === "snapshot") {
+    const out = parsed.out;
+    if (out === void 0) {
+      printError("snapshot requires --out <path>");
+      return 2;
+    }
+    const outPath = resolve2(out);
+    await mkdir(dirname(outPath), { recursive: true });
+    await writeFile(outPath, `${formatSnapshotJson(snapshot)}
+`, "utf8");
+    printOk(`wrote ${outPath}`);
+    return 0;
+  }
+  if (parsed.json) {
+    process.stdout.write(`${formatSnapshotJson(snapshot)}
+`);
+    return 0;
+  }
+  renderComponents(snapshot.components);
+  return 0;
+}
+async function runDiff(parsed) {
+  const fromPath = parsed.from;
+  const toPath = parsed.to;
+  if (fromPath === void 0 || toPath === void 0) {
+    printError("diff requires --from <path> and --to <path>");
+    return 2;
+  }
+  let diff;
+  try {
+    const from = await loadComponentSnapshot(resolve2(fromPath));
+    const to = await loadComponentSnapshot(resolve2(toPath));
+    diff = diffComponentSnapshots(from, to);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (parsed.json) {
+    process.stdout.write(`${JSON.stringify(diff, null, 2)}
+`);
+  } else {
+    renderComponentDiff(diff);
+  }
+  return 0;
+}
+function formatSnapshotJson(snapshot) {
+  return JSON.stringify(snapshot, null, 2);
+}
+function renderComponents(components) {
+  process.stdout.write(`${components.length} components
+
+`);
+  for (const component of components) {
+    const description = component.description ? ` ${component.description}` : "";
+    const line = [
+      component.kind.padEnd(21),
+      component.authority.padEnd(17),
+      component.reloadClass.padEnd(18),
+      component.path
+    ].join("");
+    process.stdout.write(`${line}${description}
+`);
+  }
+}
+function renderComponentDiff(diff) {
+  const { summary } = diff;
+  process.stdout.write(
+    [
+      `${summary.added} added`,
+      `${summary.removed} removed`,
+      `${summary.changed} changed`,
+      `${summary.unchanged} unchanged`
+    ].join(", ")
+  );
+  process.stdout.write("\n\n");
+  if (summary.added + summary.removed + summary.changed === 0) {
+    process.stdout.write("no component changes\n");
+    return;
+  }
+  for (const component of diff.added) process.stdout.write(`${formatDiffLine("+", component)}
+`);
+  for (const component of diff.removed) process.stdout.write(`${formatDiffLine("-", component)}
+`);
+  for (const change of diff.changed) {
+    process.stdout.write(`${formatDiffLine("~", change.after)} [${change.changedFields.join(",")}]
+`);
+  }
+}
+function formatDiffLine(marker, component) {
+  return [
+    marker,
+    " ",
+    component.kind.padEnd(21),
+    component.authority.padEnd(17),
+    component.reloadClass.padEnd(18),
+    component.path
+  ].join("");
+}
+export {
+  runComponentsCommand
+};
+//# sourceMappingURL=components-JVHMUBEB.js.map