@iowarp/clio-coder 0.4.4 → 0.4.5

package/dist/{chunk-RQCKCSRL.js → chunk-U7VQ4NI4.js}

@@ -1,13 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   parseAgentRecipeSchema
-} from "./chunk-7UGL4MB5.js";
-import {
-  parseFleetContract
-} from "./chunk-OEJSLEPW.js";
-import {
-  parseFrontmatter
-} from "./chunk-RKKLTLYB.js";
+} from "./chunk-EQEJJ53P.js";
 import {
   discoverMarketplaceSkills,
   expandSkillInvocationInput,
@@ -15,47 +9,53 @@ import {
   loadSkills,
   parsePendingSkillRequests,
   projectCompatTrusted
-} from "./chunk-2ZSONWVL.js";
+} from "./chunk-T7FDXNRU.js";
 import {
   normalizedSkillHash
-} from "./chunk-NDDGJUXD.js";
+} from "./chunk-DNCE23JJ.js";
 import {
   COMPAT_RESOURCE_PRECEDENCE,
   defaultScopedResourceRoots,
   sourceInfoForRoot,
   splitYamlFrontmatter,
   stringField
-} from "./chunk-YECAMM3D.js";
+} from "./chunk-U7H5WRG5.js";
+import {
+  parseFleetContract
+} from "./chunk-YEJIG7LN.js";
+import {
+  parseFrontmatter
+} from "./chunk-CXQ37WJH.js";
 import {
   assertAgentSpecPolicy,
   normalizeAgentSpec
-} from "./chunk-KFV5L5SK.js";
-import {
-  INTEROP_AGENT_KINDS
-} from "./chunk-KXDSS5WJ.js";
+} from "./chunk-OQM5IVJY.js";
 import {
   readSettings,
   updateSettings
-} from "./chunk-GHS5EBTQ.js";
+} from "./chunk-FKIOX6DS.js";
+import {
+  INTEROP_AGENT_KINDS
+} from "./chunk-5CY4Q6QI.js";
 import {
   runCommandVector
-} from "./chunk-TOIVGRUX.js";
+} from "./chunk-GJ24ODAX.js";
 import {
   expandConfigPath
-} from "./chunk-336NSSKI.js";
+} from "./chunk-VNBICSS2.js";
 import {
   require_dist
-} from "./chunk-APJ265NV.js";
+} from "./chunk-B5GGDIHT.js";
 import {
   safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-ZZFWWYLX.js";
 import {
   clioConfigDir
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   __toESM,
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/resources/index.ts
 init_esm_shims();
@@ -908,4 +908,4 @@ export {
   ResourcesDomainModule,
   createResourcesDomainModule
 };
-//# sourceMappingURL=chunk-RQCKCSRL.js.map
+//# sourceMappingURL=chunk-U7VQ4NI4.js.map

package/dist/{chunk-5TUB6SLS.js → chunk-UFYNOQK4.js}

@@ -3,31 +3,31 @@ import {
   describeYaziProfile,
   inspectCurrentYaziProfile,
   resetYaziProfile
-} from "./chunk-3M6DQK6S.js";
+} from "./chunk-T334FW2H.js";
 import {
   installTool,
   installedToolVersions,
   removeTool
-} from "./chunk-D4CJV46V.js";
+} from "./chunk-5GZICIYO.js";
 import {
   formatColumns,
   printError,
   printOk
-} from "./chunk-JCI2ROMZ.js";
+} from "./chunk-3T4DXWP6.js";
 import {
   describeFloorRejection,
   describeResolution,
   installRemedy,
   toolStatus,
   toolStatuses
-} from "./chunk-QSNYB6ZV.js";
+} from "./chunk-XCUDZQLX.js";
 import {
   PINNED_TOOLS,
   findPinnedTool
-} from "./chunk-QDC3K2U3.js";
+} from "./chunk-K2BLQC5E.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/cli/tools.ts
 init_esm_shims();
