@iowarp/clio-coder 0.3.3 → 0.3.6

package/dist/memory-7YKKR6UC.js

@@ -0,0 +1,467 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  approveMemoryRecord,
+  canonicalMemoryRepositoryIdentity,
+  loadMemoryRecords,
+  memoryAgentIdentity,
+  memoryRuntimeIdentity,
+  memoryStatus,
+  parseTaskMemoryHandoffSnapshot,
+  proposeMemoryFromEvidence,
+  proposeMemoryPromotion,
+  pruneStaleMemory,
+  rejectMemoryRecord
+} from "./chunk-6US73PDB.js";
+import "./chunk-QM3F2GKX.js";
+import "./chunk-CJUB2JJ2.js";
+import "./chunk-QKMUKYO7.js";
+import "./chunk-OH3TOQTB.js";
+import "./chunk-TSHXZTOQ.js";
+import "./chunk-TXOTCRLG.js";
+import "./chunk-HVDIIIQW.js";
+import "./chunk-W6GROXXM.js";
+import "./chunk-WHGPSPT5.js";
+import "./chunk-XXQNGV4M.js";
+import "./chunk-43AOLP7E.js";
+import "./chunk-EKY57CSP.js";
+import "./chunk-22NAGB7X.js";
+import "./chunk-AOCYTWAV.js";
+import "./chunk-MV3K5QF2.js";
+import "./chunk-CMZWFGD2.js";
+import "./chunk-I4HZDVNP.js";
+import "./chunk-FYYLNIL5.js";
+import "./chunk-UL3WSD3F.js";
+import "./chunk-OQE5J4C6.js";
+import "./chunk-ECH6PKUQ.js";
+import "./chunk-GOXNB3AO.js";
+import "./chunk-HWUFFB6L.js";
+import "./chunk-ODFEOB4F.js";
+import "./chunk-OZNBF4L3.js";
+import "./chunk-4BJ5BYCE.js";
+import "./chunk-6XLNIQDB.js";
+import "./chunk-5B2AEOW5.js";
+import "./chunk-CGKSTWHD.js";
+import "./chunk-XAKHZX5N.js";
+import "./chunk-33YXPOE3.js";
+import "./chunk-24I7BN55.js";
+import {
+  printError,
+  printOk
+} from "./chunk-PPAMZ32Z.js";
+import "./chunk-5TSRNF4G.js";
+import "./chunk-DJVECN66.js";
+import "./chunk-CFGTUFWB.js";
+import "./chunk-AD2SYQYC.js";
+import "./chunk-4OC57DA6.js";
+import "./chunk-LL4KHSZI.js";
+import "./chunk-4VP4KH3K.js";
+import "./chunk-VEZEGCGW.js";
+import "./chunk-FQ4SKYE4.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-GEYXPTRF.js";
+import "./chunk-SST6Z5JA.js";
+import "./chunk-FO5ZOVUY.js";
+import "./chunk-R346GLFC.js";
+import "./chunk-4ZG3XFUR.js";
+import "./chunk-FCSXB6T2.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-YXLYO42X.js";
+import {
+  clioDataDir
+} from "./chunk-BNAZZHFG.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-ZGVHUX3M.js";
+import "./chunk-G7MUEIGA.js";
+import "./chunk-7CR24IG7.js";
+import "./chunk-IWHMRKLL.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/memory.ts
+init_esm_shims();
+import { readFile, stat } from "node:fs/promises";
+var HELP = `clio-coder memory list
+clio-coder memory propose --from-evidence <evidenceId> [scope options]
+clio-coder memory promote --from-handoff <path> [--entry <id>...] --scope <scope> [scope options]
+clio-coder memory approve <memoryId>
+clio-coder memory reject <memoryId>
+clio-coder memory prune --stale
+
+Manage scoped, approved, evidence-linked local memory records.
+
+Scope options:
+  --scope repo --repository <canonical-absolute-path>
+  --scope global --acknowledge-global
+  --scope runtime --runtime <source-runtime-id>
+  --scope agent --agent <source-agent-id>
+
+Omit scope options from propose to preserve evidence-inferred scope. Promotion
+always requires an explicit scope and creates unapproved records for review.
+`;
+function parseMemoryArgs(args) {
+  const parsed = { entryIds: [], acknowledgeGlobal: false, stale: 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.command === void 0) {
+      if (arg === "list" || arg === "propose" || arg === "promote" || arg === "approve" || arg === "reject" || arg === "prune") {
+        parsed.command = arg;
+        continue;
+      }
+      throw new Error(`unknown memory command: ${arg}`);
+    }
+    if (parsed.command === "propose" || parsed.command === "promote") {
+      if (arg === "--from-evidence") {
+        if (parsed.command !== "propose") throw new Error("--from-evidence is valid only for memory propose");
+        const value = args[index + 1];
+        if (value === void 0 || value.startsWith("-")) throw new Error("--from-evidence requires an evidence id");
+        parsed.evidenceId = value;
+        index += 1;
+        continue;
+      }
+      if (arg === "--from-handoff") {
+        if (parsed.command !== "promote") throw new Error("--from-handoff is valid only for memory promote");
+        const value = requireOptionValue(args, index, "--from-handoff", "a path");
+        parsed.handoffPath = value;
+        index += 1;
+        continue;
+      }
+      if (arg === "--entry") {
+        if (parsed.command !== "promote") throw new Error("--entry is valid only for memory promote");
+        parsed.entryIds.push(requireOptionValue(args, index, "--entry", "an entry id"));
+        index += 1;
+        continue;
+      }
+      if (arg === "--scope") {
+        const value = requireOptionValue(args, index, "--scope", "repo, global, runtime, or agent");
+        if (value !== "repo" && value !== "global" && value !== "runtime" && value !== "agent") {
+          throw new Error("--scope requires repo, global, runtime, or agent");
+        }
+        parsed.scope = value;
+        index += 1;
+        continue;
+      }
+      if (arg === "--repository") {
+        parsed.repositoryPath = requireOptionValue(args, index, "--repository", "a canonical absolute path");
+        index += 1;
+        continue;
+      }
+      if (arg === "--acknowledge-global") {
+        parsed.acknowledgeGlobal = true;
+        continue;
+      }
+      if (arg === "--runtime") {
+        parsed.runtimeId = requireOptionValue(args, index, "--runtime", "a runtime id");
+        index += 1;
+        continue;
+      }
+      if (arg === "--agent") {
+        parsed.agentId = requireOptionValue(args, index, "--agent", "an agent id");
+        index += 1;
+        continue;
+      }
+      throw new Error(`unknown memory ${parsed.command} argument: ${arg}`);
+    }
+    if (parsed.command === "approve" || parsed.command === "reject") {
+      if (parsed.memoryId === void 0 && !arg.startsWith("-")) {
+        parsed.memoryId = arg;
+        continue;
+      }
+      throw new Error(`unexpected memory ${parsed.command} argument: ${arg}`);
+    }
+    if (parsed.command === "prune") {
+      if (arg === "--stale") {
+        parsed.stale = true;
+        continue;
+      }
+      throw new Error(`unknown memory prune argument: ${arg}`);
+    }
+    throw new Error(`unexpected memory argument: ${arg}`);
+  }
+  if (parsed.help) return parsed;
+  if (parsed.command === void 0) throw new Error("memory requires list, propose, promote, approve, reject, or prune");
+  if (parsed.command === "propose" && parsed.evidenceId === void 0) {
+    throw new Error("propose requires --from-evidence <evidenceId>");
+  }
+  if (parsed.command === "promote" && parsed.handoffPath === void 0) {
+    throw new Error("promote requires --from-handoff <path>");
+  }
+  if ((parsed.command === "approve" || parsed.command === "reject") && parsed.memoryId === void 0) {
+    throw new Error(`${parsed.command} requires a memory id`);
+  }
+  if (parsed.command === "prune" && !parsed.stale) throw new Error("prune requires --stale");
+  if (parsed.command === "promote" && parsed.scope === void 0) {
+    throw new Error("promote requires --scope <repo|global|runtime|agent>");
+  }
+  validateScopeArguments(parsed);
+  if (parsed.command === "list" && (parsed.evidenceId !== void 0 || parsed.handoffPath !== void 0 || parsed.entryIds.length > 0 || parsed.memoryId !== void 0 || parsed.stale || parsed.scope !== void 0)) {
+    throw new Error("list does not accept extra arguments");
+  }
+  return parsed;
+}
+function requireOptionValue(args, index, option, expected) {
+  const value = args[index + 1];
+  if (value === void 0 || value.startsWith("-")) throw new Error(`${option} requires ${expected}`);
+  return value;
+}
+function validateScopeArguments(parsed) {
+  const hasIdentityOption = parsed.repositoryPath !== void 0 || parsed.acknowledgeGlobal || parsed.runtimeId !== void 0 || parsed.agentId !== void 0;
+  if (parsed.scope === void 0) {
+    if (hasIdentityOption) throw new Error("scope identity options require --scope");
+    return;
+  }
+  if (parsed.scope === "repo") {
+    if (parsed.repositoryPath === void 0)
+      throw new Error("repo scope requires --repository <canonical-absolute-path>");
+    if (parsed.acknowledgeGlobal || parsed.runtimeId !== void 0 || parsed.agentId !== void 0) {
+      throw new Error("repo scope accepts only --repository");
+    }
+    return;
+  }
+  if (parsed.scope === "global") {
+    if (!parsed.acknowledgeGlobal) throw new Error("global scope requires --acknowledge-global");
+    if (parsed.repositoryPath !== void 0 || parsed.runtimeId !== void 0 || parsed.agentId !== void 0) {
+      throw new Error("global scope accepts only --acknowledge-global");
+    }
+    return;
+  }
+  if (parsed.scope === "runtime") {
+    if (parsed.runtimeId === void 0) throw new Error("runtime scope requires --runtime <source-runtime-id>");
+    if (parsed.repositoryPath !== void 0 || parsed.acknowledgeGlobal || parsed.agentId !== void 0) {
+      throw new Error("runtime scope accepts only --runtime");
+    }
+    return;
+  }
+  if (parsed.agentId === void 0) throw new Error("agent scope requires --agent <source-agent-id>");
+  if (parsed.repositoryPath !== void 0 || parsed.acknowledgeGlobal || parsed.runtimeId !== void 0) {
+    throw new Error("agent scope accepts only --agent");
+  }
+}
+async function runMemoryCommand(args) {
+  let parsed;
+  try {
+    parsed = parseMemoryArgs(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;
+  }
+  const dataDir = clioDataDir();
+  try {
+    if (parsed.command === "list") {
+      renderMemoryList(await loadMemoryRecords(dataDir));
+      return 0;
+    }
+    if (parsed.command === "propose") {
+      const evidenceId = parsed.evidenceId;
+      if (evidenceId === void 0) {
+        printError("propose requires --from-evidence <evidenceId>");
+        return 2;
+      }
+      const result = await proposeMemoryFromEvidence(dataDir, evidenceId, scopeSelection(parsed));
+      renderProposal(result.record, result.created);
+      return 0;
+    }
+    if (parsed.command === "promote") {
+      const handoffPath = parsed.handoffPath;
+      const selection = scopeSelection(parsed);
+      if (handoffPath === void 0 || selection === void 0) {
+        printError("promote requires a handoff and explicit scope");
+        return 2;
+      }
+      const snapshot = await readReviewedHandoff(handoffPath);
+      const entries = selectHandoffEntries(snapshot, parsed.entryIds);
+      for (const entry of entries) {
+        const result = await proposeMemoryPromotion(
+          dataDir,
+          {
+            kind: "handoff-snapshot",
+            sessionId: snapshot.source.sessionId,
+            evidenceRefs: snapshot.source.evidenceRefs,
+            runtimeIds: snapshot.source.runtimeIds,
+            agentIds: snapshot.source.agentIds,
+            entry: handoffTaskEntry(entry),
+            redaction: {
+              replacementCount: snapshot.redaction.replacementCount,
+              sourceFields: snapshot.redaction.sourceFields
+            }
+          },
+          selection
+        );
+        renderProposal(result.record, result.created);
+      }
+      return 0;
+    }
+    if (parsed.command === "approve") {
+      const memoryId = parsed.memoryId;
+      if (memoryId === void 0) {
+        printError("approve requires a memory id");
+        return 2;
+      }
+      const record = await approveMemoryRecord(dataDir, memoryId);
+      printOk(`approved ${record.id}`);
+      return 0;
+    }
+    if (parsed.command === "reject") {
+      const memoryId = parsed.memoryId;
+      if (memoryId === void 0) {
+        printError("reject requires a memory id");
+        return 2;
+      }
+      const record = await rejectMemoryRecord(dataDir, memoryId);
+      printOk(`rejected ${record.id}`);
+      return 0;
+    }
+    if (parsed.command === "prune") {
+      const pruned = await pruneStaleMemory(dataDir);
+      printOk(`pruned ${pruned.length} stale memory record${pruned.length === 1 ? "" : "s"}`);
+      return 0;
+    }
+    printError("memory requires list, propose, promote, approve, reject, or prune");
+    return 2;
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+function scopeSelection(parsed) {
+  if (parsed.scope === void 0) return void 0;
+  if (parsed.scope === "repo") {
+    const repositoryPath = parsed.repositoryPath;
+    if (repositoryPath === void 0) throw new Error("repo scope requires --repository");
+    const repository = canonicalMemoryRepositoryIdentity(repositoryPath);
+    if (repository === null || repository.key !== repositoryPath) {
+      throw new Error("--repository must be an existing canonical absolute repository path");
+    }
+    return { scope: "repo", repository };
+  }
+  if (parsed.scope === "global") {
+    if (!parsed.acknowledgeGlobal) throw new Error("global scope requires --acknowledge-global");
+    return { scope: "global", acknowledgeGlobal: true };
+  }
+  if (parsed.scope === "runtime") {
+    if (parsed.runtimeId === void 0) throw new Error("runtime scope requires --runtime");
+    return { scope: "runtime", runtime: memoryRuntimeIdentity(parsed.runtimeId) };
+  }
+  if (parsed.agentId === void 0) throw new Error("agent scope requires --agent");
+  return { scope: "agent", agent: memoryAgentIdentity(parsed.agentId) };
+}
+async function readReviewedHandoff(path) {
+  const info = await stat(path);
+  if (!info.isFile()) throw new Error(`task-memory handoff is not a file: ${path}`);
+  if (info.size > 1e6) throw new Error(`task-memory handoff exceeds 1000000 bytes: ${path}`);
+  const snapshot = parseTaskMemoryHandoffSnapshot(await readFile(path, "utf8"));
+  if (snapshot === null) throw new Error(`task-memory handoff is invalid: ${path}`);
+  if (snapshot.version !== 2) {
+    throw new Error("task-memory handoff lacks source session and evidence provenance; create a new redacted handoff");
+  }
+  return snapshot;
+}
+function selectHandoffEntries(snapshot, entryIds) {
+  const entries = [
+    ...snapshot.knowledge.map((entry) => ({ kind: "knowledge", entry })),
+    ...snapshot.procedural.map((entry) => ({ kind: "procedural", entry }))
+  ];
+  if (entries.length === 0) throw new Error("task-memory handoff contains no promotable entries");
+  if (entryIds.length === 0) return entries;
+  const requested = new Set(entryIds);
+  const selected = entries.filter(({ entry }) => requested.has(entry.id));
+  const missing = [...requested].filter((id) => !selected.some(({ entry }) => entry.id === id));
+  if (missing.length > 0) throw new Error(`task-memory handoff entry not found: ${missing.join(", ")}`);
+  return selected;
+}
+function handoffTaskEntry(selected) {
+  const createdAt = selected.entry.createdAt;
+  const lastTouchedAt = selected.entry.lastTouchedAt;
+  if (createdAt === void 0 || lastTouchedAt === void 0) {
+    throw new Error(`task-memory handoff entry lacks timestamps: ${selected.entry.id}`);
+  }
+  return {
+    id: selected.entry.id,
+    kind: selected.kind,
+    content: selected.entry.content,
+    createdAt,
+    lastTouchedAt,
+    injectionCount: selected.entry.injectionCount
+  };
+}
+function renderProposal(record, created) {
+  process.stdout.write(`memory: ${record.id}
+`);
+  process.stdout.write(`status: ${created ? "proposed" : memoryStatus(record)}
+`);
+  process.stdout.write(`scope: ${record.scope}
+`);
+  if (record.repository !== void 0) process.stdout.write(`repository: ${record.repository.key}
+`);
+  if (record.runtime !== void 0) process.stdout.write(`runtime: ${record.runtime.key}
+`);
+  if (record.agent !== void 0) process.stdout.write(`agent: ${record.agent.key}
+`);
+  process.stdout.write(`key: ${record.key}
+`);
+  process.stdout.write(`evidence: ${record.evidenceRefs.join(", ")}
+`);
+  process.stdout.write(`confidence: ${record.confidence.toFixed(2)}
+`);
+  process.stdout.write(`lesson: ${record.lesson}
+`);
+  if (record.provenance !== void 0) {
+    process.stdout.write(`source: ${record.provenance.sourceKind}
+`);
+    if (record.provenance.sourceSessionId !== void 0) {
+      process.stdout.write(`source-session: ${record.provenance.sourceSessionId}
+`);
+    }
+    if (record.provenance.sourceEntryId !== void 0) {
+      process.stdout.write(`source-entry: ${record.provenance.sourceEntryId}
+`);
+    }
+    if (record.provenance.redaction !== void 0) {
+      process.stdout.write(
+        `redaction: ${record.provenance.redaction.replacementCount} replacement${record.provenance.redaction.replacementCount === 1 ? "" : "s"}; fields=${record.provenance.redaction.sourceFields.join(",") || "none"}
+`
+      );
+    }
+  }
+  process.stdout.write(`review: clio-coder memory approve ${record.id}
+`);
+}
+function renderMemoryList(records) {
+  process.stdout.write(`${records.length} memory record${records.length === 1 ? "" : "s"}
+`);
+  if (records.length === 0) return;
+  process.stdout.write("\n");
+  for (const record of records) {
+    process.stdout.write(
+      [
+        record.id.padEnd(21),
+        memoryStatus(record).padEnd(10),
+        record.scope.padEnd(13),
+        `confidence=${record.confidence.toFixed(2)}`.padEnd(16),
+        `evidence=${record.evidenceRefs.join(",")}`
+      ].join("")
+    );
+    process.stdout.write("\n");
+    process.stdout.write(`  key: ${record.key}
+`);
+    process.stdout.write(`  lesson: ${record.lesson}
+`);
+  }
+}
+export {
+  runMemoryCommand
+};
+//# sourceMappingURL=memory-7YKKR6UC.js.map

package/dist/{models-I5QWSEOM.js → models-ZPOLRU2C.js}

@@ -1,24 +1,24 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import "./chunk-5UFT4SUX.js";
+import "./chunk-6XXKFVSN.js";
+import {
+  ensureClioState
+} from "./chunk-KHSFENX2.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-OC7FIQPC.js";
-import {
-  ensureClioState
-} from "./chunk-UFIIWP2H.js";
-import "./chunk-CBCAPZAA.js";
+} from "./chunk-R46L2BIR.js";
+import "./chunk-E25LMLRW.js";
 import "./chunk-4BPJXDWC.js";
 import "./chunk-2SFS6XQE.js";
 import "./chunk-ZWLZP4ZT.js";
 import "./chunk-CGKSTWHD.js";
 import "./chunk-XPLRXC72.js";
-import "./chunk-2TLUCQVG.js";
-import "./chunk-BMEMKKIT.js";
-import "./chunk-YCWGATWI.js";
+import "./chunk-RD5U66HV.js";
+import "./chunk-KOHPCX4K.js";
+import "./chunk-24I7BN55.js";
 import {
   printError
-} from "./chunk-ED4KHGC3.js";
+} from "./chunk-PPAMZ32Z.js";
 import {
   source_default
 } from "./chunk-5TSRNF4G.js";
@@ -26,28 +26,31 @@ import {
   ProvidersDomainModule,
   modelCandidatesForStatus,
   resolveModelCapabilities
-} from "./chunk-LZSJBIVT.js";
-import "./chunk-A3CYT5EX.js";
-import "./chunk-ZDOOVTXZ.js";
+} from "./chunk-DJVECN66.js";
+import "./chunk-CFGTUFWB.js";
+import "./chunk-AD2SYQYC.js";
+import "./chunk-4OC57DA6.js";
+import "./chunk-LL4KHSZI.js";
 import "./chunk-4VP4KH3K.js";
