@iowarp/clio-coder 0.3.0

package/dist/config-ZFCDBMDC.js

@@ -0,0 +1,372 @@
+import {
+  readLayeredSettings,
+  settingsSourceFor
+} from "./chunk-UU3R62TT.js";
+import {
+  loadOperatorProfile,
+  loadProjectRules,
+  renderOperatorProfile,
+  renderPromptContext
+} from "./chunk-UWIJNAOB.js";
+import "./chunk-X3BR7HWV.js";
+import {
+  loadMemoryRecordsSync,
+  memoryStorePath
+} from "./chunk-VOO7NYPP.js";
+import {
+  loadUserHooks,
+  readHookSources
+} 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 {
+  defaultScopedResourceRoots
+} from "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import {
+  listInstalledExtensions
+} from "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import {
+  classifyProjectPreload
+} from "./chunk-KBR4MZZR.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError
+} from "./chunk-67MTHP2E.js";
+import {
+  ceilChars
+} from "./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/config-inspect.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function getByPath(root, dotted) {
+  let current = root;
+  for (const key of dotted.split(".")) {
+    if (current === null || typeof current !== "object") return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function shortHash(text) {
+  let hash = 0;
+  for (let i = 0; i < text.length; i++) hash = hash * 31 + text.charCodeAt(i) | 0;
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function inspectSettings(cwd, graph) {
+  try {
+    const layered = readLayeredSettings(cwd);
+    for (const issue of layered.issues) graph.issues.push(`settings ${issue.origin}: ${issue.path}: ${issue.message}`);
+    const keys = Object.keys(layered.sources).sort();
+    for (const key of keys) {
+      graph.settings.push({
+        key,
+        value: getByPath(layered.settings, key),
+        source: settingsSourceFor(layered.sources, key)
+      });
+    }
+  } catch (err) {
+    graph.issues.push(`settings: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function inspectClioMd(cwd, graph) {
+  const path = join(cwd, "CLIO-CODER.md");
+  if (!existsSync(path)) return;
+  try {
+    const text = readFileSync(path, "utf8");
+    const promptContext = renderPromptContext(cwd);
+    const preload = classifyProjectPreload({ hasClioMd: promptContext.clioMd !== null, text: promptContext.text });
+    graph.entries.push({
+      category: "clio-md",
+      id: "CLIO-CODER.md",
+      scope: "project",
+      sourcePath: path,
+      hash: shortHash(text),
+      trust: "trusted",
+      precedence: "single",
+      reloadClass: "next-turn",
+      contextCostTokens: ceilChars(text.length),
+      detail: {
+        preload: preload.label,
+        preloadChars: preload.chars,
+        preloadLines: preload.lines,
+        ...preload.nearLimit ? { preloadNearLimit: true } : {}
+      }
+    });
+  } catch (err) {
+    graph.issues.push(`clio-md: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function inspectRules(cwd, graph) {
+  try {
+    const loaded = loadProjectRules(cwd);
+    for (const issue of loaded.issues) graph.issues.push(`rule: ${issue}`);
+    for (const rule of loaded.rules) {
+      graph.entries.push({
+        category: "rule",
+        id: rule.id,
+        scope: "project",
+        sourcePath: rule.sourcePath,
+        hash: rule.hash,
+        trust: "trusted",
+        precedence: "single",
+        reloadClass: "next-turn",
+        contextCostTokens: rule.tokenEstimate,
+        detail: {
+          enabled: rule.enabled,
+          conditional: rule.paths !== void 0,
+          ...rule.paths ? { paths: rule.paths } : {}
+        }
+      });
+    }
+    if (loaded.excludes.length > 0) {
+      graph.entries.push({
+        category: "rule",
+        id: "context.excludes",
+        scope: "project",
+        reloadClass: "next-turn",
+        detail: { excludes: loaded.excludes }
+      });
+    }
+  } catch (err) {
+    graph.issues.push(`rules: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function inspectOperatorProfile(cwd, graph) {
+  try {
+    const loaded = loadOperatorProfile(cwd);
+    for (const issue of loaded.issues) graph.issues.push(`operator-profile: ${issue}`);
+    if (loaded.origin === "none") return;
+    const rendered = renderOperatorProfile(loaded.profile);
+    const entry = {
+      category: "operator-profile",
+      id: "operator-profile",
+      scope: loaded.origin,
+      trust: "trusted",
+      precedence: "single",
+      reloadClass: "next-turn",
+      contextCostTokens: rendered.tokenEstimate,
+      detail: { fields: Object.keys(loaded.profile) }
+    };
+    if (loaded.sourcePath !== void 0) entry.sourcePath = loaded.sourcePath;
+    if (loaded.hash !== void 0) entry.hash = loaded.hash;
+    graph.entries.push(entry);
+  } catch (err) {
+    graph.issues.push(`operator-profile: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function inspectHooks(cwd, graph) {
+  try {
+    const extensions = listInstalledExtensions(cwd).filter((ext) => ext.enabled && ext.effective).map((ext) => ({ id: ext.id, rootPath: ext.rootPath }));
+    const { batches, fileIssues } = readHookSources({ cwd, extensions });
+    for (const issue of fileIssues) graph.issues.push(`hook ${issue.source.origin}: ${issue.message}`);
+    const loaded = loadUserHooks(batches, { workspaceRoot: cwd });
+    for (const issue of loaded.issues) {
+      graph.issues.push(`hook ${issue.source.sourcePath}#${issue.index}: ${issue.issues.join("; ")}`);
+    }
+    for (const hook of loaded.hooks) {
+      graph.entries.push({
+        category: "hook",
+        id: hook.id,
+        scope: hook.source.origin,
+        sourcePath: hook.source.sourcePath,
+        hash: hook.hash,
+        trust: hook.source.origin === "extension" ? "untrusted" : "trusted",
+        precedence: "winner",
+        reloadClass: "restart",
+        detail: { on: hook.on, kind: hook.spec.kind, enabled: hook.enabled, ...hook.tools ? { tools: hook.tools } : {} }
+      });
+    }
+    for (const { loser } of loaded.overridden) {
+      graph.entries.push({
+        category: "hook",
+        id: loser.id,
+        scope: loser.source.origin,
+        sourcePath: loser.source.sourcePath,
+        hash: loser.hash,
+        trust: loser.source.origin === "extension" ? "untrusted" : "trusted",
+        precedence: "loser",
+        reloadClass: "restart",
+        detail: { on: loser.on, kind: loser.spec.kind }
+      });
+    }
+  } catch (err) {
+    graph.issues.push(`hooks: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function inspectExtensions(cwd, graph) {
+  try {
+    for (const ext of listInstalledExtensions(cwd, { all: true })) {
+      graph.entries.push({
+        category: "extension",
+        id: ext.id,
+        scope: ext.scope,
+        sourcePath: ext.rootPath,
+        hash: shortHash(`${ext.id}@${ext.version}`),
+        trust: "untrusted",
+        precedence: ext.effective ? "winner" : "loser",
+        reloadClass: "restart",
+        detail: { version: ext.version, enabled: ext.enabled, effective: ext.effective }
+      });
+    }
+  } catch (err) {
+    graph.issues.push(`extensions: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function inspectResourceRoots(cwd, graph) {
+  for (const [kind, category] of [
+    ["skills", "skill-root"],
+    ["prompts", "prompt-root"]
+  ]) {
+    try {
+      for (const root of defaultScopedResourceRoots(kind, cwd)) {
+        graph.entries.push({
+          category,
+          id: `${kind}:${root.scope}`,
+          scope: root.scope,
+          sourcePath: root.path,
+          trust: root.scope === "package" ? "untrusted" : "trusted",
+          precedence: "single",
+          reloadClass: "next-turn",
+          detail: { present: existsSync(root.path), source: root.source }
+        });
+      }
+    } catch (err) {
+      graph.issues.push(`${kind}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
+function inspectSafetyAndMemory(cwd, graph) {
+  try {
+    const layered = readLayeredSettings(cwd);
+    graph.entries.push({
+      category: "safety",
+      id: "autonomy",
+      scope: settingsSourceFor(layered.sources, "autonomy"),
+      reloadClass: "hot",
+      trust: "n/a",
+      precedence: "single",
+      detail: { autonomy: layered.settings.autonomy ?? "auto-edit" }
+    });
+  } catch (err) {
+    graph.issues.push(`safety: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  try {
+    const path = memoryStorePath(clioDataDir());
+    const records = existsSync(path) ? loadMemoryRecordsSync(path) : [];
+    graph.entries.push({
+      category: "memory",
+      id: "memory-store",
+      scope: "user",
+      sourcePath: path,
+      reloadClass: "hot",
+      trust: "trusted",
+      precedence: "single",
+      detail: { present: existsSync(path), records: records.length }
+    });
+  } catch (err) {
+    graph.issues.push(`memory: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function buildCustomizationGraph(cwd) {
+  const graph = { cwd, settings: [], entries: [], issues: [] };
+  inspectSettings(cwd, graph);
+  inspectClioMd(cwd, graph);
+  inspectRules(cwd, graph);
+  inspectOperatorProfile(cwd, graph);
+  inspectHooks(cwd, graph);
+  inspectExtensions(cwd, graph);
+  inspectResourceRoots(cwd, graph);
+  inspectSafetyAndMemory(cwd, graph);
+  return graph;
+}
+
+// src/cli/config.ts
+var HELP = `clio-coder config inspect [--json]
+
+Print the effective-customization graph: what settings, context files, rules,
+skills, prompts, agents, extensions, safety, memory, hooks, and the operator
+profile loaded, from where, with what precedence, trust, reload class, and
+context cost. Read-only; nothing is created.
+
+This is the "why is Clio behaving this way" surface. Parse the --json form in
+scripts instead of the table.
+`;
+function renderText(cwd) {
+  const graph = buildCustomizationGraph(cwd);
+  const out = [`Effective customization for ${cwd}`, ""];
+  out.push("Settings (only keys a layer set; everything else is built-in):");
+  if (graph.settings.length === 0) out.push("  (none; all built-in defaults)");
+  for (const entry of graph.settings) {
+    out.push(`  ${entry.key} = ${JSON.stringify(entry.value)}  [${entry.source}]`);
+  }
+  out.push("");
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const entry of graph.entries) {
+    const list = byCategory.get(entry.category) ?? [];
+    list.push(entry);
+    byCategory.set(entry.category, list);
+  }
+  for (const [category, entries] of byCategory) {
+    out.push(`${category}:`);
+    for (const entry of entries) {
+      const cost = entry.contextCostTokens !== void 0 ? `, ~${entry.contextCostTokens} tok` : "";
+      const hash = entry.hash ? `, #${entry.hash}` : "";
+      const precedence = entry.precedence ? `, ${entry.precedence}` : "";
+      out.push(`  ${entry.id}  [${entry.scope}${precedence}, reload:${entry.reloadClass}${hash}${cost}]`);
+      if (entry.sourcePath) out.push(`    from ${entry.sourcePath}`);
+    }
+    out.push("");
+  }
+  if (graph.issues.length > 0) {
+    out.push("Issues:");
+    for (const issue of graph.issues) out.push(`  - ${issue}`);
+    out.push("");
+  }
+  return `${out.join("\n").trimEnd()}
+`;
+}
+function runConfigCommand(args = []) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const positional = args.filter((arg) => !arg.startsWith("-"));
+  const sub = positional[0] ?? "inspect";
+  if (sub !== "inspect") {
+    printError(`unknown config subcommand: ${sub}`);
+    process.stderr.write(HELP);
+    return 2;
+  }
+  const json = args.includes("--json");
+  const cwd = process.cwd();
+  if (json) {
+    process.stdout.write(`${JSON.stringify(buildCustomizationGraph(cwd), null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(renderText(cwd));
+  return 0;
+}
+export {
+  runConfigCommand
+};
+//# sourceMappingURL=config-ZFCDBMDC.js.map

package/dist/configure-G4E3A2PG.js

@@ -0,0 +1,27 @@
+import {
+  runConfigureCommand,
+  runTargetRemove,
+  runTargetRename
+} from "./chunk-XNISANGE.js";
+import "./chunk-KKKPTZLM.js";
+import "./chunk-ME6DNWIU.js";
+import "./chunk-262G75JS.js";
+import "./chunk-TFSSEXL6.js";
+import "./chunk-PIDUD6M2.js";
+import "./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 "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+export {
+  runConfigureCommand,
+  runTargetRemove,
+  runTargetRename
+};
+//# sourceMappingURL=configure-G4E3A2PG.js.map

package/dist/context-CDXTP2MP.js

@@ -0,0 +1,293 @@
+// src/cli/context.ts
+var HELP = `Usage:
+  clio-coder context
+  clio-coder context init [--yes] [--preview|--heuristic] [--adopt] [--propose|--apply|--rewrite]
+  clio-coder context refresh [--wiki]
+  clio-coder context wiki [--update] [--status] [--depth auto|simple|medium|detailed]
+                    [--target <id>] [--model <id>] [--thinking off|low|medium|high]
+  clio-coder context reset [--all] [--yes]
+  clio-coder context index [--json]
+
+Project context commands:
+  clio-coder context              show project context status (CLIO-CODER.md, preload, codewiki)
+  clio-coder context init         explore the repo and bootstrap CLIO-CODER.md and codewiki
+  clio-coder context refresh      re-index the codewiki and optionally update the Markdown wiki
+  clio-coder context wiki         generate or inspect the agent-authored Markdown wiki
+  clio-coder context reset        clear accumulated project context artifacts
+  clio-coder context index        build the codewiki index without model calls
+`;
+function printWikiProgress(event) {
+  if (event.status === "completed") return;
+  const detail = event.detail ? ` (${event.detail})` : "";
+  process.stderr.write(`clio-coder context wiki: ${event.message}${detail}
+`);
+}
+function compactMetric(value, suffix) {
+  if (value < 1e3) return `${value}${suffix}`;
+  return `${(value / 1e3).toFixed(1)}k${suffix}`;
+}
+function formatGenerationStatus(generation) {
+  if (!generation) return null;
+  const details = [`parser ${generation.parserOutcome}`];
+  if (generation.structuredOutputMode) details.push(generation.structuredOutputMode);
+  const route = [generation.targetId, generation.wireModelId, generation.runtimeId].filter(
+    (value) => typeof value === "string"
+  );
+  if (route.length > 0) details.push(route.join("/"));
+  if (generation.thinkingLevel) details.push(`thinking ${generation.thinkingLevel}`);
+  const usage = [];
+  if (generation.tokenCount !== void 0) usage.push(`${generation.tokenCount} tokens`);
+  if (generation.toolCalls !== void 0) usage.push(`${generation.toolCalls} tools`);
+  if (generation.durationMs !== void 0) usage.push(`${(generation.durationMs / 1e3).toFixed(2)}s`);
+  if (generation.promptBytes !== void 0 && generation.outputBytes !== void 0) {
+    usage.push(`${compactMetric(generation.promptBytes, "B")} in/${compactMetric(generation.outputBytes, "B")} out`);
+  }
+  if (usage.length > 0) details.push(usage.join(", "));
+  if (generation.fallbackReason) {
+    const reason = generation.fallbackReason.length > 160 ? `${generation.fallbackReason.slice(0, 157)}...` : generation.fallbackReason;
+    details.push(`fallback: ${reason}`);
+  }
+  return `generation: ${generation.mode} (${details.join("; ")})`;
+}
+async function printContextStatus() {
+  const context = await import("./context-E3KIFVXI.js");
+  const preload = await import("./preload-KZVHET2B.js");
+  const cwd = process.cwd();
+  const clio = context.tryReadClioMd(cwd);
+  const state = context.readClioState(cwd);
+  const clioMdState = !clio ? "none" : !clio.ok ? "malformed" : state?.contextSources !== void 0 && context.adoptionSourcesChanged(state.contextSources, { cwd }) ? "stale" : "ok";
+  const prompt = context.renderPromptContext(cwd);
+  const preloadClass = preload.classifyProjectPreload({
+    hasClioMd: prompt.clioMd !== null,
+    text: prompt.text
+  });
+  const codewiki = context.readCodewiki(cwd);
+  const codewikiCount = codewiki ? context.codewikiEntries(codewiki).length : 0;
+  const codewikiState = !codewiki ? "absent" : state && !context.isStale(state.fingerprint, context.computeFingerprint(cwd, codewiki)) ? "fresh" : "stale (run clio-coder context refresh)";
+  const codewikiLines = [`codewiki: ${codewikiState} (${codewikiCount} entr${codewikiCount === 1 ? "y" : "ies"})`];
+  if (codewiki) codewikiLines.push(context.renderCodewikiDigest(codewiki));
+  const adoptionSources = state?.contextSources ?? [];
+  const adoptionChanged = state?.contextSources !== void 0 ? context.adoptionSourcesChanged(adoptionSources, { cwd }) : false;
+  const adoptionState = adoptionChanged ? "changed (run clio-coder context init --adopt)" : "up to date";
+  const generationLine = formatGenerationStatus(state?.lastBootstrap);
+  process.stdout.write(
+    [
+      `CLIO-CODER.md: ${clioMdState}`,
+      `preload: ${preloadClass.label}`,
+      ...codewikiLines,
+      `adoption: ${adoptionSources.length} source${adoptionSources.length === 1 ? "" : "s"}, ${adoptionState}`,
+      ...generationLine ? [generationLine] : [],
+      ""
+    ].join("\n")
+  );
+  return 0;
+}
+async function runRefreshCommand(args) {
+  let updateWiki = false;
+  for (const arg of args) {
+    if (arg === "--help" || arg === "-h") {
+      process.stdout.write(HELP);
+      return 0;
+    }
+    if (arg === "--wiki") {
+      updateWiki = true;
+      continue;
+    }
+    process.stderr.write(`clio-coder context refresh: unknown flag ${arg}
+`);
+    process.stdout.write(HELP);
+    return 2;
+  }
+  try {
+    const { runContextRefresh } = await import("./context-E3KIFVXI.js");
+    const wikiEntry = updateWiki ? await import("./wiki-generate-PKFIX6OB.js") : null;
+    const result = await runContextRefresh({
+      cwd: process.cwd(),
+      io: {
+        stdout: (s) => process.stdout.write(s),
+        stderr: (s) => process.stderr.write(s)
+      },
+      wiki: updateWiki,
+      ...wikiEntry ? { wikiGenerate: wikiEntry.modelWikiGenerate(), wikiModel: await wikiEntry.resolveDocumenterModelId() } : {}
+    });
+    if (result.hint) process.stdout.write(`${result.hint}
+`);
+    if (result.wiki) {
+      if (result.wiki.status === "failed") {
+        process.stderr.write(
+          `clio-coder context refresh: wiki update failed: ${(result.wiki.problems ?? ["unknown failure"]).join("; ")}
+`
+        );
+        return 1;
+      }
+      process.stdout.write(
+        result.wiki.status === "noop" ? `clio-coder context refresh: wiki unchanged (${result.wiki.pages} page${result.wiki.pages === 1 ? "" : "s"})
+` : `clio-coder context refresh: wiki updated (${result.wiki.pages} page${result.wiki.pages === 1 ? "" : "s"})
+`
+      );
+    }
+    return 0;
+  } catch (err) {
+    process.stderr.write(`clio-coder context refresh failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function runWikiStatusCommand() {
+  const context = await import("./context-E3KIFVXI.js");
+  const cwd = process.cwd();
+  const meta = context.readWikiMeta(cwd);
+  if (!meta) {
+    const pageCount = context.listWikiPages(cwd).length;
+    process.stdout.write(`wiki: absent (${pageCount} page${pageCount === 1 ? "" : "s"})
+`);
+    return 0;
+  }
+  const currentHead = context.currentWikiGitHead(cwd);
+  const lines = [
+    `wiki: present (${meta.pages.length} page${meta.pages.length === 1 ? "" : "s"})`,
+    `updatedAt: ${meta.updatedAt}`,
+    `gitHead: ${meta.gitHead ?? "none"}`
+  ];
+  if (meta.generation) {
+    const { depth, requestedDepth, sourceFiles, pagesPlanned, pagesWritten } = meta.generation;
+    lines.push(
+      `depth: ${depth} (requested ${requestedDepth}; ${sourceFiles} source files; ${pagesWritten}/${pagesPlanned} planned pages written)`
+    );
+    if (pagesWritten < pagesPlanned) {
+      lines.push(`pending: ${pagesPlanned - pagesWritten} page(s); run \`clio-coder context wiki --update\` to finish`);
+    }
+  }
+  if (currentHead !== meta.gitHead) {
+    lines.push(`staleness: gitHead differs from current HEAD (${currentHead ?? "none"})`);
+  }
+  process.stdout.write(`${lines.join("\n")}
+`);
+  return 0;
+}
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["--target", "--model", "--thinking", "--depth"]);
+function isWikiDepth(value) {
+  return value === "auto" || value === "simple" || value === "medium" || value === "detailed";
+}
+function isThinkingLevel(value) {
+  return value === "off" || value === "low" || value === "medium" || value === "high";
+}
+async function runWikiCommand(args) {
+  let forceUpdate = false;
+  let status = false;
+  let depth = "auto";
+  let target;
+  let model;
+  let thinkingLevel;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--help" || arg === "-h") {
+      process.stdout.write(HELP);
+      return 0;
+    }
+    if (arg === "--update") {
+      forceUpdate = true;
+      continue;
+    }
+    if (arg === "--status") {
+      status = true;
+      continue;
+    }
+    if (VALUE_FLAGS.has(arg ?? "")) {
+      const value = args[index + 1];
+      index += 1;
+      if (arg === "--target" || arg === "--model") {
+        if (!value || value.startsWith("--")) {
+          process.stderr.write(`clio-coder context wiki: ${arg} requires a value
+`);
+          return 2;
+        }
+        if (arg === "--target") target = value;
+        else model = value;
+        continue;
+      }
+      if (arg === "--thinking") {
+        if (!isThinkingLevel(value)) {
+          process.stderr.write("clio-coder context wiki: --thinking must be off, low, medium, or high\n");
+          return 2;
+        }
+        thinkingLevel = value;
+        continue;
+      }
+      if (!isWikiDepth(value)) {
+        process.stderr.write("clio-coder context wiki: --depth must be auto, simple, medium, or detailed\n");
+        return 2;
+      }
+      depth = value;
+      continue;
+    }
+    process.stderr.write(`clio-coder context wiki: unknown flag ${arg}
+`);
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (status) return runWikiStatusCommand();
+  try {
+    const context = await import("./context-E3KIFVXI.js");
+    const { modelWikiGenerate, resolveDocumenterModelId } = await import("./wiki-generate-PKFIX6OB.js");
+    const route = {
+      ...target !== void 0 ? { target } : {},
+      ...model !== void 0 ? { model } : {},
+      ...thinkingLevel !== void 0 ? { thinkingLevel } : {}
+    };
+    const result = await context.runWikiGenerate({
+      cwd: process.cwd(),
+      ...forceUpdate ? { mode: "update" } : {},
+      depth,
+      model: await resolveDocumenterModelId(route),
+      generate: modelWikiGenerate({ route }),
+      onProgress: printWikiProgress
+    });
+    if (result.status === "failed") {
+      process.stderr.write(`clio-coder context wiki failed: ${(result.problems ?? ["unknown failure"]).join("; ")}
+`);
+      return 1;
+    }
+    process.stdout.write(
+      result.status === "noop" ? `clio-coder context wiki: unchanged (${result.pages} page${result.pages === 1 ? "" : "s"})
+` : `clio-coder context wiki: generated ${result.pages} page${result.pages === 1 ? "" : "s"}
+`
+    );
+    return 0;
+  } catch (err) {
+    process.stderr.write(`clio-coder context wiki failed: ${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+async function runContextCommand(args) {
+  const [verb, ...rest] = args;
+  if (verb === void 0) {
+    return printContextStatus();
+  }
+  if (verb === "--help" || verb === "-h") {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  switch (verb) {
+    case "init":
+      return (await import("./init-2OZDJE2D.js")).runInitCommand(rest);
+    case "refresh":
+      return runRefreshCommand(rest);
+    case "wiki":
+      return runWikiCommand(rest);
+    case "reset":
+      return (await import("./context-clear-3F4PLXOS.js")).runContextClearCommand(rest);
+    case "index":
+      return (await import("./context-index-Q7YSYTR3.js")).runContextIndexCommand(rest);
+    default:
+      process.stderr.write(`clio-coder context: unknown subcommand ${verb}
+`);
+      process.stdout.write(HELP);
+      return 2;
+  }
+}
+export {
+  runContextCommand
+};
+//# sourceMappingURL=context-CDXTP2MP.js.map