@@ -299,4 +299,4 @@ function jsonShape(status) {
 export {
   runToolsCommand
 };
-//# sourceMappingURL=chunk-5TUB6SLS.js.map
+//# sourceMappingURL=chunk-UFYNOQK4.js.map

package/dist/{chunk-R346GLFC.js → chunk-UHW5V7HC.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/core/safe-id.ts
 init_esm_shims();
@@ -28,4 +28,4 @@ export {
   InvalidIdError,
   assertSafeId
 };
-//# sourceMappingURL=chunk-R346GLFC.js.map
+//# sourceMappingURL=chunk-UHW5V7HC.js.map

package/dist/{chunk-USR47QNF.js → chunk-UL36QJX6.js}

@@ -1,54 +1,54 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   migrateSettingsV1Document
-} from "./chunk-5ICU3EUH.js";
+} from "./chunk-GVYWZNRK.js";
 import {
   parseAgentRecipeSchema
-} from "./chunk-7UGL4MB5.js";
+} from "./chunk-EQEJJ53P.js";
 import {
   parseFleetContract
-} from "./chunk-OEJSLEPW.js";
+} from "./chunk-YEJIG7LN.js";
 import {
   parseFrontmatter
-} from "./chunk-RKKLTLYB.js";
+} from "./chunk-CXQ37WJH.js";
 import {
   extensionBaseDir,
   extensionContentDigest,
   installExtension,
   listInstalledExtensions,
   loadManifestFromRoot
-} from "./chunk-5MEZN6CB.js";
+} from "./chunk-DZK63TZJ.js";
 import {
   assertAgentSpecPolicy,
   normalizeAgentSpec
-} from "./chunk-KFV5L5SK.js";
+} from "./chunk-OQM5IVJY.js";
 import {
   readSettings,
   settingsPath,
   updateSettings,
   validateSettings
-} from "./chunk-GHS5EBTQ.js";
+} from "./chunk-FKIOX6DS.js";
 import {
   readClioVersion
-} from "./chunk-IWHMRKLL.js";
+} from "./chunk-E3LEPLQ2.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-UXCU4E3T.js";
+} from "./chunk-SE4ZKILO.js";
 import {
   require_dist
-} from "./chunk-APJ265NV.js";
+} from "./chunk-B5GGDIHT.js";
 import {
   safeResourceBackupPath,
   safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
+} from "./chunk-ZZFWWYLX.js";
 import {
   clioConfigDir,
   resolveClioDirs
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   __toESM,
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/share/archive.ts
 init_esm_shims();
@@ -792,4 +792,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-USR47QNF.js.map
+//# sourceMappingURL=chunk-UL36QJX6.js.map

package/dist/{chunk-VIA6RFQZ.js → chunk-UQIVHSE4.js}

@@ -1,14 +1,14 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   normalizeClioCoderEventType
-} from "./chunk-BTK3SSSK.js";
+} from "./chunk-KMF54VH3.js";
 import {
   clioStateDir,
   stateRootRemoved
-} from "./chunk-BYP5D4HI.js";
+} from "./chunk-CTTI7G3T.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/domains/dispatch/run-event-journal.ts
 init_esm_shims();
@@ -354,4 +354,4 @@ export {
   defaultRunEventJournal,
   readRunEventJournal
 };
-//# sourceMappingURL=chunk-VIA6RFQZ.js.map
+//# sourceMappingURL=chunk-UQIVHSE4.js.map

package/dist/{chunk-RAY4OVGZ.js → chunk-URBGEOH3.js}

@@ -1,16 +1,16 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   typebox_exports
-} from "./chunk-5B2AEOW5.js";
+} from "./chunk-GH5ZR6JP.js";
 import {
   ToolNames
-} from "./chunk-4NSRCOYP.js";
+} from "./chunk-EHOSNVVM.js";
 import {
   StringEnum
-} from "./chunk-YPC6ZR5L.js";
+} from "./chunk-5CMARGPF.js";
 import {
   init_esm_shims
-} from "./chunk-3R73A4XB.js";
+} from "./chunk-ECBHH7LU.js";
 
 // src/tools/steer-surface.ts
 init_esm_shims();
