kb-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1339 @@
+// src/init.js
+import { mkdir, writeFile, access, rm } from "fs/promises";
+import { join, basename } from "path";
+import TOML from "@iarna/toml";
+function resolveProjectName(options) {
+  return options.name || basename(options.directory);
+}
+function buildConfigToml(projectName) {
+  const config = {
+    project: {
+      name: projectName,
+      version: "0.1.0"
+    },
+    directories: {
+      sources: "sources",
+      wiki: "wiki"
+    },
+    llm: {
+      provider: "anthropic",
+      model: "claude-sonnet-4-20250514"
+    }
+  };
+  const tomlStr = TOML.stringify(config);
+  return tomlStr + '\n[dependencies]\n# shared-glossary = { path = "../shared-glossary" }\n';
+}
+function buildSchemaMd() {
+  return `# KB Schema \u2014 LLM Instructions
+
+This file defines the conventions for this knowledge base. The \`kb\` CLI and any
+LLM operating on this wiki MUST follow these rules.
+
+---
+
+## Wiki Structure Conventions
+
+- All pages live under the \`wiki/\` directory.
+- \`wiki/_index.md\` is the wiki root and serves as a table of contents.
+- Sub-topics may be organised into sub-directories: \`wiki/<topic>/_index.md\`.
+- File names use kebab-case, e.g. \`wiki/authentication-flow.md\`.
+- Every page must have a valid YAML frontmatter block.
+
+---
+
+## Frontmatter Schema
+
+Every wiki page must begin with a YAML frontmatter block:
+
+\`\`\`yaml
+---
+title: <Human-readable page title>
+tags: [tag1, tag2]        # optional; array of lowercase strings
+created: <ISO 8601 date>  # e.g. 2026-04-05
+updated: <ISO 8601 date>  # updated whenever content changes
+source: <path or URL>     # optional; original source material
+---
+\`\`\`
+
+Required fields: \`title\`, \`created\`.
+
+---
+
+## Page Templates
+
+### Entity Page
+Use for: people, systems, services, tools.
+
+\`\`\`markdown
+---
+title: <Entity Name>
+tags: [entity]
+created: <ISO date>
+updated: <ISO date>
+---
+
+# <Entity Name>
+
+**Type**: <system | person | service | tool>
+
+## Overview
+
+<One-paragraph description.>
+
+## Key Attributes
+
+- **Attribute**: value
+
+## Related
+
+- [[related-page]]
+\`\`\`
+
+### Concept Page
+Use for: ideas, patterns, terminology.
+
+\`\`\`markdown
+---
+title: <Concept Name>
+tags: [concept]
+created: <ISO date>
+updated: <ISO date>
+---
+
+# <Concept Name>
+
+## Definition
+
+<Clear definition in 1-3 sentences.>
+
+## Context
+
+<When and why this concept matters in the project.>
+
+## See Also
+
+- [[related-concept]]
+\`\`\`
+
+### Source Summary Page
+Use for: summarised source material (docs, papers, meetings).
+
+\`\`\`markdown
+---
+title: Summary \u2014 <Source Title>
+tags: [source-summary]
+created: <ISO date>
+source: <path or URL>
+---
+
+# Summary \u2014 <Source Title>
+
+## Key Points
+
+- Point one
+- Point two
+
+## Decisions / Implications
+
+<What this source means for the project.>
+
+## Raw Source
+
+See \`sources/<filename>\`.
+\`\`\`
+
+### Comparison Page
+Use for: side-by-side evaluation of options.
+
+\`\`\`markdown
+---
+title: Comparison \u2014 <Topic>
+tags: [comparison]
+created: <ISO date>
+updated: <ISO date>
+---
+
+# Comparison \u2014 <Topic>
+
+| Criterion | Option A | Option B |
+|-----------|----------|----------|
+| ...       | ...      | ...      |
+
+## Recommendation
+
+<Which option and why.>
+\`\`\`
+
+---
+
+## Wikilink Conventions
+
+- Basic link: \`[[page-name]]\` \u2014 links to \`wiki/page-name.md\`.
+- Display text: \`[[page-name|display text]]\` \u2014 renders as "display text".
+- Cross-directory: \`[[topic/sub-page]]\`.
+- All wikilink targets must be lowercase kebab-case matching the file name without \`.md\`.
+
+---
+
+## Ingest Workflow
+
+1. Place the source file in \`sources/\` (PDF, Markdown, plain text, etc.).
+2. Run \`kb ingest sources/<filename>\`.
+3. The CLI reads the file, calls the configured LLM, and generates a source-summary
+   page in \`wiki/\`.
+4. The summary page is linked from \`wiki/_index.md\` under **Sources**.
+5. An entry is appended to \`log.md\`.
+
+---
+
+## Query Workflow
+
+1. Run \`kb query "<natural-language question>"\`.
+2. The CLI searches the wiki index for relevant pages.
+3. Relevant page content is assembled into a prompt context.
+4. The LLM answers the question, citing wikilinks.
+5. The answer is printed to stdout. Nothing is written to disk unless \`--save\` is passed.
+
+---
+
+## Lint Workflow
+
+Run \`kb lint\` to check for:
+
+- Pages missing required frontmatter fields (\`title\`, \`created\`).
+- Broken wikilinks (targets that don't resolve to an existing page).
+- Pages not reachable from \`wiki/_index.md\`.
+- Duplicate page titles across the wiki.
+- Frontmatter fields with invalid types or formats.
+
+Lint exits with code 0 on success, 1 if errors are found.
+`;
+}
+function buildIndexMd(projectName, isoDate) {
+  return `---
+title: ${projectName} Knowledge Base
+created: ${isoDate}
+---
+
+# ${projectName} Knowledge Base
+
+> This wiki is maintained by the \`kb\` CLI tool.
+
+## Pages
+
+(No pages yet. Use \`kb ingest <source>\` to add content.)
+
+## Sources
+
+(No sources yet.)
+`;
+}
+function buildLogMd(projectName, isoDate) {
+  return `# Activity Log
+
+## ${isoDate} \u2014 Project initialized
+
+Project \`${projectName}\` initialized.
+`;
+}
+async function kbDirExists(directory) {
+  try {
+    await access(join(directory, ".kb"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initProject(options) {
+  const projectName = resolveProjectName(options);
+  const { directory } = options;
+  if (await kbDirExists(directory)) {
+    throw new Error(`Knowledge base already initialized: .kb/ already exists in ${directory}`);
+  }
+  const isoDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  try {
+    await Promise.all([
+      mkdir(join(directory, ".kb"), { recursive: true }),
+      mkdir(join(directory, "sources"), { recursive: true }),
+      mkdir(join(directory, "wiki"), { recursive: true })
+    ]);
+    await Promise.all([
+      writeFile(join(directory, ".kb", "config.toml"), buildConfigToml(projectName), "utf8"),
+      writeFile(join(directory, ".kb", "schema.md"), buildSchemaMd(), "utf8"),
+      writeFile(join(directory, "sources", ".gitkeep"), "", "utf8"),
+      writeFile(join(directory, "wiki", "_index.md"), buildIndexMd(projectName, isoDate), "utf8"),
+      writeFile(join(directory, "log.md"), buildLogMd(projectName, isoDate), "utf8")
+    ]);
+  } catch (error) {
+    await rm(join(directory, ".kb"), { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// src/config.js
+import { readFile } from "fs/promises";
+import TOML2 from "@iarna/toml";
+var VALID_PROVIDERS = ["anthropic", "openai", "ollama"];
+function requireSafeRelativePath(val, field) {
+  if (val.startsWith("/") || val.split("/").includes("..")) {
+    throw new Error(`Invalid config: ${field} must be a safe relative path, got "${val}"`);
+  }
+}
+function requireString(obj, key, context) {
+  const val = obj[key];
+  if (typeof val !== "string" || val.trim() === "") {
+    throw new Error(`Invalid config: missing required field "${context}.${key}"`);
+  }
+  return val;
+}
+function requireSection(obj, key) {
+  const val = obj[key];
+  if (val === void 0 || val === null || typeof val !== "object" || Array.isArray(val)) {
+    throw new Error(`Invalid config: missing required section "[${key}]"`);
+  }
+  return val;
+}
+async function parseConfig(configPath) {
+  let raw;
+  try {
+    raw = await readFile(configPath, "utf8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Config file not found: ${configPath}
+${message}`);
+  }
+  let parsed;
+  try {
+    parsed = TOML2.parse(raw);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid TOML in config file ${configPath}: ${message}`);
+  }
+  const project = requireSection(parsed, "project");
+  const name = requireString(project, "name", "project");
+  const version = requireString(project, "version", "project");
+  const directories = requireSection(parsed, "directories");
+  const sources = requireString(directories, "sources", "directories");
+  requireSafeRelativePath(sources, "directories.sources");
+  const wiki = requireString(directories, "wiki", "directories");
+  requireSafeRelativePath(wiki, "directories.wiki");
+  const llm = requireSection(parsed, "llm");
+  const providerRaw = requireString(llm, "provider", "llm");
+  if (!VALID_PROVIDERS.includes(providerRaw)) {
+    throw new Error(`Invalid config: llm.provider must be one of ${VALID_PROVIDERS.join(", ")}, got "${providerRaw}"`);
+  }
+  const provider = providerRaw;
+  const model = requireString(llm, "model", "llm");
+  const rawDeps = parsed["dependencies"];
+  const dependencies = {};
+  if (rawDeps !== void 0 && rawDeps !== null && typeof rawDeps === "object" && !Array.isArray(rawDeps)) {
+    for (const [depKey, depVal] of Object.entries(rawDeps)) {
+      if (typeof depVal === "object" && depVal !== null && !Array.isArray(depVal)) {
+        const dep = depVal;
+        dependencies[depKey] = {
+          ...typeof dep["path"] === "string" ? { path: dep["path"] } : {},
+          ...typeof dep["git"] === "string" ? { git: dep["git"] } : {},
+          ...typeof dep["branch"] === "string" ? { branch: dep["branch"] } : {},
+          ...typeof dep["mode"] === "string" ? { mode: dep["mode"] } : {}
+        };
+      }
+    }
+  }
+  return {
+    project: { name, version },
+    directories: { sources, wiki },
+    llm: { provider, model },
+    dependencies
+  };
+}
+
+// src/project.js
+import { access as access2 } from "fs/promises";
+import { join as join2, dirname, resolve } from "path";
+async function hasKbDir(dir) {
+  try {
+    await access2(join2(dir, ".kb", "config.toml"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findProjectRoot(startDir) {
+  let current = resolve(startDir);
+  while (true) {
+    if (await hasKbDir(current)) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+async function loadProject(startDir) {
+  const root = await findProjectRoot(startDir);
+  if (root === null) {
+    throw new Error(`No kb project found. Run "kb init" to initialize a knowledge base in the current directory.`);
+  }
+  const kbDir = join2(root, ".kb");
+  const configPath = join2(kbDir, "config.toml");
+  const config = await parseConfig(configPath);
+  return {
+    name: config.project.name,
+    root,
+    kbDir,
+    sourcesDir: join2(root, config.directories.sources),
+    wikiDir: join2(root, config.directories.wiki),
+    config
+  };
+}
+async function tryLoadProject(startDir) {
+  try {
+    return await loadProject(startDir);
+  } catch (err) {
+    if (err instanceof Error && /no kb project found/i.test(err.message)) {
+      return null;
+    }
+    throw err;
+  }
+}
+
+// src/db.js
+import Database from "better-sqlite3";
+import { join as join3 } from "path";
+var SCHEMA_SQL = `
+CREATE VIRTUAL TABLE IF NOT EXISTS pages USING fts5(
+  path,
+  title,
+  content,
+  tags,
+  project,
+  tokenize='porter unicode61'
+);
+
+CREATE TABLE IF NOT EXISTS page_meta (
+  path TEXT PRIMARY KEY,
+  sha256 TEXT NOT NULL,
+  mtime INTEGER NOT NULL,
+  word_count INTEGER NOT NULL DEFAULT 0,
+  frontmatter TEXT NOT NULL DEFAULT '{}',
+  outgoing_links TEXT NOT NULL DEFAULT '[]',
+  updated_at INTEGER NOT NULL
+);
+`;
+function openDb(project) {
+  const dbPath = join3(project.kbDir, "index.db");
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(SCHEMA_SQL);
+  return db;
+}
+function closeDb(db) {
+  db.close();
+}
+
+// src/markdown.js
+import { readFile as readFile2 } from "fs/promises";
+import matter from "gray-matter";
+var WIKILINK_RE = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g;
+var H1_RE = /^#\s+(.+)$/m;
+function extractTitle(fm, content, relativePath) {
+  if (typeof fm["title"] === "string" && fm["title"].trim() !== "") {
+    return fm["title"].trim();
+  }
+  const h1Match = H1_RE.exec(content);
+  if (h1Match) {
+    return h1Match[1].trim();
+  }
+  const filename = relativePath.split("/").pop() ?? relativePath;
+  return filename.replace(/\.md$/i, "");
+}
+function extractTags(fm) {
+  const tags = fm["tags"];
+  if (!Array.isArray(tags))
+    return "";
+  return tags.filter((t) => typeof t === "string").join(",");
+}
+function extractWikiLinks(content) {
+  const links = [];
+  let match;
+  const re = new RegExp(WIKILINK_RE.source, "g");
+  while ((match = re.exec(content)) !== null) {
+    links.push(match[1].trim());
+  }
+  return links;
+}
+function countWords(text) {
+  const trimmed = text.trim();
+  if (trimmed === "")
+    return 0;
+  return trimmed.split(/\s+/).length;
+}
+async function parsePage(filePath, relativePath, rawContent) {
+  const raw = rawContent ?? await readFile2(filePath, "utf8");
+  const parsed = matter(raw);
+  const fm = parsed.data;
+  const content = parsed.content;
+  const title = extractTitle(fm, content, relativePath);
+  const tags = extractTags(fm);
+  const outgoingLinks = extractWikiLinks(content);
+  const wordCount = countWords(content);
+  return {
+    path: relativePath,
+    title,
+    content,
+    tags,
+    frontmatter: fm,
+    outgoingLinks,
+    wordCount
+  };
+}
+
+// src/indexer.js
+import { createHash } from "crypto";
+import { readFile as readFile3, stat, readdir } from "fs/promises";
+import { join as join4, relative } from "path";
+async function collectMdFiles(dir) {
+  try {
+    const entries = await readdir(dir, {
+      recursive: true,
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => join4(e.parentPath ?? e.path, e.name));
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+    return [];
+  }
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function upsertParsedPage(stmts, project, page, hash, mtime) {
+  stmts.deletePages.run(page.path);
+  stmts.insertPage.run(page.path, page.title, page.content, page.tags, project.name);
+  stmts.upsertMeta.run(page.path, hash, mtime, page.wordCount, JSON.stringify(page.frontmatter), JSON.stringify(page.outgoingLinks), Date.now());
+}
+async function indexProject(project, rebuild = false) {
+  const db = openDb(project);
+  try {
+    if (rebuild) {
+      db.exec("DELETE FROM pages; DELETE FROM page_meta;");
+    }
+    const files = await collectMdFiles(project.wikiDir);
+    const stats = { indexed: 0, skipped: 0, deleted: 0, errors: 0 };
+    const getMetaStmt = db.prepare("SELECT sha256 FROM page_meta WHERE path = ?");
+    const upsertStmts = {
+      deletePages: db.prepare("DELETE FROM pages WHERE path = ?"),
+      insertPage: db.prepare("INSERT INTO pages(path, title, content, tags, project) VALUES (?, ?, ?, ?, ?)"),
+      upsertMeta: db.prepare(`
+        INSERT INTO page_meta(path, sha256, mtime, word_count, frontmatter, outgoing_links, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(path) DO UPDATE SET
+          sha256 = excluded.sha256,
+          mtime = excluded.mtime,
+          word_count = excluded.word_count,
+          frontmatter = excluded.frontmatter,
+          outgoing_links = excluded.outgoing_links,
+          updated_at = excluded.updated_at
+      `)
+    };
+    const deleteStalePages = db.prepare("DELETE FROM pages WHERE path = ?");
+    const deleteStaleMeta = db.prepare("DELETE FROM page_meta WHERE path = ?");
+    const listMetaStmt = db.prepare("SELECT path FROM page_meta");
+    const processFile = db.transaction((page, hash, mtime) => {
+      upsertParsedPage(upsertStmts, project, page, hash, mtime);
+    });
+    const onDiskPaths = /* @__PURE__ */ new Set();
+    for (const absPath of files) {
+      const relPath = relative(project.root, absPath);
+      onDiskPaths.add(relPath);
+      let raw;
+      try {
+        raw = await readFile3(absPath, "utf8");
+      } catch (err) {
+        stats.errors++;
+        continue;
+      }
+      const hash = sha256(raw);
+      const existing = getMetaStmt.get(relPath);
+      if (existing && existing.sha256 === hash) {
+        stats.skipped++;
+        continue;
+      }
+      let fileStat;
+      try {
+        fileStat = await stat(absPath);
+      } catch {
+        stats.errors++;
+        continue;
+      }
+      let page;
+      try {
+        page = await parsePage(absPath, relPath, raw);
+      } catch {
+        stats.errors++;
+        continue;
+      }
+      try {
+        processFile(page, hash, Math.floor(fileStat.mtimeMs));
+        stats.indexed++;
+      } catch {
+        stats.errors++;
+      }
+    }
+    const allMetaPaths = listMetaStmt.all().map((r) => r.path);
+    const stalePaths = allMetaPaths.filter((p) => !onDiskPaths.has(p));
+    const deleteStale = db.transaction((paths) => {
+      for (const p of paths) {
+        deleteStalePages.run(p);
+        deleteStaleMeta.run(p);
+      }
+    });
+    deleteStale(stalePaths);
+    stats.deleted += stalePaths.length;
+    return stats;
+  } finally {
+    closeDb(db);
+  }
+}
+
+// src/search.js
+function sanitizeFtsQuery(query) {
+  const tokens = query.trim().split(/\s+/).filter((t) => t.length > 0);
+  if (tokens.length === 0)
+    return '""';
+  return tokens.map((t) => `"${t.replace(/"/g, '""')}"`).join(" ");
+}
+function parseTags(raw) {
+  if (!raw || raw.trim() === "")
+    return [];
+  return raw.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+}
+function searchWiki(db, query, projectName, options) {
+  if (!query || query.trim() === "") {
+    return [];
+  }
+  const limit = options?.limit ?? 10;
+  const ftsQuery = sanitizeFtsQuery(query.trim());
+  const filterTags = options?.tags?.length ? options.tags.map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0) : [];
+  const tagClauses = filterTags.map(() => "AND lower(tags) LIKE ?").join(" ");
+  const tagParams = filterTags.map((t) => `%${t}%`);
+  const stmt = db.prepare(`
+    SELECT path, title, tags, bm25(pages) as rank,
+           snippet(pages, 2, '', '', '...', 8) as snippet
+    FROM pages
+    WHERE pages MATCH ? AND project = ?
+    ${tagClauses}
+    ORDER BY rank
+    LIMIT ?
+  `);
+  const rows = stmt.all(ftsQuery, projectName, ...tagParams, limit);
+  const results = rows.map((row) => ({
+    rank: row.rank,
+    path: row.path,
+    title: row.title,
+    snippet: row.snippet,
+    tags: parseTags(row.tags)
+  }));
+  return results;
+}
+
+// src/source-reader.js
+import { readFile as readFile4 } from "fs/promises";
+import { basename as basename2, extname } from "path";
+function sanitizeFilename(name) {
+  return name.toLowerCase().replace(/\s/g, "-");
+}
+function detectType(sourcePath) {
+  if (sourcePath.startsWith("http://") || sourcePath.startsWith("https://")) {
+    return "url";
+  }
+  const ext = extname(sourcePath).toLowerCase();
+  if (ext === ".pdf")
+    return "pdf";
+  if (ext === ".md")
+    return "markdown";
+  return "text";
+}
+function filenameFromUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const parts = parsed.pathname.split("/").filter(Boolean);
+    const last = parts[parts.length - 1];
+    const pagePart = last ? last.includes(".") ? last : `${last}.html` : "index.html";
+    return sanitizeFilename(`${parsed.hostname}-${pagePart}`);
+  } catch {
+    return "url-content.html";
+  }
+}
+function stripHtml(html) {
+  let text = html.replace(/<script[\s\S]*?<\/script>/gi, " ");
+  text = text.replace(/<style[\s\S]*?<\/style>/gi, " ");
+  text = text.replace(/<[^>]+>/g, " ");
+  text = text.replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/&nbsp;/gi, " ");
+  text = text.replace(/\s+/g, " ").trim();
+  return text;
+}
+async function readPdf(filePath) {
+  const pdfParse = await import("pdf-parse").then((m) => m.default ?? m);
+  const buffer = await readFile4(filePath);
+  const data = await pdfParse(buffer);
+  return data.text;
+}
+function isPrivateUrl(url) {
+  try {
+    const { hostname } = new URL(url);
+    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname.startsWith("169.254.") || // link-local
+    hostname.startsWith("10.") || hostname.startsWith("192.168.") || /^172\.(1[6-9]|2\d|3[01])\./.test(hostname);
+  } catch {
+    return false;
+  }
+}
+async function fetchUrl(url) {
+  if (isPrivateUrl(url)) {
+    throw new Error(`Fetching private/localhost URLs is not allowed: ${url}`);
+  }
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch URL ${url}: HTTP ${response.status} ${response.statusText}`);
+  }
+  const html = await response.text();
+  return stripHtml(html);
+}
+async function readSource(sourcePath) {
+  const type = detectType(sourcePath);
+  if (type === "url") {
+    const content2 = await fetchUrl(sourcePath);
+    const filename2 = filenameFromUrl(sourcePath);
+    return { type, originalPath: sourcePath, content: content2, filename: filename2 };
+  }
+  if (type === "pdf") {
+    const content2 = await readPdf(sourcePath);
+    const raw2 = basename2(sourcePath);
+    const filename2 = sanitizeFilename(raw2);
+    return { type, originalPath: sourcePath, content: content2, filename: filename2 };
+  }
+  const content = await readFile4(sourcePath, "utf8");
+  const raw = basename2(sourcePath);
+  const filename = sanitizeFilename(raw);
+  return { type, originalPath: sourcePath, content, filename };
+}
+
+// src/llm.js
+function createAnthropicAdapter(model) {
+  return {
+    async complete(messages, systemPrompt) {
+      const apiKey = process.env["ANTHROPIC_API_KEY"];
+      if (!apiKey) {
+        throw new Error("ANTHROPIC_API_KEY environment variable is not set");
+      }
+      const Anthropic = await import("@anthropic-ai/sdk").then((m) => m.default ?? m);
+      const client = new Anthropic({ apiKey });
+      const response = await client.messages.create({
+        model,
+        max_tokens: 8192,
+        system: systemPrompt,
+        messages: messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        }))
+      });
+      const block = response.content[0];
+      if (!block || block.type !== "text") {
+        throw new Error("Anthropic returned no text content");
+      }
+      return block.text;
+    }
+  };
+}
+function createOpenAiAdapter(model) {
+  return {
+    async complete(messages, systemPrompt) {
+      const apiKey = process.env["OPENAI_API_KEY"];
+      if (!apiKey) {
+        throw new Error("OPENAI_API_KEY environment variable is not set");
+      }
+      const body = {
+        model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          ...messages.map((m) => ({ role: m.role, content: m.content }))
+        ]
+      };
+      const response = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`OpenAI API error: HTTP ${response.status} \u2014 ${text}`);
+      }
+      const data = await response.json();
+      const content = data.choices[0]?.message?.content;
+      if (!content) {
+        throw new Error("OpenAI returned no content");
+      }
+      return content;
+    }
+  };
+}
+function createOllamaAdapter(model) {
+  return {
+    async complete(messages, systemPrompt) {
+      const baseUrl = process.env["OLLAMA_BASE_URL"] ?? "http://localhost:11434";
+      const body = {
+        model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          ...messages.map((m) => ({ role: m.role, content: m.content }))
+        ],
+        stream: false
+      };
+      const response = await fetch(`${baseUrl}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama API error: HTTP ${response.status} \u2014 ${text}`);
+      }
+      const data = await response.json();
+      const content = data.message?.content;
+      if (!content) {
+        throw new Error("Ollama returned no content");
+      }
+      return content;
+    }
+  };
+}
+function createLlmAdapter(config) {
+  const { provider, model } = config.llm;
+  switch (provider) {
+    case "anthropic":
+      return createAnthropicAdapter(model);
+    case "openai":
+      return createOpenAiAdapter(model);
+    case "ollama":
+      return createOllamaAdapter(model);
+    default: {
+      const _exhaustive = provider;
+      throw new Error(`Unsupported LLM provider: ${String(_exhaustive)}`);
+    }
+  }
+}
+
+// src/ingest.js
+import { readFile as readFile5, writeFile as writeFile2, mkdir as mkdir2, appendFile } from "fs/promises";
+import { join as join5, dirname as dirname2, resolve as resolve2 } from "path";
+var SYSTEM_PROMPT = `You are an AI assistant maintaining a knowledge base wiki.
+You will be given a new source document and the current state of the wiki.
+Your task is to integrate the new knowledge into the wiki.
+
+Return ONLY a JSON object matching this exact schema (no markdown fences):
+{
+  "summary": { "path": "wiki/sources/<filename>-summary.md", "content": "..." },
+  "updates": [{ "path": "...", "content": "...", "reason": "..." }],
+  "newPages": [{ "path": "...", "content": "...", "reason": "..." }],
+  "indexUpdate": "...",
+  "logEntry": "..."
+}`;
+function assertWithinRoot(absPath, root) {
+  const resolvedPath = resolve2(absPath);
+  const resolvedRoot = resolve2(root) + "/";
+  if (!resolvedPath.startsWith(resolvedRoot)) {
+    throw new Error(`Unsafe path rejected: "${absPath}" is outside project root`);
+  }
+}
+async function readFileSafe(filePath) {
+  try {
+    return await readFile5(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function parseIngestResult(raw) {
+  const cleaned = raw.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/i, "").trim();
+  let parsed;
+  try {
+    parsed = JSON.parse(cleaned);
+  } catch (err) {
+    throw new Error(`Invalid LLM response: could not parse JSON. Raw response: ${cleaned.slice(0, 200)}`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Invalid LLM response: expected a JSON object");
+  }
+  const obj = parsed;
+  if (!obj["summary"] || typeof obj["summary"] !== "object" || Array.isArray(obj["summary"])) {
+    throw new Error('Invalid LLM response: missing "summary" object');
+  }
+  const summary = obj["summary"];
+  if (typeof summary["path"] !== "string" || typeof summary["content"] !== "string") {
+    throw new Error('Invalid LLM response: "summary" must have "path" and "content" strings');
+  }
+  if (!Array.isArray(obj["updates"])) {
+    throw new Error('Invalid LLM response: "updates" must be an array');
+  }
+  if (!Array.isArray(obj["newPages"])) {
+    throw new Error('Invalid LLM response: "newPages" must be an array');
+  }
+  if (typeof obj["indexUpdate"] !== "string") {
+    throw new Error('Invalid LLM response: "indexUpdate" must be a string');
+  }
+  if (typeof obj["logEntry"] !== "string") {
+    throw new Error('Invalid LLM response: "logEntry" must be a string');
+  }
+  const updates = obj["updates"].map((u, i) => {
+    if (typeof u !== "object" || u === null || Array.isArray(u)) {
+      throw new Error(`Invalid LLM response: updates[${i}] must be an object`);
+    }
+    const update = u;
+    if (typeof update["path"] !== "string" || typeof update["content"] !== "string" || typeof update["reason"] !== "string") {
+      throw new Error(`Invalid LLM response: updates[${i}] must have path, content, and reason strings`);
+    }
+    return {
+      path: update["path"],
+      content: update["content"],
+      reason: update["reason"]
+    };
+  });
+  const newPages = obj["newPages"].map((p, i) => {
+    if (typeof p !== "object" || p === null || Array.isArray(p)) {
+      throw new Error(`Invalid LLM response: newPages[${i}] must be an object`);
+    }
+    const page = p;
+    if (typeof page["path"] !== "string" || typeof page["content"] !== "string" || typeof page["reason"] !== "string") {
+      throw new Error(`Invalid LLM response: newPages[${i}] must have path, content, and reason strings`);
+    }
+    return {
+      path: page["path"],
+      content: page["content"],
+      reason: page["reason"]
+    };
+  });
+  return {
+    summary: { path: summary["path"], content: summary["content"] },
+    updates,
+    newPages,
+    indexUpdate: obj["indexUpdate"],
+    logEntry: obj["logEntry"]
+  };
+}
+async function applyIngestResult(project, result, sourceContent, sourceFilename) {
+  const summaryAbsPath = join5(project.root, result.summary.path);
+  assertWithinRoot(summaryAbsPath, project.root);
+  await mkdir2(dirname2(summaryAbsPath), { recursive: true });
+  await writeFile2(summaryAbsPath, result.summary.content, "utf8");
+  for (const update of result.updates) {
+    const absPath = join5(project.root, update.path);
+    assertWithinRoot(absPath, project.root);
+    await mkdir2(dirname2(absPath), { recursive: true });
+    await writeFile2(absPath, update.content, "utf8");
+  }
+  for (const newPage of result.newPages) {
+    const absPath = join5(project.root, newPage.path);
+    assertWithinRoot(absPath, project.root);
+    await mkdir2(dirname2(absPath), { recursive: true });
+    await writeFile2(absPath, newPage.content, "utf8");
+  }
+  const indexPath = join5(project.wikiDir, "_index.md");
+  await writeFile2(indexPath, result.indexUpdate, "utf8");
+  const sourceDestPath = join5(project.sourcesDir, sourceFilename);
+  await mkdir2(project.sourcesDir, { recursive: true });
+  await writeFile2(sourceDestPath, sourceContent, "utf8");
+  const logPath = join5(project.wikiDir, "log.md");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const logLine = `- ${timestamp}: ${result.logEntry}
+`;
+  await appendFile(logPath, logLine, "utf8");
+  await indexProject(project);
+}
+async function ingestSource(project, sourcePath, llm, options) {
+  const apply = options?.apply ?? false;
+  const sourceContent = await readSource(sourcePath);
+  const indexPath = join5(project.wikiDir, "_index.md");
+  const currentIndex = await readFileSafe(indexPath);
+  const schemaPath = join5(project.kbDir, "schema.md");
+  const schema = await readFileSafe(schemaPath);
+  const userMessage = `## Wiki Schema
+${schema}
+
+## Current Wiki Index
+${currentIndex}
+
+## New Source: ${sourceContent.filename}
+${sourceContent.content}
+
+Integrate this source into the wiki following the schema above.`;
+  const raw = await llm.complete([{ role: "user", content: userMessage }], SYSTEM_PROMPT);
+  const result = parseIngestResult(raw);
+  if (apply) {
+    await applyIngestResult(project, result, sourceContent.content, sourceContent.filename);
+  }
+  const sourceFile = join5(project.sourcesDir, sourceContent.filename);
+  return {
+    result,
+    sourceFile,
+    dryRun: !apply
+  };
+}
+
+// src/query.ts
+import { readFile as readFile6, writeFile as writeFile3, mkdir as mkdir3, appendFile as appendFile2 } from "fs/promises";
+import { existsSync } from "fs";
+import { join as join6, dirname as dirname3, resolve as resolve3 } from "path";
+var SYSTEM_PROMPT2 = `You are a knowledgeable assistant answering questions about a project's knowledge base.
+Answer concisely using only information from the provided wiki pages.
+Use [[page-name]] wikilink syntax to cite specific wiki pages in your answer.
+Format your answer in markdown.`;
+function assertWithinRoot2(absPath, root) {
+  const resolvedPath = resolve3(absPath);
+  const resolvedRoot = resolve3(root) + "/";
+  if (!resolvedPath.startsWith(resolvedRoot)) {
+    throw new Error(
+      `Unsafe path rejected: "${absPath}" is outside project root`
+    );
+  }
+}
+async function readFileSafe2(filePath) {
+  try {
+    return await readFile6(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function queryWiki(project, question, llm, options) {
+  const dbPath = join6(project.kbDir, "index.db");
+  if (!existsSync(dbPath)) {
+    await indexProject(project);
+  }
+  const db = openDb(project);
+  let searchResults;
+  try {
+    searchResults = searchWiki(db, question, project.name, { limit: 10 });
+  } finally {
+    closeDb(db);
+  }
+  const pages = [];
+  for (const result of searchResults) {
+    const absPath = join6(project.root, result.path);
+    const content = await readFileSafe2(absPath);
+    if (content) {
+      pages.push({ path: result.path, title: result.title, content });
+    }
+  }
+  const pagesSection = pages.length > 0 ? pages.map((p) => `### ${p.title} (${p.path})
+${p.content}`).join("\n\n") : "(No wiki pages found for this query.)";
+  const userMessage = `## Question
+${question}
+
+## Relevant Wiki Pages
+
+${pagesSection}`;
+  const answer = await llm.complete(
+    [{ role: "user", content: userMessage }],
+    SYSTEM_PROMPT2
+  );
+  const sources = pages.map((p) => p.path);
+  if (options?.save) {
+    const saveRelPath = options.save;
+    const saveAbsPath = join6(project.root, saveRelPath);
+    assertWithinRoot2(saveAbsPath, project.root);
+    await mkdir3(dirname3(saveAbsPath), { recursive: true });
+    await writeFile3(saveAbsPath, answer, "utf8");
+    const logPath = join6(project.wikiDir, "log.md");
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const logEntry = `
+## ${timestamp} \u2014 Queried: ${question}
+
+Saved to: ${saveRelPath}
+`;
+    await appendFile2(logPath, logEntry, "utf8");
+    await indexProject(project);
+  }
+  return { answer, sources };
+}
+
+// src/lint.ts
+import { readdir as readdir2, stat as stat2 } from "fs/promises";
+import { join as join7, relative as relative2, basename as basename3, extname as extname2 } from "path";
+async function collectMdFiles2(dir) {
+  try {
+    const entries = await readdir2(dir, {
+      recursive: true,
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => join7(e.parentPath ?? e.path, e.name));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    return [];
+  }
+}
+async function collectSourceFiles(dir) {
+  try {
+    const entries = await readdir2(dir, {
+      recursive: true,
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isFile()).map((e) => join7(e.parentPath ?? e.path, e.name));
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+    return [];
+  }
+}
+function buildPageKeySet(relPaths, projectRoot, wikiDir) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const rp of relPaths) {
+    keys.add(rp);
+    keys.add(rp.replace(/\.md$/i, ""));
+    const fname = basename3(rp, ".md");
+    keys.add(fname);
+    const absPath = join7(projectRoot, rp);
+    const relToWiki = relative2(wikiDir, absPath);
+    keys.add(relToWiki);
+    keys.add(relToWiki.replace(/\.md$/i, ""));
+  }
+  return keys;
+}
+async function lintProject(project) {
+  await indexProject(project);
+  const issues = [];
+  const absWikiFiles = await collectMdFiles2(project.wikiDir);
+  const relWikiPaths = absWikiFiles.map((f) => relative2(project.root, f));
+  const pagesChecked = relWikiPaths.length;
+  const sourceFiles = await collectSourceFiles(project.sourcesDir);
+  const sourcesChecked = sourceFiles.filter(
+    (f) => basename3(f) !== ".gitkeep"
+  ).length;
+  if (pagesChecked === 0) {
+    return { issues, pagesChecked: 0, sourcesChecked };
+  }
+  const pageKeySet = buildPageKeySet(
+    relWikiPaths,
+    project.root,
+    project.wikiDir
+  );
+  const db = openDb(project);
+  let rows;
+  try {
+    rows = db.prepare("SELECT path, outgoing_links, word_count, mtime, updated_at FROM page_meta").all();
+  } finally {
+    closeDb(db);
+  }
+  const metaMap = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    metaMap.set(row.path, row);
+  }
+  const inboundLinks = /* @__PURE__ */ new Map();
+  for (const rp of relWikiPaths) {
+    inboundLinks.set(rp, /* @__PURE__ */ new Set());
+  }
+  for (const row of rows) {
+    let links = [];
+    try {
+      links = JSON.parse(row.outgoing_links);
+    } catch {
+      links = [];
+    }
+    for (const link of links) {
+      const resolved = resolveLink(
+        link,
+        relWikiPaths,
+        project.root,
+        project.wikiDir
+      );
+      if (resolved !== null) {
+        const set = inboundLinks.get(resolved);
+        if (set) {
+          set.add(row.path);
+        }
+      }
+    }
+  }
+  const indexPath = relWikiPaths.find((p) => basename3(p) === "_index.md");
+  let indexLinks = /* @__PURE__ */ new Set();
+  if (indexPath) {
+    const indexRow = metaMap.get(indexPath);
+    if (indexRow) {
+      let links = [];
+      try {
+        links = JSON.parse(indexRow.outgoing_links);
+      } catch {
+        links = [];
+      }
+      for (const link of links) {
+        const resolved = resolveLink(
+          link,
+          relWikiPaths,
+          project.root,
+          project.wikiDir
+        );
+        if (resolved !== null) {
+          indexLinks.add(resolved);
+        }
+      }
+    }
+  }
+  for (const rp of relWikiPaths) {
+    if (basename3(rp) === "_index.md") continue;
+    const inbound = inboundLinks.get(rp);
+    if (!inbound || inbound.size === 0) {
+      issues.push({
+        severity: "warning",
+        code: "ORPHAN_PAGE",
+        path: rp,
+        message: "Orphan page (no inbound links)"
+      });
+    }
+  }
+  for (const row of rows) {
+    let links = [];
+    try {
+      links = JSON.parse(row.outgoing_links);
+    } catch {
+      links = [];
+    }
+    for (const link of links) {
+      if (!isLinkResolvable(link, pageKeySet)) {
+        issues.push({
+          severity: "warning",
+          code: "BROKEN_LINK",
+          path: row.path,
+          message: `Broken wikilink [[${link}]] not found`,
+          detail: link
+        });
+      }
+    }
+  }
+  for (const row of rows) {
+    if (basename3(row.path) === "_index.md") continue;
+    let links = [];
+    try {
+      links = JSON.parse(row.outgoing_links);
+    } catch {
+      links = [];
+    }
+    if (links.length === 0 && row.word_count < 50) {
+      issues.push({
+        severity: "info",
+        code: "STUB_PAGE",
+        path: row.path,
+        message: `Stub page (no links, < 50 words)`
+      });
+    }
+  }
+  const wikiSourcesDir = join7(project.wikiDir, "sources");
+  for (const rp of relWikiPaths) {
+    const absWikiPage = join7(project.root, rp);
+    const relToWikiSources = relative2(wikiSourcesDir, absWikiPage);
+    if (relToWikiSources.startsWith("..")) continue;
+    const summaryBasename = basename3(rp, ".md");
+    const sourceBasename = summaryBasename.endsWith("-summary") ? summaryBasename.slice(0, -"-summary".length) : summaryBasename;
+    const matchingSource = sourceFiles.find((sf) => {
+      const sfBase = basename3(sf, extname2(sf));
+      return sfBase === sourceBasename;
+    });
+    if (!matchingSource) continue;
+    try {
+      const summaryRow = metaMap.get(rp);
+      if (!summaryRow) continue;
+      const [sourceStat, summaryStat] = await Promise.all([
+        stat2(matchingSource),
+        stat2(join7(project.root, summaryRow.path))
+      ]);
+      if (sourceStat.mtimeMs > summaryStat.mtimeMs) {
+        issues.push({
+          severity: "warning",
+          code: "STALE_SUMMARY",
+          path: rp,
+          message: "Source updated after summary",
+          detail: relative2(project.root, matchingSource)
+        });
+      }
+    } catch {
+    }
+  }
+  for (const rp of relWikiPaths) {
+    if (basename3(rp) === "_index.md") continue;
+    if (!indexPath) {
+      continue;
+    }
+    if (!indexLinks.has(rp)) {
+      const fname = basename3(rp, ".md");
+      if (!indexLinks.has(fname)) {
+        issues.push({
+          severity: "info",
+          code: "MISSING_INDEX",
+          path: rp,
+          message: "Not in _index.md"
+        });
+      }
+    }
+  }
+  return { issues, pagesChecked, sourcesChecked };
+}
+function resolveLink(link, relPaths, projectRoot, wikiDir) {
+  for (const rp of relPaths) {
+    const fname = basename3(rp, ".md");
+    if (fname === link) return rp;
+    if (rp === link || rp === `${link}.md`) return rp;
+    const absPath = join7(projectRoot, rp);
+    const relToWiki = relative2(wikiDir, absPath);
+    if (relToWiki === link || relToWiki.replace(/\.md$/i, "") === link) {
+      return rp;
+    }
+  }
+  return null;
+}
+function isLinkResolvable(link, pageKeySet) {
+  return pageKeySet.has(link);
+}
+
+// src/log-parser.ts
+function parseLogEntries(content) {
+  const entries = [];
+  const sections = content.split(/^(?=## )/m);
+  for (const section of sections) {
+    const trimmed = section.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith("# ")) continue;
+    if (!trimmed.startsWith("## ")) continue;
+    const newlineIdx = trimmed.indexOf("\n");
+    if (newlineIdx === -1) {
+      entries.push({ heading: trimmed.slice(3).trim(), body: "" });
+    } else {
+      const heading = trimmed.slice(3, newlineIdx).trim();
+      const body = trimmed.slice(newlineIdx + 1).trim();
+      entries.push({ heading, body });
+    }
+  }
+  return entries;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  VERSION,
+  closeDb,
+  createLlmAdapter,
+  indexProject,
+  ingestSource,
+  initProject,
+  lintProject,
+  loadProject,
+  openDb,
+  parseConfig,
+  parseLogEntries,
+  parsePage,
+  queryWiki,
+  readSource,
+  searchWiki,
+  tryLoadProject
+};
+//# sourceMappingURL=index.js.map