llm-wiki-compiler 0.1.0

package/dist/cli.js

@@ -0,0 +1,1415 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import "dotenv/config";
+import { createRequire } from "module";
+import { Command } from "commander";
+
+// src/commands/ingest.ts
+import path3 from "path";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+
+// src/utils/markdown.ts
+import { writeFile, rename, readFile, mkdir } from "fs/promises";
+import path from "path";
+import yaml from "js-yaml";
+function slugify(title) {
+  return title.toLowerCase().replace(/['']/g, "").replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function buildFrontmatter(fields) {
+  const dumped = yaml.dump(fields, { lineWidth: -1, quotingType: '"' }).trimEnd();
+  return `---
+${dumped}
+---`;
+}
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) {
+    return { meta: {}, body: content };
+  }
+  let meta = {};
+  try {
+    const parsed = yaml.load(match[1]);
+    if (parsed && typeof parsed === "object") {
+      meta = parsed;
+    }
+  } catch {
+  }
+  return { meta, body: match[2] };
+}
+async function atomicWrite(filePath, content) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  const tmpPath = filePath + ".tmp";
+  await writeFile(tmpPath, content, "utf-8");
+  await rename(tmpPath, filePath);
+}
+async function safeReadFile(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function validateWikiPage(content) {
+  if (!content || content.trim().length === 0) return false;
+  const { meta, body } = parseFrontmatter(content);
+  if (!meta.title) return false;
+  if (body.trim().length === 0) return false;
+  return true;
+}
+
+// src/utils/constants.ts
+var MAX_SOURCE_CHARS = 1e5;
+var MIN_SOURCE_CHARS = 50;
+var QUERY_PAGE_LIMIT = 5;
+var COMPILE_CONCURRENCY = 5;
+var RETRY_COUNT = 3;
+var RETRY_BASE_MS = 1e3;
+var RETRY_MULTIPLIER = 4;
+var MODEL = "claude-sonnet-4-20250514";
+var SOURCES_DIR = "sources";
+var CONCEPTS_DIR = "wiki/concepts";
+var QUERIES_DIR = "wiki/queries";
+var LLMWIKI_DIR = ".llmwiki";
+var STATE_FILE = ".llmwiki/state.json";
+var LOCK_FILE = ".llmwiki/lock";
+var INDEX_FILE = "wiki/index.md";
+
+// src/utils/output.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var MAGENTA = "\x1B[35m";
+var CYAN = "\x1B[36m";
+var RED = "\x1B[31m";
+function bold(text) {
+  return `${BOLD}${text}${RESET}`;
+}
+function dim(text) {
+  return `${DIM}${text}${RESET}`;
+}
+function success(text) {
+  return `${GREEN}${text}${RESET}`;
+}
+function warn(text) {
+  return `${YELLOW}${text}${RESET}`;
+}
+function info(text) {
+  return `${BLUE}${text}${RESET}`;
+}
+function error(text) {
+  return `${RED}${text}${RESET}`;
+}
+function concept(text) {
+  return `${MAGENTA}${BOLD}${text}${RESET}`;
+}
+function source(text) {
+  return `${CYAN}${text}${RESET}`;
+}
+function status(icon, message) {
+  console.log(`${icon} ${message}`);
+}
+function header(title) {
+  console.log(`
+${BOLD}${title}${RESET}`);
+  console.log(dim("\u2500".repeat(Math.min(title.length + 4, 60))));
+}
+
+// src/ingest/web.ts
+import { JSDOM } from "jsdom";
+import { Readability } from "@mozilla/readability";
+import TurndownService from "turndown";
+async function fetchAndParse(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url}: HTTP ${response.status}`);
+  }
+  return response;
+}
+function extractReadableContent(html, url) {
+  const dom = new JSDOM(html, { url });
+  const reader = new Readability(dom.window.document);
+  const article = reader.parse();
+  if (!article || !article.content) {
+    throw new Error(`Could not extract readable content from ${url}`);
+  }
+  return {
+    title: article.title || "Untitled",
+    htmlContent: article.content
+  };
+}
+function convertToMarkdown(html) {
+  const turndown = new TurndownService({ headingStyle: "atx" });
+  return turndown.turndown(html);
+}
+async function ingestWeb(url) {
+  const response = await fetchAndParse(url);
+  const html = await response.text();
+  const { title, htmlContent } = extractReadableContent(html, url);
+  const content = convertToMarkdown(htmlContent);
+  return { title, content };
+}
+
+// src/ingest/file.ts
+import { readFile as readFile2 } from "fs/promises";
+import path2 from "path";
+var SUPPORTED_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".txt"]);
+function titleFromFilename(filePath) {
+  const basename = path2.basename(filePath, path2.extname(filePath));
+  return basename.replace(/[-_]+/g, " ").trim();
+}
+function wrapPlainText(text) {
+  return `\`\`\`
+${text}
+\`\`\``;
+}
+async function ingestFile(filePath) {
+  const ext = path2.extname(filePath).toLowerCase();
+  if (!SUPPORTED_EXTENSIONS.has(ext)) {
+    throw new Error(
+      `Unsupported file type "${ext}". Only .md and .txt files are supported.`
+    );
+  }
+  const raw = await readFile2(filePath, "utf-8");
+  const title = titleFromFilename(filePath);
+  const content = ext === ".md" ? raw : wrapPlainText(raw);
+  return { title, content };
+}
+
+// src/commands/ingest.ts
+function isUrl(source2) {
+  return source2.startsWith("http://") || source2.startsWith("https://");
+}
+function enforceCharLimit(content) {
+  if (content.length <= MAX_SOURCE_CHARS) {
+    return { content, truncated: false, originalChars: content.length };
+  }
+  status(
+    "!",
+    warn(
+      `Content truncated from ${content.length.toLocaleString()} to ${MAX_SOURCE_CHARS.toLocaleString()} characters.`
+    )
+  );
+  return {
+    content: content.slice(0, MAX_SOURCE_CHARS),
+    truncated: true,
+    originalChars: content.length
+  };
+}
+function enforceMinContent(content) {
+  const length = content.trim().length;
+  if (length === 0) {
+    throw new Error(
+      "No readable content could be extracted from the source."
+    );
+  }
+  if (length < MIN_SOURCE_CHARS) {
+    status(
+      "!",
+      warn(
+        `Content seems very short (${length} chars, minimum recommended is ${MIN_SOURCE_CHARS}).`
+      )
+    );
+  }
+}
+function buildDocument(title, source2, result) {
+  const meta = {
+    title,
+    source: source2,
+    ingestedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (result.truncated) {
+    meta.truncated = true;
+    meta.originalChars = result.originalChars;
+  }
+  const frontmatter = buildFrontmatter(meta);
+  return `${frontmatter}
+
+${result.content}
+`;
+}
+async function saveSource(title, document) {
+  const filename = `${slugify(title)}.md`;
+  const destPath = path3.join(SOURCES_DIR, filename);
+  await mkdir2(SOURCES_DIR, { recursive: true });
+  await writeFile2(destPath, document, "utf-8");
+  return destPath;
+}
+async function ingest(source2) {
+  status("*", info(`Ingesting: ${source2}`));
+  const { title, content } = isUrl(source2) ? await ingestWeb(source2) : await ingestFile(source2);
+  const result = enforceCharLimit(content);
+  enforceMinContent(result.content);
+  const document = buildDocument(title, source2, result);
+  const savedPath = await saveSource(title, document);
+  status(
+    "+",
+    success(`Saved ${bold(title)} \u2192 ${source(savedPath)}`)
+  );
+  status("\u2192", dim("Next: llmwiki compile"));
+}
+
+// src/commands/compile.ts
+import { existsSync as existsSync3 } from "fs";
+
+// src/compiler/index.ts
+import { readFile as readFile7, readdir as readdir4 } from "fs/promises";
+import path10 from "path";
+
+// src/utils/state.ts
+import { readFile as readFile3, writeFile as writeFile3, rename as rename2, mkdir as mkdir3, copyFile } from "fs/promises";
+import { existsSync } from "fs";
+import path4 from "path";
+function emptyState() {
+  return { version: 1, indexHash: "", sources: {} };
+}
+async function readState(root) {
+  const filePath = path4.join(root, STATE_FILE);
+  if (!existsSync(filePath)) {
+    return emptyState();
+  }
+  try {
+    const raw = await readFile3(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    const bakPath = filePath + ".bak";
+    console.warn(`\u26A0 Corrupt state.json \u2014 backed up to ${bakPath}, starting fresh.`);
+    await copyFile(filePath, bakPath);
+    return emptyState();
+  }
+}
+async function writeState(root, state) {
+  const dir = path4.join(root, LLMWIKI_DIR);
+  await mkdir3(dir, { recursive: true });
+  const filePath = path4.join(root, STATE_FILE);
+  const tmpPath = filePath + ".tmp";
+  await writeFile3(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+  await rename2(tmpPath, filePath);
+}
+async function updateSourceState(root, sourceFile, entry) {
+  const state = await readState(root);
+  state.sources[sourceFile] = entry;
+  await writeState(root, state);
+}
+async function removeSourceState(root, sourceFile) {
+  const state = await readState(root);
+  delete state.sources[sourceFile];
+  await writeState(root, state);
+}
+
+// src/utils/llm.ts
+import Anthropic from "@anthropic-ai/sdk";
+var client = null;
+function getClient() {
+  if (!client) {
+    client = new Anthropic();
+  }
+  return client;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function callClaude(options) {
+  const { system, messages, tools, maxTokens = 4096, stream = false, onToken } = options;
+  const anthropic = getClient();
+  for (let attempt = 0; attempt <= RETRY_COUNT; attempt++) {
+    try {
+      if (stream) {
+        return await callClaudeStreaming(anthropic, system, messages, maxTokens, onToken);
+      }
+      if (tools && tools.length > 0) {
+        return await callClaudeToolUse(anthropic, system, messages, tools, maxTokens);
+      }
+      return await callClaudeBasic(anthropic, system, messages, maxTokens);
+    } catch (error2) {
+      if (attempt === RETRY_COUNT) throw error2;
+      const delayMs = RETRY_BASE_MS * Math.pow(RETRY_MULTIPLIER, attempt);
+      const errMsg = error2 instanceof Error ? error2.message : String(error2);
+      console.warn(`\u26A0 API call failed (attempt ${attempt + 1}/${RETRY_COUNT + 1}): ${errMsg}`);
+      console.warn(`  Retrying in ${delayMs / 1e3}s...`);
+      await sleep(delayMs);
+    }
+  }
+  throw new Error("Unreachable");
+}
+async function callClaudeStreaming(anthropic, system, messages, maxTokens, onToken) {
+  const stream = anthropic.messages.stream({
+    model: MODEL,
+    max_tokens: maxTokens,
+    system,
+    messages
+  });
+  let fullText = "";
+  for await (const event of stream) {
+    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+      fullText += event.delta.text;
+      onToken?.(event.delta.text);
+    }
+  }
+  return fullText;
+}
+async function callClaudeToolUse(anthropic, system, messages, tools, maxTokens) {
+  const response = await anthropic.messages.create({
+    model: MODEL,
+    max_tokens: maxTokens,
+    system,
+    messages,
+    tools
+  });
+  const toolBlock = response.content.find((block) => block.type === "tool_use");
+  if (toolBlock && toolBlock.type === "tool_use") {
+    return JSON.stringify(toolBlock.input);
+  }
+  const textBlock = response.content.find((block) => block.type === "text");
+  if (textBlock && textBlock.type === "text") {
+    return textBlock.text;
+  }
+  return "";
+}
+async function callClaudeBasic(anthropic, system, messages, maxTokens) {
+  const response = await anthropic.messages.create({
+    model: MODEL,
+    max_tokens: maxTokens,
+    system,
+    messages
+  });
+  const textBlock = response.content.find((block) => block.type === "text");
+  if (textBlock && textBlock.type === "text") {
+    return textBlock.text;
+  }
+  return "";
+}
+
+// src/utils/lock.ts
+import { open, readFile as readFile4, unlink, mkdir as mkdir4 } from "fs/promises";
+import path5 from "path";
+var RECLAIM_SUFFIX = ".reclaim";
+var MAX_ACQUIRE_ATTEMPTS = 2;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function acquireLock(root) {
+  const lockPath = path5.join(root, LOCK_FILE);
+  await mkdir4(path5.join(root, LLMWIKI_DIR), { recursive: true });
+  for (let attempt = 0; attempt < MAX_ACQUIRE_ATTEMPTS; attempt++) {
+    const created = await tryCreateLock(lockPath);
+    if (created) return true;
+    const stale = await isLockStale(lockPath);
+    if (!stale) {
+      status("!", warn("Another compilation is running."));
+      return false;
+    }
+    const reclaimed = await reclaimStaleLock(root, lockPath);
+    if (reclaimed) return true;
+  }
+  status("!", warn("Could not acquire lock after retrying."));
+  return false;
+}
+async function reclaimStaleLock(root, lockPath) {
+  const reclaimPath = lockPath + RECLAIM_SUFFIX;
+  const gotReclaimLock = await acquireReclaimLock(reclaimPath);
+  if (!gotReclaimLock) return false;
+  try {
+    if (!await isLockStale(lockPath)) {
+      return false;
+    }
+    try {
+      await unlink(lockPath);
+    } catch {
+    }
+    const acquired = await tryCreateLock(lockPath);
+    if (acquired) {
+      status("i", dim("Reclaimed stale lock from dead process."));
+    }
+    return acquired;
+  } finally {
+    try {
+      await unlink(reclaimPath);
+    } catch {
+    }
+  }
+}
+async function acquireReclaimLock(reclaimPath) {
+  if (await tryCreateLock(reclaimPath)) return true;
+  if (!await isLockStale(reclaimPath)) return false;
+  try {
+    await unlink(reclaimPath);
+  } catch {
+  }
+  return false;
+}
+async function tryCreateLock(lockPath) {
+  try {
+    const fd = await open(lockPath, "wx");
+    await fd.writeFile(String(process.pid), "utf-8");
+    await fd.close();
+    return true;
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "EEXIST") {
+      return false;
+    }
+    throw err;
+  }
+}
+async function isLockStale(lockPath) {
+  try {
+    const content = await readFile4(lockPath, "utf-8");
+    const pid = parseInt(content.trim(), 10);
+    if (isNaN(pid)) return true;
+    return !isProcessAlive(pid);
+  } catch {
+    return true;
+  }
+}
+async function releaseLock(root) {
+  const lockPath = path5.join(root, LOCK_FILE);
+  try {
+    await unlink(lockPath);
+  } catch {
+  }
+}
+
+// src/compiler/prompts.ts
+var CONCEPT_EXTRACTION_TOOL = {
+  name: "extract_concepts",
+  description: "Extract knowledge concepts from a source document",
+  input_schema: {
+    type: "object",
+    properties: {
+      concepts: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            concept: {
+              type: "string",
+              description: "Human-readable concept title"
+            },
+            summary: {
+              type: "string",
+              description: "One-line description"
+            },
+            is_new: {
+              type: "boolean",
+              description: "True if this is a new concept not in existing wiki"
+            }
+          },
+          required: ["concept", "summary", "is_new"]
+        }
+      }
+    },
+    required: ["concepts"]
+  }
+};
+function buildExtractionPrompt(sourceContent, existingIndex) {
+  const indexSection = existingIndex ? `
+
+Here is the existing wiki index \u2014 avoid duplicating concepts already covered:
+
+${existingIndex}` : "\n\nNo existing wiki pages yet.";
+  return [
+    "You are a knowledge extraction engine. Analyze the following source document",
+    "and identify 3-8 distinct, meaningful concepts worth documenting as wiki pages.",
+    "Each concept should be a standalone topic that someone might look up.",
+    "Focus on key ideas, techniques, patterns, or entities \u2014 not trivial details.",
+    "Use the extract_concepts tool to return your findings.",
+    indexSection,
+    "\n\n--- SOURCE DOCUMENT ---\n\n",
+    sourceContent
+  ].join("\n");
+}
+function buildPagePrompt(concept2, sourceContent, existingPage, relatedPages) {
+  const existingSection = existingPage ? `
+
+Existing page to update:
+
+${existingPage}` : "";
+  const relatedSection = relatedPages ? `
+
+Related wiki pages for cross-referencing:
+
+${relatedPages}` : "";
+  return [
+    `You are a wiki author. Write a clear, well-structured markdown page about "${concept2}".`,
+    "Draw facts only from the provided source material.",
+    "Include a ## Sources section at the end listing the source document.",
+    "Suggest [[wikilinks]] to related concepts where appropriate.",
+    "Write in a neutral, informative tone. Be concise but thorough.",
+    existingSection,
+    relatedSection,
+    "\n\n--- SOURCE MATERIAL ---\n\n",
+    sourceContent
+  ].join("\n");
+}
+function parseConcepts(toolOutput) {
+  try {
+    const parsed = JSON.parse(toolOutput);
+    const concepts = parsed.concepts ?? [];
+    return concepts.filter(
+      (c) => typeof c.concept === "string" && typeof c.summary === "string" && typeof c.is_new === "boolean"
+    );
+  } catch {
+    return [];
+  }
+}
+
+// src/compiler/hasher.ts
+import { createHash } from "crypto";
+import { readFile as readFile5, readdir } from "fs/promises";
+import path6 from "path";
+async function hashFile(filePath) {
+  const content = await readFile5(filePath, "utf-8");
+  return createHash("sha256").update(content).digest("hex");
+}
+async function detectChanges(root, prevState) {
+  const sourcesPath = path6.join(root, SOURCES_DIR);
+  const currentFiles = await listSourceFiles(sourcesPath);
+  const changes = [];
+  for (const file of currentFiles) {
+    const status2 = await classifyFile(root, file, prevState);
+    changes.push({ file, status: status2 });
+  }
+  const deletedChanges = findDeletedFiles(currentFiles, prevState);
+  changes.push(...deletedChanges);
+  return changes;
+}
+async function listSourceFiles(sourcesPath) {
+  try {
+    const entries = await readdir(sourcesPath);
+    return entries.filter((f) => f.endsWith(".md"));
+  } catch {
+    return [];
+  }
+}
+async function classifyFile(root, file, prevState) {
+  const filePath = path6.join(root, SOURCES_DIR, file);
+  const hash = await hashFile(filePath);
+  const prev = prevState.sources[file];
+  if (!prev) return "new";
+  if (prev.hash !== hash) return "changed";
+  return "unchanged";
+}
+function findDeletedFiles(currentFiles, prevState) {
+  const currentSet = new Set(currentFiles);
+  return Object.keys(prevState.sources).filter((file) => !currentSet.has(file)).map((file) => ({ file, status: "deleted" }));
+}
+
+// src/compiler/deps.ts
+function buildConceptToSourcesMap(sources) {
+  const conceptMap = /* @__PURE__ */ new Map();
+  for (const [sourceFile, entry] of Object.entries(sources)) {
+    for (const slug of entry.concepts) {
+      const existing = conceptMap.get(slug);
+      if (existing) {
+        existing.push(sourceFile);
+      } else {
+        conceptMap.set(slug, [sourceFile]);
+      }
+    }
+  }
+  return conceptMap;
+}
+function findAffectedSources(state, directChanges) {
+  const changedFiles = new Set(
+    directChanges.filter((c) => c.status === "new" || c.status === "changed").map((c) => c.file)
+  );
+  const deletedFiles = new Set(
+    directChanges.filter((c) => c.status === "deleted").map((c) => c.file)
+  );
+  const conceptMap = buildConceptToSourcesMap(state.sources);
+  const affected = /* @__PURE__ */ new Set();
+  for (const changedFile of changedFiles) {
+    const sourceEntry = state.sources[changedFile];
+    if (!sourceEntry) continue;
+    for (const slug of sourceEntry.concepts) {
+      const contributors = conceptMap.get(slug);
+      if (!contributors || contributors.length < 2) continue;
+      for (const contributor of contributors) {
+        const skip = changedFiles.has(contributor) || deletedFiles.has(contributor) || affected.has(contributor);
+        if (!skip) {
+          affected.add(contributor);
+        }
+      }
+    }
+  }
+  return Array.from(affected);
+}
+function findFrozenSlugs(state, changes) {
+  const frozen = new Set(state.frozenSlugs ?? []);
+  const deletedFiles = changes.filter((c) => c.status === "deleted").map((c) => c.file);
+  const conceptMap = buildConceptToSourcesMap(state.sources);
+  for (const file of deletedFiles) {
+    const entry = state.sources[file];
+    if (!entry) continue;
+    for (const slug of entry.concepts) {
+      const contributors = conceptMap.get(slug);
+      if (contributors && contributors.length > 1) {
+        frozen.add(slug);
+      }
+    }
+  }
+  return frozen;
+}
+async function persistFrozenSlugs(root, frozenSlugs, successfulExtractions) {
+  const currentState = await readState(root);
+  const conceptMap = buildConceptToSourcesMap(currentState.sources);
+  const extractedBy = /* @__PURE__ */ new Set();
+  for (const result of successfulExtractions) {
+    if (result.concepts.length === 0) continue;
+    for (const c of result.concepts) {
+      extractedBy.add(slugify(c.concept));
+    }
+  }
+  const compiledFiles = new Set(
+    successfulExtractions.filter((r) => r.concepts.length > 0).map((r) => r.sourceFile)
+  );
+  const remaining = /* @__PURE__ */ new Set();
+  for (const slug of frozenSlugs) {
+    const owners = conceptMap.get(slug) ?? [];
+    const allOwnersCompiled = owners.length > 0 && owners.every((f) => compiledFiles.has(f)) && extractedBy.has(slug);
+    if (!allOwnersCompiled) remaining.add(slug);
+  }
+  const stateToSave = { ...currentState, frozenSlugs: Array.from(remaining) };
+  await writeState(root, stateToSave);
+}
+function findLateAffectedSources(extractions, state, allChanges) {
+  const compilingFiles = new Set(
+    allChanges.filter((c) => c.status === "new" || c.status === "changed").map((c) => c.file)
+  );
+  const deletedFiles = new Set(
+    allChanges.filter((c) => c.status === "deleted").map((c) => c.file)
+  );
+  const conceptMap = buildConceptToSourcesMap(state.sources);
+  const freshSlugs = /* @__PURE__ */ new Set();
+  for (const result of extractions) {
+    const oldConcepts = new Set(state.sources[result.sourceFile]?.concepts ?? []);
+    for (const c of result.concepts) {
+      const slug = slugify(c.concept);
+      if (!oldConcepts.has(slug)) {
+        freshSlugs.add(slug);
+      }
+    }
+  }
+  const affected = /* @__PURE__ */ new Set();
+  for (const slug of freshSlugs) {
+    const owners = conceptMap.get(slug);
+    if (!owners) continue;
+    for (const owner of owners) {
+      if (!compilingFiles.has(owner) && !deletedFiles.has(owner)) {
+        affected.add(owner);
+      }
+    }
+  }
+  return Array.from(affected);
+}
+function findSharedConcepts(sourceFile, state) {
+  const shared = /* @__PURE__ */ new Set();
+  const sourceEntry = state.sources[sourceFile];
+  if (!sourceEntry) return shared;
+  const conceptMap = buildConceptToSourcesMap(state.sources);
+  for (const slug of sourceEntry.concepts) {
+    const contributors = conceptMap.get(slug);
+    if (contributors && contributors.length > 1) {
+      shared.add(slug);
+    }
+  }
+  return shared;
+}
+async function freezeFailedExtractions(root, results, frozenSlugs) {
+  for (const result of results) {
+    if (result.concepts.length > 0) continue;
+    status("!", warn(`${result.sourceFile}: no concepts \u2014 will retry.`));
+    const currentState = await readState(root);
+    const oldConcepts = currentState.sources[result.sourceFile]?.concepts ?? [];
+    for (const slug of oldConcepts) frozenSlugs.add(slug);
+    await updateSourceState(root, result.sourceFile, {
+      hash: "",
+      concepts: oldConcepts,
+      compiledAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+}
+
+// src/compiler/orphan.ts
+import path7 from "path";
+async function markOrphaned(root, sourceFile, state) {
+  const sourceEntry = state.sources[sourceFile];
+  if (!sourceEntry) return;
+  const sharedSlugs = findSharedConcepts(sourceFile, state);
+  for (const slug of sourceEntry.concepts) {
+    if (sharedSlugs.has(slug)) {
+      status("i", dim(`Kept: ${slug}.md (shared with other sources)`));
+      continue;
+    }
+    await orphanPage(root, slug, "source deleted");
+  }
+  await removeSourceState(root, sourceFile);
+}
+async function orphanUnownedFrozenPages(root, frozenSlugs) {
+  const currentState = await readState(root);
+  const ownedSlugs = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(currentState.sources)) {
+    for (const slug of entry.concepts) ownedSlugs.add(slug);
+  }
+  for (const slug of frozenSlugs) {
+    if (ownedSlugs.has(slug)) continue;
+    await orphanPage(root, slug, "no remaining sources");
+  }
+}
+async function orphanPage(root, slug, reason) {
+  const pagePath = path7.join(root, CONCEPTS_DIR, `${slug}.md`);
+  const content = await safeReadFile(pagePath);
+  if (!content) return;
+  const { meta } = parseFrontmatter(content);
+  if (meta.orphaned === true) return;
+  const updated = content.replace("---\n", "---\norphaned: true\n");
+  await atomicWrite(pagePath, updated);
+  status("\u26A0", warn(`Orphaned: ${slug}.md (${reason})`));
+}
+
+// src/compiler/resolver.ts
+import { readdir as readdir2, readFile as readFile6 } from "fs/promises";
+import path8 from "path";
+import { existsSync as existsSync2 } from "fs";
+async function buildTitleIndex(root) {
+  const conceptsDir = path8.join(root, CONCEPTS_DIR);
+  if (!existsSync2(conceptsDir)) return [];
+  const files = await readdir2(conceptsDir);
+  const pages = [];
+  for (const file of files) {
+    if (!file.endsWith(".md")) continue;
+    const filePath = path8.join(conceptsDir, file);
+    const content = await readFile6(filePath, "utf-8");
+    const { meta } = parseFrontmatter(content);
+    if (meta.title && typeof meta.title === "string" && !meta.orphaned) {
+      pages.push({
+        slug: file.replace(/\.md$/, ""),
+        title: meta.title,
+        filePath
+      });
+    }
+  }
+  return pages;
+}
+function isInsideWikilink(text, position) {
+  const before = text.lastIndexOf("[[", position);
+  const after = text.indexOf("]]", position);
+  if (before === -1 || after === -1) return false;
+  const closeBefore = text.indexOf("]]", before);
+  return closeBefore >= position;
+}
+function isWordBoundary(text, start, end) {
+  const before = start === 0 || /[\s,.:;!?()\[\]{}/"']/.test(text[start - 1]);
+  const after = end >= text.length || /[\s,.:;!?()\[\]{}/"']/.test(text[end]);
+  return before && after;
+}
+function addWikilinks(body, titles, selfTitle) {
+  let result = body;
+  for (const page of titles) {
+    if (page.title.toLowerCase() === selfTitle.toLowerCase()) continue;
+    const escaped = page.title.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(escaped, "gi");
+    let match;
+    const matches = [];
+    while ((match = regex.exec(result)) !== null) {
+      matches.push({ start: match.index, end: match.index + match[0].length });
+    }
+    for (const m of matches.reverse()) {
+      if (isInsideWikilink(result, m.start)) continue;
+      if (!isWordBoundary(result, m.start, m.end)) continue;
+      result = result.slice(0, m.start) + `[[${page.title}]]` + result.slice(m.end);
+    }
+  }
+  return result;
+}
+async function resolveLinks(root, changedSlugs, newSlugs) {
+  const titleIndex = await buildTitleIndex(root);
+  if (titleIndex.length === 0) return 0;
+  let linkCount = 0;
+  linkCount += await resolveOutboundLinks(titleIndex, changedSlugs);
+  linkCount += await resolveInboundLinks(titleIndex, newSlugs);
+  if (linkCount > 0) {
+    status("\u{1F517}", dim(`Resolved links in ${linkCount} page(s)`));
+  }
+  return linkCount;
+}
+async function resolveOutboundLinks(titleIndex, changedSlugs) {
+  let count = 0;
+  for (const page of titleIndex) {
+    if (!changedSlugs.includes(page.slug)) continue;
+    const didLink = await linkPage(page, titleIndex);
+    if (didLink) count++;
+  }
+  return count;
+}
+async function resolveInboundLinks(titleIndex, newSlugs) {
+  if (newSlugs.length === 0) return 0;
+  const newTitles = titleIndex.filter((p) => newSlugs.includes(p.slug));
+  if (newTitles.length === 0) return 0;
+  let count = 0;
+  for (const page of titleIndex) {
+    if (newSlugs.includes(page.slug)) continue;
+    const content = await readFile6(page.filePath, "utf-8");
+    const { body } = parseFrontmatter(content);
+    const linked = addWikilinks(body, newTitles, page.title);
+    if (linked !== body) {
+      const newContent = content.replace(body, linked);
+      await atomicWrite(page.filePath, newContent);
+      count++;
+    }
+  }
+  return count;
+}
+async function linkPage(page, titleIndex) {
+  const content = await readFile6(page.filePath, "utf-8");
+  const { body } = parseFrontmatter(content);
+  const linked = addWikilinks(body, titleIndex, page.title);
+  if (linked === body) return false;
+  const newContent = content.replace(body, linked);
+  await atomicWrite(page.filePath, newContent);
+  return true;
+}
+
+// src/compiler/indexgen.ts
+import { readdir as readdir3 } from "fs/promises";
+import path9 from "path";
+async function generateIndex(root) {
+  status("*", info("Generating index..."));
+  const conceptsPath = path9.join(root, CONCEPTS_DIR);
+  const queriesPath = path9.join(root, QUERIES_DIR);
+  const concepts = await collectPageSummaries(conceptsPath);
+  const queries = await collectPageSummaries(queriesPath);
+  concepts.sort((a, b) => a.title.localeCompare(b.title));
+  queries.sort((a, b) => a.title.localeCompare(b.title));
+  const indexContent = buildIndexContent(concepts, queries);
+  const indexPath = path9.join(root, INDEX_FILE);
+  await atomicWrite(indexPath, indexContent);
+  const total = concepts.length + queries.length;
+  status("+", success(`Index updated with ${total} pages.`));
+}
+async function collectPageSummaries(conceptsPath) {
+  let files;
+  try {
+    files = await readdir3(conceptsPath);
+  } catch {
+    return [];
+  }
+  const pages = [];
+  for (const file of files.filter((f) => f.endsWith(".md"))) {
+    const content = await safeReadFile(path9.join(conceptsPath, file));
+    const { meta } = parseFrontmatter(content);
+    if (meta.title && typeof meta.title === "string" && !meta.orphaned) {
+      pages.push({
+        title: meta.title,
+        slug: file.replace(/\.md$/, ""),
+        summary: typeof meta.summary === "string" ? meta.summary : ""
+      });
+    }
+  }
+  return pages;
+}
+function stripWikilinks(text) {
+  return text.replace(/\[\[([^\]]+)\]\]/g, "$1");
+}
+function buildIndexContent(concepts, queries) {
+  const lines = ["# Knowledge Wiki", "", "## Concepts", ""];
+  for (const page of concepts) {
+    lines.push(`- **[[${page.title}]]** \u2014 ${stripWikilinks(page.summary)}`);
+  }
+  if (queries.length > 0) {
+    lines.push("", "## Saved Queries", "");
+    for (const page of queries) {
+      lines.push(`- **[[${page.title}]]** \u2014 ${stripWikilinks(page.summary)}`);
+    }
+  }
+  const total = concepts.length + queries.length;
+  lines.push("");
+  lines.push(`_${total} pages | Generated ${(/* @__PURE__ */ new Date()).toISOString()}_`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/compiler/index.ts
+import pLimit from "p-limit";
+async function compile(root) {
+  header("llmwiki compile");
+  const locked = await acquireLock(root);
+  if (!locked) {
+    status("!", error("Could not acquire lock. Try again later."));
+    return;
+  }
+  try {
+    await runCompilePipeline(root);
+  } finally {
+    await releaseLock(root);
+  }
+}
+async function runCompilePipeline(root) {
+  const state = await readState(root);
+  const changes = await detectChanges(root, state);
+  const affectedFiles = findAffectedSources(state, changes);
+  for (const file of affectedFiles) {
+    status("~", info(`${file} [affected by shared concept]`));
+    changes.push({ file, status: "changed" });
+  }
+  const toCompile = changes.filter((c) => c.status === "new" || c.status === "changed");
+  const deleted = changes.filter((c) => c.status === "deleted");
+  const unchanged = changes.filter((c) => c.status === "unchanged");
+  if (toCompile.length === 0 && deleted.length === 0) {
+    status("\u2713", success("Nothing to compile \u2014 all sources up to date."));
+    return;
+  }
+  printChangesSummary(changes);
+  for (const del of deleted) {
+    await markOrphaned(root, del.file, state);
+  }
+  const frozenSlugs = findFrozenSlugs(state, changes);
+  for (const slug of frozenSlugs) {
+    status("i", dim(`Frozen: ${slug} (shared with deleted source)`));
+  }
+  const extractions = [];
+  for (const change of toCompile) {
+    extractions.push(await extractForSource(root, change.file));
+  }
+  const lateAffected = findLateAffectedSources(extractions, state, changes);
+  for (const file of lateAffected) {
+    status("~", info(`${file} [shares concept with new source]`));
+    extractions.push(await extractForSource(root, file));
+  }
+  await freezeFailedExtractions(root, extractions, frozenSlugs);
+  const merged = mergeExtractions(extractions, frozenSlugs);
+  const limit = pLimit(COMPILE_CONCURRENCY);
+  const pageResults = await Promise.all(
+    merged.map((entry) => limit(async () => {
+      await generateMergedPage(root, entry);
+      return entry;
+    }))
+  );
+  const allChangedSlugs = pageResults.map((e) => e.slug);
+  const allNewSlugs = pageResults.filter((e) => e.concept.is_new).map((e) => e.slug);
+  for (const result of extractions) {
+    if (result.concepts.length === 0) continue;
+    await persistSourceState(root, result.sourcePath, result.sourceFile, result.concepts);
+  }
+  if (frozenSlugs.size > 0) {
+    await orphanUnownedFrozenPages(root, frozenSlugs);
+  }
+  await persistFrozenSlugs(root, frozenSlugs, extractions);
+  if (allChangedSlugs.length > 0) {
+    status("\u{1F517}", info("Resolving interlinks..."));
+    await resolveLinks(root, allChangedSlugs, allNewSlugs);
+  }
+  await generateIndex(root);
+  header("Compilation complete");
+  status("\u2713", success(
+    `${toCompile.length} compiled, ${unchanged.length} skipped, ${deleted.length} deleted`
+  ));
+  if (toCompile.length > 0) {
+    status("\u2192", dim('Next: llmwiki query "your question here"'));
+  }
+}
+function printChangesSummary(changes) {
+  const iconMap = {
+    new: "+",
+    changed: "~",
+    unchanged: ".",
+    deleted: "-"
+  };
+  const fmtMap = {
+    new: success,
+    changed: warn,
+    unchanged: dim,
+    deleted: error
+  };
+  for (const c of changes) {
+    const icon = iconMap[c.status] ?? "?";
+    const fmt = fmtMap[c.status] ?? dim;
+    status(icon, fmt(`${c.file} [${c.status}]`));
+  }
+}
+async function extractForSource(root, sourceFile) {
+  header(`Extracting: ${sourceFile}`);
+  const sourcePath = path10.join(root, SOURCES_DIR, sourceFile);
+  const sourceContent = await readFile7(sourcePath, "utf-8");
+  const existingIndex = await safeReadFile(path10.join(root, INDEX_FILE));
+  const concepts = await extractConcepts(sourceContent, existingIndex);
+  if (concepts.length > 0) logExtractedConcepts(concepts);
+  return { sourceFile, sourcePath, sourceContent, concepts };
+}
+function mergeExtractions(extractions, frozenSlugs) {
+  const bySlug = /* @__PURE__ */ new Map();
+  for (const result of extractions) {
+    if (result.concepts.length === 0) continue;
+    for (const concept2 of result.concepts) {
+      const slug = slugify(concept2.concept);
+      if (frozenSlugs.has(slug)) continue;
+      const existing = bySlug.get(slug);
+      if (existing) {
+        existing.sourceFiles.push(result.sourceFile);
+        existing.combinedContent += `
+
+--- SOURCE: ${result.sourceFile} ---
+
+${result.sourceContent}`;
+      } else {
+        bySlug.set(slug, {
+          slug,
+          concept: concept2,
+          sourceFiles: [result.sourceFile],
+          combinedContent: `--- SOURCE: ${result.sourceFile} ---
+
+${result.sourceContent}`
+        });
+      }
+    }
+  }
+  return Array.from(bySlug.values());
+}
+async function generateMergedPage(root, entry) {
+  const pagePath = path10.join(root, CONCEPTS_DIR, `${entry.slug}.md`);
+  const existingPage = await safeReadFile(pagePath);
+  const relatedPages = await loadRelatedPages(root, entry.slug);
+  status(">", info(`Generating: ${entry.concept.concept}`));
+  const system = buildPagePrompt(
+    entry.concept.concept,
+    entry.combinedContent,
+    existingPage,
+    relatedPages
+  );
+  const pageBody = await callClaude({
+    system,
+    messages: [
+      { role: "user", content: `Write the wiki page for "${entry.concept.concept}".` }
+    ],
+    stream: true,
+    onToken: (token) => process.stdout.write(dim(token))
+  });
+  process.stdout.write("\n");
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existing = existingPage ? parseFrontmatter(existingPage) : null;
+  const createdAt = existing?.meta.createdAt && typeof existing.meta.createdAt === "string" ? existing.meta.createdAt : now;
+  const frontmatter = buildFrontmatter({
+    title: entry.concept.concept,
+    summary: entry.concept.summary,
+    sources: entry.sourceFiles,
+    createdAt,
+    updatedAt: now
+  });
+  const fullPage = `${frontmatter}
+
+${pageBody}
+`;
+  await writePageIfValid(pagePath, fullPage, entry.concept.concept);
+}
+async function extractConcepts(sourceContent, existingIndex) {
+  status("*", info("Extracting concepts..."));
+  const system = buildExtractionPrompt(sourceContent, existingIndex);
+  const rawOutput = await callClaude({
+    system,
+    messages: [{ role: "user", content: "Extract the key concepts from this source." }],
+    tools: [CONCEPT_EXTRACTION_TOOL]
+  });
+  return parseConcepts(rawOutput);
+}
+function logExtractedConcepts(concepts) {
+  for (const c of concepts) {
+    const tag = c.is_new ? success("NEW") : dim("update");
+    status("*", `${concept(c.concept)} [${tag}] \u2014 ${c.summary}`);
+  }
+}
+async function loadRelatedPages(root, excludeSlug) {
+  const conceptsPath = path10.join(root, CONCEPTS_DIR);
+  let files;
+  try {
+    files = await readdir4(conceptsPath);
+  } catch {
+    return "";
+  }
+  const related = files.filter((f) => f.endsWith(".md") && f !== `${excludeSlug}.md`).slice(0, 5);
+  const contents = [];
+  for (const f of related) {
+    const content = await safeReadFile(path10.join(conceptsPath, f));
+    if (!content) continue;
+    const { meta } = parseFrontmatter(content);
+    if (meta.orphaned) continue;
+    contents.push(content);
+  }
+  return contents.join("\n\n---\n\n");
+}
+async function writePageIfValid(pagePath, content, conceptTitle) {
+  if (!validateWikiPage(content)) {
+    status("!", warn(`Invalid page for "${conceptTitle}" \u2014 skipped.`));
+    return;
+  }
+  await atomicWrite(pagePath, content);
+  status("+", success(`Wrote: ${conceptTitle}`));
+}
+async function persistSourceState(root, sourcePath, sourceFile, concepts) {
+  const hash = await hashFile(sourcePath);
+  const entry = {
+    hash,
+    concepts: concepts.map((c) => slugify(c.concept)),
+    compiledAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await updateSourceState(root, sourceFile, entry);
+}
+
+// src/commands/compile.ts
+async function compileCommand() {
+  if (!existsSync3(SOURCES_DIR)) {
+    status(
+      "!",
+      warn("No sources found. Run `llmwiki ingest <url>` first.")
+    );
+    return;
+  }
+  await compile(process.cwd());
+}
+
+// src/commands/query.ts
+import { existsSync as existsSync4 } from "fs";
+import path11 from "path";
+var PAGE_DIRS = [CONCEPTS_DIR, QUERIES_DIR];
+var PAGE_SELECTION_TOOL = {
+  name: "select_pages",
+  description: "Select the most relevant wiki pages to answer a question",
+  input_schema: {
+    type: "object",
+    properties: {
+      pages: {
+        type: "array",
+        items: {
+          type: "string",
+          description: "Slug of a relevant wiki page (e.g. 'llm-knowledge-bases')"
+        },
+        maxItems: QUERY_PAGE_LIMIT
+      },
+      reasoning: {
+        type: "string",
+        description: "Brief explanation of why these pages were selected"
+      }
+    },
+    required: ["pages", "reasoning"]
+  }
+};
+async function selectPages(question, indexContent) {
+  const systemPrompt = "You are a knowledge base assistant. Given a question and a wiki index, select the most relevant pages.";
+  const userMessage = `Question: ${question}
+
+Wiki Index:
+${indexContent}`;
+  const rawResult = await callClaude({
+    system: systemPrompt,
+    messages: [{ role: "user", content: userMessage }],
+    tools: [PAGE_SELECTION_TOOL]
+  });
+  try {
+    const parsed = JSON.parse(rawResult);
+    return {
+      pages: Array.isArray(parsed.pages) ? parsed.pages.filter((p) => typeof p === "string") : [],
+      reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning : "No reasoning provided"
+    };
+  } catch {
+    return { pages: [], reasoning: "Failed to parse page selection response" };
+  }
+}
+async function loadSelectedPages(root, slugs) {
+  const sections = [];
+  for (const slug of slugs) {
+    let content = "";
+    for (const dir of PAGE_DIRS) {
+      const candidate = await safeReadFile(path11.join(root, dir, `${slug}.md`));
+      if (!candidate) continue;
+      const { meta } = parseFrontmatter(candidate);
+      if (meta.orphaned) continue;
+      content = candidate;
+      break;
+    }
+    if (!content) {
+      status("?", warn(`Page not found: ${slug}.md \u2014 skipping`));
+      continue;
+    }
+    sections.push(`--- Page: ${slug} ---
+${content}`);
+  }
+  return sections.join("\n\n");
+}
+async function streamAnswer(question, pagesContent) {
+  const systemPrompt = "You are a knowledge assistant. Answer the question using ONLY the wiki content provided. Cite specific pages using [[Page Title]] wikilinks. If the wiki doesn't contain enough information, say so.";
+  const userMessage = `Question: ${question}
+
+Relevant wiki pages:
+${pagesContent}`;
+  const answer = await callClaude({
+    system: systemPrompt,
+    messages: [{ role: "user", content: userMessage }],
+    stream: true,
+    onToken: (text) => process.stdout.write(text)
+  });
+  process.stdout.write("\n");
+  return answer;
+}
+function summarizeAnswer(answer) {
+  const firstLine = answer.trim().split(/\n/)[0] ?? "";
+  const firstSentence = firstLine.split(/(?<=[.!?])\s/)[0] ?? firstLine;
+  return firstSentence.slice(0, 120);
+}
+async function saveQueryPage(root, question, answer) {
+  const slug = slugify(question);
+  const filePath = path11.join(root, QUERIES_DIR, `${slug}.md`);
+  const frontmatter = buildFrontmatter({
+    title: question,
+    summary: summarizeAnswer(answer),
+    type: "query",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const document = `${frontmatter}
+
+${answer}
+`;
+  await atomicWrite(filePath, document);
+  status(
+    "+",
+    success(`Saved query \u2192 ${source(filePath)}`)
+  );
+  await generateIndex(root);
+}
+async function queryCommand(root, question, options) {
+  if (!existsSync4(path11.join(root, INDEX_FILE))) {
+    status("!", error("Wiki index not found. Run `llmwiki compile` first."));
+    return;
+  }
+  header("Selecting relevant pages");
+  const indexContent = await safeReadFile(path11.join(root, INDEX_FILE));
+  const { pages: rawPages, reasoning } = await selectPages(question, indexContent);
+  const pages = rawPages.map((p) => slugify(p));
+  status("i", dim(`Reasoning: ${reasoning}`));
+  status("*", info(`Selected ${pages.length} page(s): ${rawPages.join(", ")}`));
+  header("Generating answer");
+  const pagesContent = await loadSelectedPages(root, pages);
+  if (!pagesContent) {
+    status("!", error("No matching pages found. Try refining your question."));
+    return;
+  }
+  const answer = await streamAnswer(question, pagesContent);
+  if (options.save) {
+    await saveQueryPage(root, question, answer);
+    status("\u2192", dim("Saved. Future queries will use this answer as context."));
+  } else {
+    status("\u2192", dim("Tip: use --save to add this answer to your wiki"));
+  }
+}
+
+// src/commands/watch.ts
+import { watch as chokidarWatch } from "chokidar";
+import { existsSync as existsSync5 } from "fs";
+import path12 from "path";
+var DEBOUNCE_MS = 500;
+async function watchCommand() {
+  const sourcesPath = path12.resolve(SOURCES_DIR);
+  if (!existsSync5(sourcesPath)) {
+    status(
+      "!",
+      warn("No sources/ directory found. Run `llmwiki ingest <url>` first.")
+    );
+    return;
+  }
+  header("llmwiki watch");
+  status("\u{1F441}", info(`Watching ${sourcesPath} for changes...`));
+  status("i", dim("Press Ctrl+C to stop.\n"));
+  let compiling = false;
+  let pendingRecompile = false;
+  let debounceTimer = null;
+  const triggerCompile = async () => {
+    if (compiling) {
+      pendingRecompile = true;
+      return;
+    }
+    compiling = true;
+    try {
+      await compile(process.cwd());
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      status("!", error(`Compile failed: ${msg}`));
+    }
+    compiling = false;
+    if (pendingRecompile) {
+      pendingRecompile = false;
+      await triggerCompile();
+    }
+  };
+  const scheduleCompile = (eventPath, event) => {
+    status(
+      "~",
+      dim(`${event}: ${path12.basename(eventPath)}`)
+    );
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(triggerCompile, DEBOUNCE_MS);
+  };
+  const watcher = chokidarWatch(sourcesPath, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 200 }
+  });
+  watcher.on("add", (p) => scheduleCompile(p, "added")).on("change", (p) => scheduleCompile(p, "changed")).on("unlink", (p) => scheduleCompile(p, "deleted"));
+  await new Promise(() => {
+  });
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.name("llmwiki").description("The knowledge compiler \u2014 raw sources in, interlinked wiki out").version(version);
+program.command("ingest <source>").description("Ingest a URL or local file into sources/").action(async (source2) => {
+  try {
+    await ingest(source2);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+program.command("compile").description("Compile sources/ into an interlinked wiki").action(async () => {
+  requireApiKey();
+  try {
+    await compileCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+program.command("query <question>").description("Ask a question against the wiki").option("--save", "Save the answer as a wiki page").action(async (question, options) => {
+  requireApiKey();
+  try {
+    await queryCommand(process.cwd(), question, options);
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+program.command("watch").description("Watch sources/ and auto-recompile on changes").action(async () => {
+  requireApiKey();
+  try {
+    await watchCommand();
+  } catch (err) {
+    console.error(`\x1B[31mError:\x1B[0m ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  }
+});
+program.parse();
+function requireApiKey() {
+  if (!process.env.ANTHROPIC_API_KEY) {
+    console.error(
+      "\x1B[31mError:\x1B[0m ANTHROPIC_API_KEY environment variable is required.\n  Set it with: export ANTHROPIC_API_KEY=sk-ant-...\n  Get a key at: https://console.anthropic.com/settings/keys"
+    );
+    process.exit(1);
+  }
+}
+//# sourceMappingURL=cli.js.map