@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-X4RCMKVQ.js

@@ -0,0 +1,641 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  computeFingerprint,
+  computeFingerprintAsync
+} from "./chunk-VJWL6YS5.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/context/wiki/frontmatter.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { isAbsolute, join, normalize, relative } from "node:path";
+var FRONTMATTER_BLOCK = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+var LIST_FIELDS = ["sources", "symbols", "tests", "invariants", "validate"];
+var SUMMARY_MAX_CHARS = 240;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function usableString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringList(value) {
+  if (!Array.isArray(value)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    const usable = usableString(entry);
+    if (usable) seen.add(usable);
+  }
+  return [...seen];
+}
+function wikiPageHeading(text) {
+  return usableString(/^#\s+(.+?)\s*$/m.exec(stripFrontmatter(text).body)?.[1]);
+}
+function titleFromPagePath(pagePath) {
+  const base = pagePath.replace(/^.*\//, "").replace(/\.md$/i, "");
+  const spaced = base.replace(/[-_]+/g, " ").trim();
+  return spaced.length > 0 ? spaced.charAt(0).toUpperCase() + spaced.slice(1) : base;
+}
+function stripFrontmatter(content) {
+  const match = FRONTMATTER_BLOCK.exec(content);
+  if (!match) return { block: null, body: content };
+  return { block: match[1] ?? "", body: content.slice(match[0].length) };
+}
+function summaryFromBody(body) {
+  const skipped = ["#", "|", "```", "-", "*", ">", "<!--"];
+  const paragraphs = body.split(/\r?\n\s*\r?\n/).map((paragraph) => paragraph.replace(/\s+/g, " ").trim()).filter((paragraph) => paragraph.length > 0 && !skipped.some((prefix) => paragraph.startsWith(prefix)));
+  const first = paragraphs[0] ?? "";
+  return first.length > SUMMARY_MAX_CHARS ? `${first.slice(0, SUMMARY_MAX_CHARS - 1).trimEnd()}\u2026` : first;
+}
+function isWithin(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel.length === 0 || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function resolveSourcePath(sourceRoot, cited) {
+  if (cited.length === 0 || isAbsolute(cited) || /[*?{}<>]/.test(cited)) return null;
+  const direct = normalize(join(sourceRoot, cited));
+  if (!isWithin(sourceRoot, direct)) return null;
+  if (existsSync(direct)) return direct;
+  if (cited.endsWith(".js")) {
+    for (const extension of [".ts", ".tsx"]) {
+      const authored = normalize(join(sourceRoot, `${cited.slice(0, -3)}${extension}`));
+      if (isWithin(sourceRoot, authored) && existsSync(authored)) return authored;
+    }
+  }
+  return null;
+}
+function readWikiPage(input) {
+  const { block, body } = stripFrontmatter(input.content);
+  let fields;
+  if (block !== null) {
+    try {
+      fields = (0, import_yaml.parse)(`
+${block}`, { schema: "core", uniqueKeys: true });
+    } catch {
+      fields = void 0;
+    }
+  }
+  const authored = isRecord(fields) ? fields : {};
+  const metadata = {
+    title: usableString(authored.title) ?? wikiPageHeading(body) ?? titleFromPagePath(input.pagePath),
+    summary: usableString(authored.summary) ?? summaryFromBody(body),
+    sources: [],
+    symbols: stringList(authored.symbols),
+    tests: [],
+    invariants: stringList(authored.invariants),
+    validate: stringList(authored.validate)
+  };
+  const unresolvedPaths = [];
+  for (const field of ["sources", "tests"]) {
+    for (const cited of stringList(authored[field])) {
+      if (input.sourceRoot === void 0 || resolveSourcePath(input.sourceRoot, cited) !== null) {
+        metadata[field].push(cited);
+      } else {
+        unresolvedPaths.push(cited);
+      }
+    }
+  }
+  return { metadata, body, unresolvedPaths };
+}
+function renderList(name, values) {
+  if (values.length === 0) return [];
+  return [`${name}:`, ...values.map((value) => `  - ${JSON.stringify(value)}`)];
+}
+function renderFrontmatter(metadata) {
+  const lines = [`title: ${JSON.stringify(metadata.title)}`];
+  if (metadata.summary.length > 0) lines.push(`summary: ${JSON.stringify(metadata.summary)}`);
+  for (const field of LIST_FIELDS) lines.push(...renderList(field, metadata[field]));
+  return `---
+${lines.join("\n")}
+---
+`;
+}
+function renderWikiPage(metadata, body) {
+  const trimmed = body.replace(/^\s+/, "").replace(/\s+$/, "");
+  const hasHeading = /^#\s+\S/m.test(trimmed);
+  const withHeading = hasHeading ? trimmed : `# ${metadata.title}
+
+${trimmed}`;
+  return `${renderFrontmatter(metadata)}
+${withHeading}
+`;
+}
+
+// src/domains/context/wiki/layout.ts
+init_esm_shims();
+import { readdirSync, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var WIKI_QUICKSTART = "quickstart.md";
+var WIKI_INDEX = "index.md";
+var WIKI_PLAN_FILE = "_plan.json";
+var NON_PAGE_FILES = /* @__PURE__ */ new Set(["meta.json", WIKI_PLAN_FILE]);
+function compareStrings(a, b) {
+  return a.localeCompare(b);
+}
+function wikiDir(cwd) {
+  return join2(cwd, ".clio-coder", "wiki");
+}
+function wikiMarkdownFilesInDir(dir, prefix = "") {
+  let entries;
+  try {
+    entries = readdirSync(join2(dir, prefix), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const relPath = prefix.length > 0 ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      files.push(...wikiMarkdownFilesInDir(dir, relPath));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".md") && !NON_PAGE_FILES.has(entry.name)) {
+      files.push(relPath);
+    }
+  }
+  return files.sort(compareStrings);
+}
+function isGeneratedWikiFile(relPath) {
+  return relPath === WIKI_QUICKSTART || relPath === WIKI_INDEX || relPath.endsWith(`/${WIKI_INDEX}`);
+}
+function listWikiPagesInDir(dir) {
+  const pages = [];
+  for (const relPath of wikiMarkdownFilesInDir(dir)) {
+    if (relPath !== WIKI_QUICKSTART && isGeneratedWikiFile(relPath)) continue;
+    let content = "";
+    try {
+      content = readFileSync(join2(dir, relPath), "utf8");
+    } catch {
+      content = "";
+    }
+    const { metadata } = readWikiPage({ pagePath: relPath, content });
+    pages.push({
+      path: relPath,
+      title: metadata.title,
+      ...metadata.summary.length > 0 ? { summary: metadata.summary } : {}
+    });
+  }
+  return pages;
+}
+function listWikiPages(cwd) {
+  return listWikiPagesInDir(wikiDir(cwd));
+}
+
+// src/domains/context/wiki/plan-store.ts
+init_esm_shims();
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+var MAX_PAGE_ATTEMPTS = 3;
+var MAX_INTENT_CHARS = 600;
+var MAX_PLAN_PAGES = 200;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function usableString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function stringList2(value, limit) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const entry of value) {
+    const usable = usableString2(entry);
+    if (usable && !out.includes(usable)) out.push(usable);
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+function sanitizePagePath(value) {
+  const raw = usableString2(value);
+  if (raw === null) return null;
+  const normalized = raw.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+  if (!normalized.endsWith(".md") || normalized.length > 200) return null;
+  const segments = normalized.split("/");
+  if (segments.some((segment) => segment.length === 0 || segment === "." || segment === ".." || segment.startsWith("."))) {
+    return null;
+  }
+  if (isGeneratedWikiFile(normalized)) return null;
+  return normalized;
+}
+function wikiPlanPath(dir) {
+  return join3(dir, WIKI_PLAN_FILE);
+}
+function parsedStatus(value) {
+  return value === "written" || value === "pending" ? value : null;
+}
+function parsedAttempts(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function sanitizeWikiPlan(value, previous, options = { trustStatus: true }) {
+  if (!isRecord2(value) || !Array.isArray(value.pages)) return null;
+  const priorByPath = new Map((previous?.pages ?? []).map((page) => [page.path, page]));
+  const pages = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value.pages) {
+    if (pages.length >= MAX_PLAN_PAGES) break;
+    if (!isRecord2(entry)) continue;
+    const path = sanitizePagePath(entry.path);
+    if (path === null || seen.has(path)) continue;
+    const intent = usableString2(entry.intent);
+    const prior = priorByPath.get(path);
+    const recorded = options.trustStatus ? parsedStatus(entry.status) : null;
+    const recordedAttempts = options.trustStatus ? parsedAttempts(entry.attempts) : null;
+    seen.add(path);
+    pages.push({
+      path,
+      title: usableString2(entry.title) ?? path.replace(/\.md$/, ""),
+      intent: intent === null ? "" : intent.slice(0, MAX_INTENT_CHARS),
+      sources: stringList2(entry.sources, 16),
+      status: prior?.status ?? recorded ?? "pending",
+      attempts: prior?.attempts ?? recordedAttempts ?? 0
+    });
+  }
+  if (pages.length === 0) return null;
+  return { version: 1, overview: usableString2(value.overview) ?? previous?.overview ?? "", pages };
+}
+function readPlanDocument(dir) {
+  const filePath = wikiPlanPath(dir);
+  if (!existsSync2(filePath)) return void 0;
+  try {
+    return JSON.parse(readFileSync2(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function readWikiPlanFile(dir, previous) {
+  const document = readPlanDocument(dir);
+  return document === void 0 ? null : sanitizeWikiPlan(document, previous, { trustStatus: true });
+}
+function readAuthoredWikiPlan(dir, previous) {
+  const document = readPlanDocument(dir);
+  return document === void 0 ? null : sanitizeWikiPlan(document, previous, { trustStatus: false });
+}
+function writeWikiPlanFile(dir, plan) {
+  safeResourceWrite(wikiPlanPath(dir), `${JSON.stringify(plan, null, 2)}
+`, { encoding: "utf8" });
+}
+function unclaimedCandidates(plan, candidate, pageSources = /* @__PURE__ */ new Map()) {
+  const knownPaths = new Set(plan.pages.map((page) => page.path));
+  const claimed = /* @__PURE__ */ new Set();
+  for (const page of plan.pages) {
+    for (const source of [...page.sources, ...pageSources.get(page.path) ?? []]) claimed.add(source);
+  }
+  return candidate.pages.filter(
+    (page) => !knownPaths.has(page.path) && !page.sources.some((source) => claimed.has(source))
+  );
+}
+function scopePlanForUpdate(input) {
+  const changedPrefixes = [...input.changedPaths];
+  const pages = input.plan.pages.map((page) => {
+    if (!input.existingPages.has(page.path)) return { ...page, status: "pending", attempts: 0 };
+    const claimed = [...input.pageSources.get(page.path) ?? [], ...page.sources];
+    const touched = claimed.some(
+      (source) => changedPrefixes.some((changed) => changed === source || changed.startsWith(`${source}/`))
+    );
+    return touched ? { ...page, status: "pending", attempts: 0 } : { ...page, status: "written" };
+  });
+  return { ...input.plan, pages };
+}
+function pendingPages(plan) {
+  return plan.pages.filter((page) => page.status !== "written" && page.attempts < MAX_PAGE_ATTEMPTS);
+}
+
+// src/domains/context/wiki/meta.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+function compareStrings2(a, b) {
+  return a.localeCompare(b);
+}
+function isRecord3(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 (!isRecord3(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 join4(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 (!isRecord3(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 (!isRecord3(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) {
+  const filePath = wikiMetaPath(cwd);
+  if (!existsSync3(filePath)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync3(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+  const validation = validateWikiMeta(parsed);
+  return validation.ok ? validation.value : null;
+}
+function writeWikiMeta(cwd, 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(wikiMetaPath(cwd), `${JSON.stringify(normalized)}
+`, { encoding: "utf8" });
+}
+function computeWikiContentHashOfDir(dir) {
+  const hash = createHash("sha256");
+  for (const relPath of wikiMarkdownFilesInDir(dir).sort(compareStrings2)) {
+    let text = "";
+    try {
+      text = readFileSync3(join4(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 [];
+  try {
+    return [...collectChangedPaths(cwd, gitHead)];
+  } catch {
+    return [];
+  }
+}
+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));
+}
+var MISSING_RECORDED_HEAD = "wiki staleness unavailable: recorded gitHead is missing";
+var MISSING_CURRENT_HEAD = "wiki staleness unavailable: current git HEAD is missing";
+function wikiStaleness(cwd) {
+  const meta = readWikiMeta(cwd);
+  if (!meta) return { state: "absent" };
+  if (!meta.gitHead) return { state: "fresh", warning: MISSING_RECORDED_HEAD };
+  const head = currentGitHead(cwd);
+  if (!head) return { state: "fresh", warning: MISSING_CURRENT_HEAD };
+  if (meta.sourceTreeHash && computeFingerprint(cwd).treeHash === meta.sourceTreeHash && head === meta.gitHead) {
+    return { state: "fresh" };
+  }
+  if (!meta.sourceTreeHash && head === meta.gitHead) return { state: "fresh" };
+  const diff = changedFileCount(cwd, meta.gitHead);
+  if (!("count" in diff)) return { state: "fresh", warning: diff.warning };
+  return { state: "stale", changedFiles: diff.count, ...diff.warning ? { warning: diff.warning } : {} };
+}
+async function wikiStalenessAsync(cwd) {
+  const meta = readWikiMeta(cwd);
+  if (!meta) return { state: "absent" };
+  if (!meta.gitHead) return { state: "fresh", warning: MISSING_RECORDED_HEAD };
+  const head = await currentGitHeadAsync(cwd);
+  if (!head) return { state: "fresh", warning: MISSING_CURRENT_HEAD };
+  if (meta.sourceTreeHash) {
+    const fingerprint = await computeFingerprintAsync(cwd);
+    if (fingerprint.treeHash === meta.sourceTreeHash && head === meta.gitHead) return { state: "fresh" };
+  } else if (head === meta.gitHead) {
+    return { state: "fresh" };
+  }
+  const diff = await changedFileCountAsync(cwd, meta.gitHead);
+  if (!("count" in diff)) return { state: "fresh", warning: diff.warning };
+  return { state: "stale", changedFiles: diff.count, ...diff.warning ? { warning: diff.warning } : {} };
+}
+
+export {
+  resolveSourcePath,
+  readWikiPage,
+  renderWikiPage,
+  WIKI_QUICKSTART,
+  WIKI_INDEX,
+  WIKI_PLAN_FILE,
+  wikiDir,
+  wikiMarkdownFilesInDir,
+  isGeneratedWikiFile,
+  listWikiPagesInDir,
+  listWikiPages,
+  MAX_PAGE_ATTEMPTS,
+  sanitizePagePath,
+  sanitizeWikiPlan,
+  readWikiPlanFile,
+  readAuthoredWikiPlan,
+  writeWikiPlanFile,
+  unclaimedCandidates,
+  scopePlanForUpdate,
+  pendingPages,
+  wikiMetaPath,
+  currentWikiGitHead,
+  validateWikiMeta,
+  isWikiMeta,
+  readWikiMeta,
+  writeWikiMeta,
+  computeWikiContentHashOfDir,
+  computeWikiContentHash,
+  changedPathsSince,
+  wikiCompletenessFromMeta,
+  wikiCompleteness,
+  wikiStaleness,
+  wikiStalenessAsync
+};
+//# sourceMappingURL=chunk-X4RCMKVQ.js.map