@@ -29,4 +29,4 @@ var steerToolSurface = {
 export {
   steerToolSurface
 };
-//# sourceMappingURL=chunk-RAY4OVGZ.js.map
+//# sourceMappingURL=chunk-URBGEOH3.js.map

package/dist/chunk-USZA7GWL.js

@@ -0,0 +1,341 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  captureWikiSourceContent,
+  captureWikiSourceContentAsync,
+  sanitizeWikiPlan,
+  wikiDir,
+  wikiMarkdownFilesInDir,
+  wikiSourcesMatch
+} from "./chunk-LVFANMOH.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/context/wiki/meta.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : null;
+}
+function nonNegativeSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+var REQUESTED_DEPTHS = ["auto", "simple", "medium", "detailed"];
+var RESOLVED_DEPTHS = ["simple", "medium", "detailed"];
+function parseGeneration(value) {
+  if (!isRecord(value)) return void 0;
+  const { requestedDepth, depth, sourceFiles, sourceLines, pagesPlanned, pagesWritten } = value;
+  if (!REQUESTED_DEPTHS.includes(requestedDepth) || !RESOLVED_DEPTHS.includes(depth) || !nonNegativeSafeInteger(sourceFiles) || !nonNegativeSafeInteger(sourceLines) || !nonNegativeSafeInteger(pagesPlanned) || !nonNegativeSafeInteger(pagesWritten)) {
+    return void 0;
+  }
+  return {
+    requestedDepth,
+    depth,
+    sourceFiles,
+    sourceLines,
+    pagesPlanned,
+    pagesWritten
+  };
+}
+function normalizePages(pages) {
+  return pages.map((page) => ({ path: page.path, title: page.title, ...page.summary ? { summary: page.summary } : {} })).sort((a, b) => a.path.localeCompare(b.path));
+}
+function wikiMetaPath(cwd) {
+  return join(wikiDir(cwd), "meta.json");
+}
+function currentWikiGitHead(cwd) {
+  try {
+    return execFileSync("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function validateWikiMeta(value) {
+  const problems = [];
+  if (!isRecord(value)) {
+    return { ok: false, problems: ["meta must be a JSON object"] };
+  }
+  if (value.version !== 1) problems.push("version must be 1");
+  const updatedAt = stringValue(value.updatedAt);
+  if (!updatedAt) problems.push("updatedAt must be a non-empty string");
+  const gitHead = value.gitHead;
+  if (gitHead !== null && typeof gitHead !== "string") problems.push("gitHead must be a string or null");
+  const sourceTreeHash = value.sourceTreeHash;
+  if (sourceTreeHash !== void 0 && (typeof sourceTreeHash !== "string" || !/^[a-f0-9]{64}$/.test(sourceTreeHash))) {
+    problems.push("sourceTreeHash must be a sha256 hex string when present");
+  }
+  const model = stringValue(value.model);
+  if (!model) problems.push("model must be a non-empty string");
+  const contentHash = stringValue(value.contentHash);
+  if (!contentHash || !/^[a-f0-9]{64}$/.test(contentHash)) {
+    problems.push("contentHash must be a sha256 hex string");
+  }
+  if (!Array.isArray(value.pages)) {
+    problems.push("pages must be an array");
+  } else {
+    for (const [index, page] of value.pages.entries()) {
+      if (!isRecord(page)) {
+        problems.push(`pages[${index}] must be an object`);
+        continue;
+      }
+      if (!stringValue(page.path)) problems.push(`pages[${index}].path must be a non-empty string`);
+      if (!stringValue(page.title)) problems.push(`pages[${index}].title must be a non-empty string`);
+    }
+  }
+  if (problems.length > 0) return { ok: false, problems };
+  const generation = parseGeneration(value.generation);
+  const plan = sanitizeWikiPlan(value.plan, void 0, { trustStatus: true });
+  return {
+    ok: true,
+    value: {
+      version: 1,
+      updatedAt,
+      gitHead,
+      ...sourceTreeHash !== void 0 ? { sourceTreeHash } : {},
+      model,
+      contentHash,
+      pages: normalizePages(value.pages),
+      ...generation !== void 0 ? { generation } : {},
+      ...plan !== null ? { plan } : {}
+    }
+  };
+}
+function isWikiMeta(value) {
+  return validateWikiMeta(value).ok;
+}
+function readWikiMeta(cwd) {
+  return readWikiMetaInDir(wikiDir(cwd));
+}
+function readWikiMetaInDir(dir) {
+  const filePath = join(dir, "meta.json");
+  if (!existsSync(filePath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+  const validation = validateWikiMeta(parsed);
+  return validation.ok ? validation.value : null;
+}
+function writeWikiMeta(cwd, meta) {
+  writeWikiMetaInDir(wikiDir(cwd), meta);
+}
+function writeWikiMetaInDir(dir, meta) {
+  const normalized = {
+    version: 1,
+    updatedAt: meta.updatedAt,
+    gitHead: meta.gitHead,
+    ...meta.sourceTreeHash ? { sourceTreeHash: meta.sourceTreeHash } : {},
+    model: meta.model,
+    contentHash: meta.contentHash,
+    pages: normalizePages(meta.pages),
+    ...meta.generation !== void 0 ? { generation: { ...meta.generation } } : {},
+    ...meta.plan !== void 0 ? { plan: meta.plan } : {}
+  };
+  safeResourceWrite(join(dir, "meta.json"), `${JSON.stringify(normalized)}
+`, { encoding: "utf8" });
+}
+function computeWikiContentHashOfDir(dir) {
+  const hash = createHash("sha256");
+  for (const relPath of wikiMarkdownFilesInDir(dir).sort(compareStrings)) {
+    let text = "";
+    try {
+      text = readFileSync(join(dir, relPath), "utf8");
+    } catch {
+      text = "";
+    }
+    hash.update(`${relPath}\0${text.length}\0`);
+    hash.update(text);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+function computeWikiContentHash(cwd) {
+  return computeWikiContentHashOfDir(wikiDir(cwd));
+}
+
+// src/domains/context/wiki/staleness.ts
+init_esm_shims();
+import { execFile, execFileSync as execFileSync2 } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var GIT_DIFF_LINE_CAP = 200;
+function splitNullTerminatedPaths(output) {
+  return output.split("\0").filter((path) => path.length > 0);
+}
+function currentGitHead(cwd) {
+  try {
+    const out = execFileSync2("git", ["rev-parse", "--verify", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+async function currentGitHeadAsync(cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--verify", "HEAD"], { cwd, encoding: "utf8" });
+    const out = stdout.trim();
+    return out.length > 0 ? out : null;
+  } catch {
+    return null;
+  }
+}
+function collectChangedPaths(cwd, gitHead) {
+  const committed = execFileSync2("git", ["diff", "--name-only", "-z", `${gitHead}..HEAD`], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const trackedWorking = execFileSync2("git", ["diff", "--name-only", "-z", "HEAD"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  const untracked = execFileSync2("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  return /* @__PURE__ */ new Set([
+    ...splitNullTerminatedPaths(committed),
+    ...splitNullTerminatedPaths(trackedWorking),
+    ...splitNullTerminatedPaths(untracked)
+  ]);
+}
+function changedPathsSince(cwd, gitHead) {
+  if (!gitHead) return null;
+  try {
+    return [...collectChangedPaths(cwd, gitHead)];
+  } catch {
+    return null;
+  }
+}
+async function collectChangedPathsAsync(cwd, gitHead) {
+  const run = async (args) => {
+    const { stdout } = await execFileAsync("git", args, { cwd, encoding: "utf8" });
+    return stdout;
+  };
+  const [committed, trackedWorking, untracked] = await Promise.all([
+    run(["diff", "--name-only", "-z", `${gitHead}..HEAD`]),
+    run(["diff", "--name-only", "-z", "HEAD"]),
+    run(["ls-files", "--others", "--exclude-standard", "-z"])
+  ]);
+  return /* @__PURE__ */ new Set([
+    ...splitNullTerminatedPaths(committed),
+    ...splitNullTerminatedPaths(trackedWorking),
+    ...splitNullTerminatedPaths(untracked)
+  ]);
+}
+function capChangedPaths(paths) {
+  const capped = [...paths].slice(0, GIT_DIFF_LINE_CAP);
+  return {
+    count: capped.length,
+    ...paths.size > capped.length ? { warning: `changed file count capped at ${GIT_DIFF_LINE_CAP}` } : {}
+  };
+}
+var CHANGED_COUNT_FAILURE = "wiki staleness unavailable: git diff failed for the recorded wiki gitHead";
+function changedFileCount(cwd, gitHead) {
+  try {
+    return capChangedPaths(collectChangedPaths(cwd, gitHead));
+  } catch {
+    return { warning: CHANGED_COUNT_FAILURE };
+  }
+}
+async function changedFileCountAsync(cwd, gitHead) {
+  try {
+    return capChangedPaths(await collectChangedPathsAsync(cwd, gitHead));
+  } catch {
+    return { warning: CHANGED_COUNT_FAILURE };
+  }
+}
+function wikiCompletenessFromMeta(meta) {
+  const generation = meta?.generation;
+  if (!generation) return null;
+  return {
+    pagesPlanned: generation.pagesPlanned,
+    pagesWritten: generation.pagesWritten,
+    owed: Math.max(0, generation.pagesPlanned - generation.pagesWritten)
+  };
+}
+function wikiCompleteness(cwd) {
+  return wikiCompletenessFromMeta(readWikiMeta(cwd));
+}
+function pendingRefresh(meta) {
+  const available = new Set(meta.pages.map((page) => page.path));
+  if (!meta.plan?.pages.some((page) => page.status !== "written" && available.has(page.path))) return null;
+  return { state: "stale", changedFiles: 0, warning: "wiki has published pages awaiting successful validation" };
+}
+var MISSING_RECORDED_HEAD = "wiki staleness unavailable: recorded gitHead is missing";
+var MISSING_CURRENT_HEAD = "wiki staleness unavailable: current git HEAD is missing";
+function unavailableStaleness(warning) {
+  return { state: "stale", changedFiles: 0, warning };
+}
+function wikiStaleness(cwd) {
+  const meta = readWikiMeta(cwd);
+  if (!meta) return { state: "absent" };
+  const pending = pendingRefresh(meta);
+  if (pending) return pending;
+  if (!meta.gitHead) return unavailableStaleness(MISSING_RECORDED_HEAD);
+  const head = currentGitHead(cwd);
+  if (!head) return unavailableStaleness(MISSING_CURRENT_HEAD);
+  const diff = changedFileCount(cwd, meta.gitHead);
+  if (!("count" in diff)) return unavailableStaleness(diff.warning);
+  if (wikiSourcesMatch(meta.plan?.sourceContent, captureWikiSourceContent(cwd)) && head === meta.gitHead) {
+    return { state: "fresh" };
+  }
+  return { state: "stale", changedFiles: diff.count, ...diff.warning ? { warning: diff.warning } : {} };
+}
+async function wikiStalenessAsync(cwd) {
+  const meta = readWikiMeta(cwd);
+  if (!meta) return { state: "absent" };
+  const pending = pendingRefresh(meta);
+  if (pending) return pending;
+  if (!meta.gitHead) return unavailableStaleness(MISSING_RECORDED_HEAD);
+  const head = await currentGitHeadAsync(cwd);
+  if (!head) return unavailableStaleness(MISSING_CURRENT_HEAD);
+  const diff = await changedFileCountAsync(cwd, meta.gitHead);
+  if (!("count" in diff)) return unavailableStaleness(diff.warning);
+  if (wikiSourcesMatch(meta.plan?.sourceContent, await captureWikiSourceContentAsync(cwd)) && head === meta.gitHead)
+    return { state: "fresh" };
+  return { state: "stale", changedFiles: diff.count, ...diff.warning ? { warning: diff.warning } : {} };
+}
+
+export {
+  wikiMetaPath,
+  currentWikiGitHead,
+  validateWikiMeta,
+  isWikiMeta,
+  readWikiMeta,
+  readWikiMetaInDir,
+  writeWikiMeta,
+  writeWikiMetaInDir,
+  computeWikiContentHashOfDir,
+  computeWikiContentHash,
+  changedPathsSince,
+  wikiCompletenessFromMeta,
+  wikiCompleteness,
+  wikiStaleness,
+  wikiStalenessAsync
+};
+//# sourceMappingURL=chunk-USZA7GWL.js.map