-import "./chunk-M6SHUN7Q.js";
-import "./chunk-R346GLFC.js";
-import "./chunk-VPAYEGVX.js";
-import "./chunk-COU2UHX6.js";
+import "./chunk-VEZEGCGW.js";
 import "./chunk-FQ4SKYE4.js";
 import "./chunk-IKCO5N3L.js";
 import "./chunk-3I7MS7N2.js";
 import "./chunk-IHXBNWMM.js";
+import "./chunk-GEYXPTRF.js";
 import "./chunk-SST6Z5JA.js";
+import "./chunk-FO5ZOVUY.js";
+import "./chunk-R346GLFC.js";
 import "./chunk-4ZG3XFUR.js";
-import "./chunk-APJ265NV.js";
 import "./chunk-FCSXB6T2.js";
+import "./chunk-APJ265NV.js";
 import "./chunk-YXLYO42X.js";
 import "./chunk-BNAZZHFG.js";
 import "./chunk-6EJMN2Y3.js";
 import "./chunk-WEPFGWHJ.js";
-import "./chunk-TZTZS7QK.js";
-import "./chunk-OQ33BKR3.js";
+import "./chunk-XE2VEJHX.js";
+import "./chunk-ZGVHUX3M.js";
+import "./chunk-G7MUEIGA.js";
 import "./chunk-IWHMRKLL.js";
 import {
   init_esm_shims
@@ -259,4 +262,4 @@ export {
   modelTableLines,
   runModelsCommand
 };
-//# sourceMappingURL=models-I5QWSEOM.js.map
+//# sourceMappingURL=models-ZPOLRU2C.js.map