@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-BFPHMSK7.js

@@ -0,0 +1,169 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// apps/clio-coder-web/server/launcher/install.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { access, lstat, mkdir, readFile, realpath, stat, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute as isAbsolute2, join } from "node:path";
+import { parseArgs } from "node:util";
+
+// apps/clio-coder-web/server/launcher/desktop-entry.ts
+init_esm_shims();
+import { isAbsolute } from "node:path";
+var launcherId = "io.iowarp.ClioCoder";
+var launcherUnsupported = "Desktop installation is currently supported on Linux only. Start the web server with --open, or open its printed URL, on this platform.";
+function desktopArgument(value) {
+  if ([...value].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127))
+    throw new Error("Desktop entry paths cannot contain control characters.");
+  return `"${value.replace(/\\/g, "\\\\\\\\").replace(/["`$]/g, "\\\\$&").replace(/%/g, "%%")}"`;
+}
+function desktopEntry(paths) {
+  if (!Object.values(paths).every(isAbsolute)) throw new Error("Launcher paths must be absolute.");
+  if (paths.background !== void 0 && !isAbsolute(paths.background))
+    throw new Error("Background directory must be absolute.");
+  if (paths.icon) desktopArgument(paths.icon);
+  const argv = [
+    paths.node,
+    ...paths.loader ? ["--import", paths.loader] : [],
+    paths.entry,
+    ...paths.background ? ["background", "open", "--directory", paths.background] : ["--open", "--idle-exit", "60000"]
+  ];
+  return [
+    "[Desktop Entry]",
+    "Type=Application",
+    "Name=Clio Coder",
+    "Comment=Build and explore with Clio Coder",
+    `Exec=${argv.map(desktopArgument).join(" ")}`,
+    `Icon=${paths.icon ? paths.icon.replace(/\\/g, "\\\\") : "applications-development"}`,
+    "Terminal=false",
+    "Categories=Development;",
+    "Keywords=Clio;AI;Coding;",
+    "StartupNotify=false",
+    ""
+  ].join("\n");
+}
+
+// apps/clio-coder-web/server/launcher/install.ts
+var hash = (value) => createHash("sha256").update(value).digest("hex");
+var names = { entry: `${launcherId}.desktop`, manifest: `${launcherId}.desktop.owner.json` };
+var missing = (error) => error.code === "ENOENT";
+async function contents(path) {
+  try {
+    const info = await lstat(path);
+    if (!info.isFile() || info.nlink !== 1 || info.size > 16384 || process.getuid && info.uid !== process.getuid())
+      throw new Error("Launcher file is not a small regular file owned by this user.");
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (missing(error)) return null;
+    throw error;
+  }
+}
+async function launcherFiles(prefix, platform = process.platform) {
+  if (platform !== "linux") throw new Error(launcherUnsupported);
+  if (!isAbsolute2(prefix)) throw new Error("--prefix must be an absolute XDG data directory.");
+  const directory = join(prefix, "applications");
+  try {
+    if (!(await lstat(directory)).isDirectory())
+      throw new Error("Launcher applications path must be a directory, not a symlink.");
+  } catch (error) {
+    if (!missing(error)) throw error;
+  }
+  return { directory, entry: join(directory, names.entry), manifest: join(directory, names.manifest) };
+}
+async function launcherStatus(prefix, platform = process.platform) {
+  const files = await launcherFiles(prefix, platform);
+  const entry = await contents(files.entry), manifest = await contents(files.manifest);
+  if (entry === null && manifest === null) return { status: "absent", ...files };
+  let owned = false, available = false;
+  try {
+    const value = JSON.parse(manifest ?? "null");
+    owned = entry !== null && value?.version === 1 && value?.owner === launcherId && value?.sha256 === hash(entry) && desktopEntry(value.launch) === entry;
+    if (owned) {
+      await access(value.launch.node, constants.X_OK);
+      for (const path of [
+        value.launch.node,
+        value.launch.entry,
+        ...value.launch.loader ? [value.launch.loader] : [],
+        ...value.launch.icon ? [value.launch.icon] : []
+      ]) {
+        await access(path, constants.R_OK);
+        if (!(await stat(path)).isFile()) throw new Error("Launcher target is not a file.");
+      }
+      available = true;
+    }
+  } catch {
+  }
+  return {
+    status: owned ? available ? "installed" : "unavailable" : "conflict",
+    ...files
+  };
+}
+async function installLauncher(prefix, paths) {
+  const launch = {
+    node: await realpath(paths.node),
+    ...paths.loader ? { loader: await realpath(paths.loader) } : {},
+    ...paths.icon ? { icon: await realpath(paths.icon) } : {},
+    entry: await realpath(paths.entry),
+    ...paths.background ? { background: await realpath(paths.background) } : {}
+  };
+  const entry = desktopEntry(launch);
+  const state = await launcherStatus(prefix);
+  if (state.status === "installed" && await contents(state.entry) === entry) return state;
+  if (state.status !== "absent")
+    throw new Error(
+      "Launcher files already exist or differ. Inspect status and uninstall the owned entry before installing again."
+    );
+  await mkdir(state.directory, { recursive: true });
+  await launcherFiles(prefix);
+  await writeFile(state.entry, entry, { flag: "wx", mode: 420 });
+  try {
+    await writeFile(
+      state.manifest,
+      `${JSON.stringify({ version: 1, owner: launcherId, sha256: hash(entry), launch })}
+`,
+      {
+        flag: "wx",
+        mode: 384
+      }
+    );
+  } catch (error) {
+    if (await contents(state.entry) === entry) await unlink(state.entry);
+    throw error;
+  }
+  return launcherStatus(prefix);
+}
+async function uninstallLauncher(prefix) {
+  const state = await launcherStatus(prefix);
+  if (state.status === "conflict") throw new Error("Launcher ownership could not be verified; no files were removed.");
+  if (state.status === "installed" || state.status === "unavailable") {
+    await unlink(state.entry);
+    await unlink(state.manifest);
+  }
+  return launcherStatus(prefix);
+}
+async function launcher(args, paths) {
+  const { values, positionals } = parseArgs({ args, allowPositionals: true, options: { prefix: { type: "string" } } });
+  const command = positionals[0];
+  if (positionals.length !== 1 || !["install", "status", "uninstall"].includes(command ?? ""))
+    throw new Error("Usage: launcher install|status|uninstall [--prefix <absolute XDG data directory>]");
+  const prefix = values.prefix ?? (process.env.XDG_DATA_HOME && isAbsolute2(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : join(homedir(), ".local/share"));
+  const result = command === "install" ? await installLauncher(prefix, paths) : command === "uninstall" ? await uninstallLauncher(prefix) : await launcherStatus(prefix);
+  console.log(JSON.stringify(result, null, 2));
+  if (result.status === "conflict" || result.status === "unavailable") process.exitCode = 1;
+}
+
+export {
+  desktopEntry,
+  contents,
+  launcherFiles,
+  launcherStatus,
+  installLauncher,
+  uninstallLauncher,
+  launcher
+};
+//# sourceMappingURL=chunk-BFPHMSK7.js.map

package/dist/chunk-BHJMMCXS.js

@@ -0,0 +1,466 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  createSlicer
+} from "./chunk-KPRLAMP4.js";
+import {
+  WORKSPACE_EXCLUDED_DIRS,
+  enumerateWorkspaceFiles,
+  enumerateWorkspaceFilesAsync
+} from "./chunk-PPEZJWUG.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-ECBHH7LU.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", "decisions"];
+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),
+    ...authored.decisions === void 0 ? {} : { decisions: stringList(authored.decisions) }
+  };
+  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 join4 } from "node:path";
+
+// src/domains/context/wiki/source-content.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+import { join as join3 } from "node:path";
+var MAX_FILES = 2e4;
+var MAX_BYTES = 128 * 1024 * 1024;
+function parseWikiSourceContent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value);
+  if (entries.length > MAX_FILES) return void 0;
+  if (entries.some(([path, hash]) => !path || hash !== null && (typeof hash !== "string" || !/^[a-f0-9]{64}$/.test(hash))))
+    return void 0;
+  return Object.fromEntries(entries);
+}
+function capture(cwd, files) {
+  const content = /* @__PURE__ */ Object.create(null);
+  let remainingBytes = MAX_BYTES;
+  const buffer = Buffer.alloc(64 * 1024);
+  return {
+    content,
+    add(path) {
+      if (files.length > MAX_FILES) return;
+      let fd;
+      content[path] = null;
+      try {
+        fd = openSync(join3(cwd, path), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        const before = fstatSync(fd);
+        if (!before.isFile() || before.size > remainingBytes) return;
+        remainingBytes -= before.size;
+        const hash = createHash("sha256");
+        let remaining = before.size;
+        while (remaining > 0) {
+          const count = readSync(fd, buffer, 0, Math.min(buffer.length, remaining), null);
+          if (count === 0) return;
+          hash.update(buffer.subarray(0, count));
+          remaining -= count;
+        }
+        const after = fstatSync(fd);
+        if (after.size === before.size && after.mtimeMs === before.mtimeMs && after.ctimeMs === before.ctimeMs)
+          content[path] = hash.digest("hex");
+      } catch {
+      } finally {
+        if (fd !== void 0) closeSync(fd);
+      }
+    }
+  };
+}
+function captureWikiSourceContent(cwd) {
+  try {
+    const files = enumerateWorkspaceFiles(cwd, WORKSPACE_EXCLUDED_DIRS);
+    const snapshot = capture(cwd, files);
+    for (const path of files) snapshot.add(path);
+    return snapshot.content;
+  } catch {
+    return {};
+  }
+}
+async function captureWikiSourceContentAsync(cwd) {
+  try {
+    const slicer = createSlicer();
+    const files = await enumerateWorkspaceFilesAsync(cwd, WORKSPACE_EXCLUDED_DIRS, void 0, slicer);
+    const snapshot = capture(cwd, files);
+    for (const path of files) {
+      snapshot.add(path);
+      await slicer.tick();
+    }
+    return snapshot.content;
+  } catch {
+    return {};
+  }
+}
+function wikiSourcesMatch(previous, current, sources) {
+  if (!previous || Object.keys(previous).length === 0 || Object.keys(current).length === 0) return false;
+  const claimed = sources?.map((path) => path.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, ""));
+  const paths = [.../* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(current)])].filter(
+    (path) => !claimed || claimed.some((source) => path === source || path.startsWith(`${source}/`))
+  );
+  if (claimed?.some((source) => !paths.some((path) => path === source || path.startsWith(`${source}/`)))) return false;
+  return paths.length > 0 && paths.every((path) => previous[path] != null && previous[path] === current[path]);
+}
+
+// src/domains/context/wiki/plan-store.ts
+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 join4(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 parsedFailure(value) {
+  if (!isRecord2(value)) return void 0;
+  const phase = value.phase;
+  if (phase !== "admission" && phase !== "writer" && phase !== "validation") return void 0;
+  const detail = usableString2(value.detail)?.replace(/\s+/gu, " ").slice(0, 500);
+  if (!detail) return void 0;
+  const runId = usableString2(value.runId)?.slice(0, 120);
+  return { phase, detail, ...runId ? { runId } : {} };
+}
+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) ?? "").slice(0, MAX_INTENT_CHARS);
+    const title = usableString2(entry.title) ?? path.replace(/\.md$/, "");
+    const sources = stringList2(entry.sources, 16);
+    const prior = priorByPath.get(path);
+    const changedSpec = prior !== void 0 && (prior.title !== title || prior.intent !== intent || JSON.stringify([...prior.sources].sort()) !== JSON.stringify([...sources].sort()));
+    const recorded = options.trustStatus ? parsedStatus(entry.status) : null;
+    const recordedAttempts = options.trustStatus ? parsedAttempts(entry.attempts) : null;
+    const lastFailure = prior?.lastFailure ?? (options.trustStatus ? parsedFailure(entry.lastFailure) : void 0);
+    const dependencies = prior?.dependencies ?? (options.trustStatus ? stringList2(entry.dependencies, Number.POSITIVE_INFINITY) : []);
+    seen.add(path);
+    pages.push({
+      path,
+      title,
+      intent,
+      sources,
+      ...dependencies.length > 0 ? { dependencies } : {},
+      status: changedSpec ? "pending" : prior?.status ?? recorded ?? "pending",
+      attempts: changedSpec ? 0 : prior?.attempts ?? recordedAttempts ?? 0,
+      ...!changedSpec && (prior?.status ?? recorded) !== "written" && lastFailure ? { lastFailure } : {}
+    });
+  }
+  if (pages.length === 0) return null;
+  const retiredPages = [
+    .../* @__PURE__ */ new Set([
+      ...previous?.retiredPages ?? (options.trustStatus ? stringList2(value.retiredPages, MAX_PLAN_PAGES) : []),
+      ...previous?.pages.filter((page) => !seen.has(page.path)).map((page) => page.path) ?? []
+    ])
+  ].map(sanitizePagePath).filter((path) => path !== null && !seen.has(path));
+  const sourceContent = previous?.sourceContent ?? (options.trustStatus ? parseWikiSourceContent(value.sourceContent) : void 0);
+  const sourceTreeHash = previous?.sourceTreeHash ?? (options.trustStatus ? value.sourceTreeHash : void 0);
+  const sourceGitHead = previous?.sourceGitHead ?? (options.trustStatus ? value.sourceGitHead : void 0);
+  const depth = previous?.depth ?? (options.trustStatus ? value.depth : void 0);
+  const requestedDepth = previous?.requestedDepth ?? (options.trustStatus ? value.requestedDepth : void 0);
+  return {
+    version: 1,
+    ...depth === "simple" || depth === "medium" || depth === "detailed" ? { depth } : {},
+    ...requestedDepth === "auto" || requestedDepth === "simple" || requestedDepth === "medium" || requestedDepth === "detailed" ? { requestedDepth } : {},
+    ...sourceContent ? { sourceContent } : {},
+    ...retiredPages.length ? { retiredPages } : {},
+    ...typeof sourceTreeHash === "string" && /^[a-f0-9]{64}$/.test(sourceTreeHash) ? { sourceTreeHash } : {},
+    ...typeof sourceGitHead === "string" && /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(sourceGitHead) ? { sourceGitHead } : {},
+    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, ...page.dependencies ?? [], ...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 (page.status !== "written") return page;
+    if (!input.existingPages.has(page.path)) return { ...page, status: "pending", attempts: 0 };
+    const claimed = [...input.pageSources.get(page.path) ?? [], ...page.sources, ...page.dependencies ?? []];
+    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, retryExhausted = false) {
+  return plan.pages.filter((page) => page.status !== "written" && (retryExhausted || page.attempts < MAX_PAGE_ATTEMPTS));
+}
+
+export {
+  stripFrontmatter,
+  resolveSourcePath,
+  readWikiPage,
+  renderWikiPage,
+  WIKI_QUICKSTART,
+  WIKI_INDEX,
+  WIKI_PLAN_FILE,
+  wikiDir,
+  wikiMarkdownFilesInDir,
+  isGeneratedWikiFile,
+  listWikiPagesInDir,
+  listWikiPages,
+  captureWikiSourceContent,
+  captureWikiSourceContentAsync,
+  wikiSourcesMatch,
+  MAX_PAGE_ATTEMPTS,
+  sanitizePagePath,
+  sanitizeWikiPlan,
+  readWikiPlanFile,
+  readAuthoredWikiPlan,
+  writeWikiPlanFile,
+  unclaimedCandidates,
+  scopePlanForUpdate,
+  pendingPages
+};
+//# sourceMappingURL=chunk-BHJMMCXS.js.map