llm-wiki-mcp 0.1.0

package/dist/server.js

@@ -0,0 +1,895 @@
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/server";
+
+// src/config/schema-loader.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import yaml from "js-yaml";
+
+// src/config/types.ts
+var DEFAULT_SCHEMA = {
+  name: "My Wiki",
+  version: 1,
+  linkStyle: "wikilink",
+  paths: {
+    raw: "raw",
+    wiki: "wiki",
+    assets: "raw/assets"
+  },
+  pageTypes: {
+    source: {
+      description: "Summary of a raw source document",
+      requiredFields: ["title", "type", "source_path", "created"]
+    },
+    concept: {
+      description: "A concept or idea",
+      requiredFields: ["title", "type", "tags", "created"]
+    },
+    entity: {
+      description: "A person, organization, or thing",
+      requiredFields: ["title", "type", "tags", "created"]
+    },
+    comparison: {
+      description: "Comparison between concepts/entities",
+      requiredFields: ["title", "type", "subjects", "created"]
+    }
+  },
+  tags: {
+    required: false,
+    suggested: []
+  },
+  log: {
+    prefix: "## [{date}] {operation} | {title}"
+  }
+};
+
+// src/config/schema-loader.ts
+function loadSchema(vaultPath) {
+  const configPath = join(vaultPath, ".wiki-schema.yaml");
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_SCHEMA };
+  }
+  const raw = readFileSync(configPath, "utf-8");
+  const parsed = yaml.load(raw);
+  if (parsed.linkStyle && parsed.linkStyle !== "wikilink" && parsed.linkStyle !== "markdown") {
+    throw new Error(
+      `Invalid linkStyle: "${parsed.linkStyle}". Must be "wikilink" or "markdown".`
+    );
+  }
+  return {
+    name: parsed.name ?? DEFAULT_SCHEMA.name,
+    version: parsed.version ?? DEFAULT_SCHEMA.version,
+    linkStyle: parsed.linkStyle ?? DEFAULT_SCHEMA.linkStyle,
+    paths: {
+      ...DEFAULT_SCHEMA.paths,
+      ...parsed.paths
+    },
+    pageTypes: parsed.pageTypes ?? DEFAULT_SCHEMA.pageTypes,
+    tags: {
+      ...DEFAULT_SCHEMA.tags,
+      ...parsed.tags
+    },
+    log: {
+      ...DEFAULT_SCHEMA.log,
+      ...parsed.log
+    }
+  };
+}
+
+// src/core/link-resolver.ts
+var WIKILINK_REGEX = /\[\[([^\]|]+)(?:\|([^\]]+))?\]\]/g;
+var MDLINK_REGEX = /\[([^\]]+)\]\(([^)]+)\)/g;
+var LinkResolver = class {
+  constructor(linkStyle, wikiDir) {
+    this.linkStyle = linkStyle;
+    this.wikiDir = wikiDir;
+  }
+  linkStyle;
+  wikiDir;
+  slugify(title) {
+    return title.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  createLink(targetTitle, displayText) {
+    if (this.linkStyle === "wikilink") {
+      if (displayText) {
+        return `[[${targetTitle}|${displayText}]]`;
+      }
+      return `[[${targetTitle}]]`;
+    }
+    const slug = this.slugify(targetTitle);
+    const path = `${this.wikiDir}/${slug}.md`;
+    const text = displayText ?? targetTitle;
+    return `[${text}](${path})`;
+  }
+  parseLinks(content) {
+    const links = [];
+    if (this.linkStyle === "wikilink") {
+      let match;
+      const regex = new RegExp(WIKILINK_REGEX.source, "g");
+      while ((match = regex.exec(content)) !== null) {
+        links.push({
+          raw: match[0],
+          target: match[1],
+          displayText: match[2] ?? void 0
+        });
+      }
+    } else {
+      let match;
+      const regex = new RegExp(MDLINK_REGEX.source, "g");
+      while ((match = regex.exec(content)) !== null) {
+        links.push({
+          raw: match[0],
+          target: match[1],
+          displayText: void 0
+        });
+      }
+    }
+    return links;
+  }
+};
+
+// src/core/log-manager.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, appendFileSync } from "fs";
+import { join as join2 } from "path";
+var LOG_HEADER = "# Wiki Log\n";
+var ENTRY_REGEX = /^## \[(\d{4}-\d{2}-\d{2})\] (\w+) \| (.+)$/;
+var LogManager = class {
+  logPath;
+  constructor(vaultPath) {
+    this.logPath = join2(vaultPath, "log.md");
+  }
+  async append(entry) {
+    if (!existsSync2(this.logPath)) {
+      writeFileSync(this.logPath, LOG_HEADER + "\n", "utf-8");
+    }
+    let block = `
+## [${entry.date}] ${entry.operation} | ${entry.title}
+`;
+    if (entry.details) {
+      block += `${entry.details}
+`;
+    }
+    appendFileSync(this.logPath, block, "utf-8");
+  }
+  async read(filter) {
+    if (!existsSync2(this.logPath)) {
+      return [];
+    }
+    const content = readFileSync2(this.logPath, "utf-8");
+    const lines = content.split("\n");
+    const entries = [];
+    let current = null;
+    const detailLines = [];
+    const flushCurrent = () => {
+      if (current) {
+        if (detailLines.length > 0) {
+          current.details = detailLines.join("\n").trim() || void 0;
+        }
+        entries.push(current);
+        detailLines.length = 0;
+      }
+    };
+    for (const line of lines) {
+      const match = line.match(ENTRY_REGEX);
+      if (match) {
+        flushCurrent();
+        current = {
+          date: match[1],
+          operation: match[2],
+          title: match[3]
+        };
+      } else if (current && line.trim() !== "" && !line.startsWith("# ")) {
+        detailLines.push(line);
+      }
+    }
+    flushCurrent();
+    let result = entries;
+    if (filter?.operation) {
+      result = result.filter((e) => e.operation === filter.operation);
+    }
+    if (filter?.since) {
+      result = result.filter((e) => e.date >= filter.since);
+    }
+    if (filter?.limit) {
+      result = result.slice(-filter.limit);
+    }
+    return result;
+  }
+};
+
+// src/core/index-manager.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+var INDEX_HEADER = "# Wiki Index\n";
+var CATEGORY_MAP = {
+  source: "Sources",
+  concept: "Concepts",
+  entity: "Entities",
+  comparison: "Comparisons"
+};
+var IndexManager = class {
+  constructor(vaultPath, linkResolver) {
+    this.linkResolver = linkResolver;
+    this.indexPath = join3(vaultPath, "index.md");
+  }
+  linkResolver;
+  indexPath;
+  async addEntry(entry) {
+    const stored = this.load();
+    stored.entries.push(entry);
+    this.save(stored);
+  }
+  async removeEntry(path) {
+    const stored = this.load();
+    stored.entries = stored.entries.filter((e) => e.path !== path);
+    this.save(stored);
+  }
+  async read() {
+    return this.load().entries;
+  }
+  async rebuild(entries) {
+    this.save({ entries });
+  }
+  load() {
+    if (!existsSync3(this.indexPath)) {
+      return { entries: [] };
+    }
+    const content = readFileSync3(this.indexPath, "utf-8");
+    const entries = [];
+    const pathCommentRegex = /<!--\s*path:\s*([^>]+?)\s*-->/;
+    const summaryRegex = /^- .+? — (.+?)(?:\s*<!--.*-->)?$/;
+    const wikilinkRegex = /\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/;
+    const mdlinkRegex = /\[([^\]]+)\]\(([^)]+)\)/;
+    let currentType = "";
+    const categoryToType = {};
+    for (const [type, category] of Object.entries(CATEGORY_MAP)) {
+      categoryToType[category] = type;
+    }
+    for (const line of content.split("\n")) {
+      if (line.startsWith("## ")) {
+        const category = line.slice(3).trim();
+        currentType = categoryToType[category] ?? "other";
+        continue;
+      }
+      if (!line.startsWith("- ")) continue;
+      const summaryMatch = line.match(summaryRegex);
+      const summary = summaryMatch?.[1]?.trim() ?? "";
+      const pathMatch = line.match(pathCommentRegex);
+      const storedPath = pathMatch?.[1] ?? "";
+      const wikiMatch = line.match(wikilinkRegex);
+      const mdMatch = line.match(mdlinkRegex);
+      if (wikiMatch) {
+        entries.push({
+          title: wikiMatch[1],
+          path: storedPath,
+          pageType: currentType,
+          summary
+        });
+      } else if (mdMatch) {
+        entries.push({
+          title: mdMatch[1],
+          path: storedPath || mdMatch[2],
+          pageType: currentType,
+          summary
+        });
+      }
+    }
+    return { entries };
+  }
+  save(stored) {
+    const grouped = {};
+    for (const entry of stored.entries) {
+      const category = CATEGORY_MAP[entry.pageType] ?? "Other";
+      if (!grouped[category]) {
+        grouped[category] = [];
+      }
+      grouped[category].push(entry);
+    }
+    let content = INDEX_HEADER;
+    const orderedCategories = [
+      "Sources",
+      "Concepts",
+      "Entities",
+      "Comparisons",
+      "Other"
+    ];
+    for (const category of orderedCategories) {
+      const entries = grouped[category];
+      if (!entries || entries.length === 0) continue;
+      content += `
+## ${category}
+
+`;
+      for (const entry of entries) {
+        const link = this.linkResolver.createLink(entry.title);
+        content += `- ${link} \u2014 ${entry.summary} <!-- path: ${entry.path} -->
+`;
+      }
+    }
+    writeFileSync2(this.indexPath, content, "utf-8");
+  }
+};
+
+// src/core/wiki-manager.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4, unlinkSync, readdirSync } from "fs";
+import { join as join4 } from "path";
+import matter from "gray-matter";
+var WikiManager = class {
+  constructor(vaultPath, schema, linkResolver, indexManager, logManager) {
+    this.vaultPath = vaultPath;
+    this.schema = schema;
+    this.linkResolver = linkResolver;
+    this.indexManager = indexManager;
+    this.logManager = logManager;
+    this.wikiAbsDir = join4(vaultPath, schema.paths.wiki);
+  }
+  vaultPath;
+  schema;
+  linkResolver;
+  indexManager;
+  logManager;
+  wikiAbsDir;
+  async createPage(title, content, pageType) {
+    const slug = this.linkResolver.slugify(title);
+    const relativePath = `${this.schema.paths.wiki}/${slug}.md`;
+    const absPath = join4(this.vaultPath, relativePath);
+    if (existsSync4(absPath)) {
+      return { success: false, path: relativePath, message: `Page already exists: ${relativePath}` };
+    }
+    writeFileSync3(absPath, content, "utf-8");
+    const parsed = matter(content);
+    const summary = this.extractSummary(parsed.content);
+    await this.indexManager.addEntry({
+      title,
+      path: relativePath,
+      pageType: pageType ?? parsed.data.type ?? "other",
+      summary
+    });
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    await this.logManager.append({
+      date: today,
+      operation: "create",
+      title,
+      details: `Created: ${relativePath}`
+    });
+    return { success: true, path: relativePath, message: `Created: ${relativePath}` };
+  }
+  async readPage(lookup) {
+    let absPath;
+    let relativePath;
+    if (lookup.path) {
+      relativePath = lookup.path;
+      absPath = join4(this.vaultPath, relativePath);
+    } else if (lookup.title) {
+      const slug = this.linkResolver.slugify(lookup.title);
+      relativePath = `${this.schema.paths.wiki}/${slug}.md`;
+      absPath = join4(this.vaultPath, relativePath);
+    } else {
+      throw new Error("Either title or path must be provided");
+    }
+    if (!existsSync4(absPath)) {
+      throw new Error(`Page not found: ${relativePath}`);
+    }
+    const raw = readFileSync4(absPath, "utf-8");
+    const parsed = matter(raw);
+    return {
+      content: raw,
+      frontmatter: parsed.data,
+      path: relativePath
+    };
+  }
+  async updatePage(path, content) {
+    const absPath = join4(this.vaultPath, path);
+    if (!existsSync4(absPath)) {
+      return { success: false, path, message: `Page not found: ${path}` };
+    }
+    writeFileSync3(absPath, content, "utf-8");
+    const parsed = matter(content);
+    const title = parsed.data.title ?? path;
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    await this.logManager.append({
+      date: today,
+      operation: "update",
+      title,
+      details: `Updated: ${path}`
+    });
+    return { success: true, path, message: `Updated: ${path}` };
+  }
+  async deletePage(path) {
+    const absPath = join4(this.vaultPath, path);
+    if (!existsSync4(absPath)) {
+      return { success: false, message: `Page not found: ${path}`, brokenLinks: [] };
+    }
+    const raw = readFileSync4(absPath, "utf-8");
+    const parsed = matter(raw);
+    const title = parsed.data.title ?? path;
+    const brokenLinks = this.findBacklinks(title);
+    unlinkSync(absPath);
+    await this.indexManager.removeEntry(path);
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    await this.logManager.append({
+      date: today,
+      operation: "delete",
+      title,
+      details: `Deleted: ${path}. Broken links in: ${brokenLinks.join(", ") || "none"}`
+    });
+    return { success: true, message: `Deleted: ${path}`, brokenLinks };
+  }
+  findBacklinks(title) {
+    const backlinks = [];
+    const files = this.listWikiFiles();
+    for (const file of files) {
+      const absPath = join4(this.vaultPath, file);
+      const content = readFileSync4(absPath, "utf-8");
+      const links = this.linkResolver.parseLinks(content);
+      if (links.some((l) => l.target === title)) {
+        backlinks.push(file);
+      }
+    }
+    return backlinks;
+  }
+  listWikiFiles() {
+    if (!existsSync4(this.wikiAbsDir)) return [];
+    return readdirSync(this.wikiAbsDir).filter((f) => f.endsWith(".md")).map((f) => `${this.schema.paths.wiki}/${f}`);
+  }
+  extractSummary(content) {
+    const lines = content.trim().split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith("#")) {
+        return trimmed.slice(0, 120);
+      }
+    }
+    return "";
+  }
+};
+
+// src/search/qmd-provider.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var QmdProvider = class {
+  name = "qmd";
+  async available() {
+    try {
+      await execFileAsync("which", ["qmd"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async index(wikiDir) {
+    try {
+      await execFileAsync("qmd", ["index", "--dir", wikiDir]);
+    } catch (err) {
+      throw new Error(`qmd index failed: ${err}`);
+    }
+  }
+  async search(query, options) {
+    const { maxResults, wikiDir } = options;
+    try {
+      const { stdout } = await execFileAsync("qmd", [
+        "search",
+        query,
+        "--dir",
+        wikiDir,
+        "--limit",
+        String(maxResults),
+        "--json"
+      ]);
+      const parsed = JSON.parse(stdout);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.map((item) => ({
+        path: String(item.path ?? ""),
+        title: String(item.title ?? ""),
+        snippet: String(item.snippet ?? item.content ?? ""),
+        score: Number(item.score ?? 0)
+      }));
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/search/simple-provider.ts
+import { readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+import matter2 from "gray-matter";
+var SimpleProvider = class {
+  name = "simple";
+  async available() {
+    return true;
+  }
+  async index() {
+  }
+  async search(query, options) {
+    const { maxResults, wikiDir } = options;
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0) return [];
+    const files = readdirSync2(wikiDir).filter((f) => f.endsWith(".md"));
+    const scored = [];
+    for (const file of files) {
+      const absPath = join5(wikiDir, file);
+      const raw = readFileSync5(absPath, "utf-8");
+      const parsed = matter2(raw);
+      const title = parsed.data.title ?? file.replace(".md", "");
+      const body = parsed.content.toLowerCase();
+      const titleLower = title.toLowerCase();
+      let score = 0;
+      let matchedSnippet = "";
+      for (const term of terms) {
+        if (titleLower.includes(term)) {
+          score += 3;
+        }
+        const bodyMatches = body.split(term).length - 1;
+        score += bodyMatches;
+        if (!matchedSnippet && bodyMatches > 0) {
+          const idx = body.indexOf(term);
+          const start = Math.max(0, idx - 50);
+          const end = Math.min(body.length, idx + term.length + 100);
+          matchedSnippet = parsed.content.slice(start, end).trim();
+        }
+      }
+      if (score > 0) {
+        scored.push({
+          path: file,
+          title,
+          snippet: matchedSnippet,
+          score: Math.min(score / (terms.length * 5), 1)
+        });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, maxResults);
+  }
+};
+
+// src/search/detect.ts
+async function detectSearchProvider() {
+  const qmd = new QmdProvider();
+  if (await qmd.available()) {
+    return qmd;
+  }
+  return new SimpleProvider();
+}
+
+// src/tools/index.ts
+import { z } from "zod";
+
+// src/tools/init.ts
+import { mkdirSync, writeFileSync as writeFileSync4, existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+import yaml2 from "js-yaml";
+async function handleInit(input) {
+  const { path: vaultPath, name, linkStyle } = input;
+  const schemaPath = join6(vaultPath, ".wiki-schema.yaml");
+  if (existsSync5(schemaPath)) {
+    return {
+      success: true,
+      message: "Vault already initialized \u2014 skipping without overwrite.",
+      created: []
+    };
+  }
+  const schema = {
+    ...DEFAULT_SCHEMA,
+    name: name ?? DEFAULT_SCHEMA.name,
+    linkStyle: linkStyle ?? DEFAULT_SCHEMA.linkStyle
+  };
+  const created = [];
+  const dirs = [schema.paths.raw, schema.paths.assets, schema.paths.wiki];
+  for (const dir of dirs) {
+    const absDir = join6(vaultPath, dir);
+    if (!existsSync5(absDir)) {
+      mkdirSync(absDir, { recursive: true });
+      created.push(dir + "/");
+    }
+  }
+  const yamlContent = yaml2.dump(schema, { lineWidth: -1 });
+  writeFileSync4(schemaPath, yamlContent, "utf-8");
+  created.push(".wiki-schema.yaml");
+  const indexPath = join6(vaultPath, "index.md");
+  if (!existsSync5(indexPath)) {
+    writeFileSync4(indexPath, "# Wiki Index\n", "utf-8");
+    created.push("index.md");
+  }
+  const logPath = join6(vaultPath, "log.md");
+  if (!existsSync5(logPath)) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const logContent = `# Wiki Log
+
+## [${today}] init | ${schema.name}
+Vault initialized.
+`;
+    writeFileSync4(logPath, logContent, "utf-8");
+    created.push("log.md");
+  }
+  return {
+    success: true,
+    message: `Vault initialized at ${vaultPath}`,
+    created
+  };
+}
+
+// src/tools/create-page.ts
+async function handleCreatePage(input, wikiManager) {
+  return wikiManager.createPage(input.title, input.content, input.pageType);
+}
+
+// src/tools/read-page.ts
+async function handleReadPage(input, wikiManager) {
+  return wikiManager.readPage(input);
+}
+
+// src/tools/update-page.ts
+async function handleUpdatePage(input, wikiManager) {
+  return wikiManager.updatePage(input.path, input.content);
+}
+
+// src/tools/delete-page.ts
+async function handleDeletePage(input, wikiManager) {
+  return wikiManager.deletePage(input.path);
+}
+
+// src/tools/ingest.ts
+import { readFileSync as readFileSync6, existsSync as existsSync6, readdirSync as readdirSync3 } from "fs";
+import { join as join7 } from "path";
+async function handleIngest(input, vaultPath, schema) {
+  const absPath = join7(vaultPath, input.source_path);
+  if (!existsSync6(absPath)) {
+    throw new Error(`Source not found: ${input.source_path}`);
+  }
+  const content = readFileSync6(absPath, "utf-8");
+  const wikiDir = join7(vaultPath, schema.paths.wiki);
+  let existingPages = [];
+  if (existsSync6(wikiDir)) {
+    existingPages = readdirSync3(wikiDir).filter((f) => f.endsWith(".md")).map((f) => `${schema.paths.wiki}/${f}`);
+  }
+  return {
+    content,
+    existing_pages: existingPages,
+    schema: {
+      pageTypes: schema.pageTypes,
+      linkStyle: schema.linkStyle
+    }
+  };
+}
+
+// src/tools/search.ts
+async function handleSearch(input, searchProvider, wikiDir) {
+  const maxResults = input.max_results ?? 10;
+  const results = await searchProvider.search(input.query, {
+    maxResults,
+    wikiDir
+  });
+  return { results };
+}
+
+// src/tools/lint.ts
+import { readdirSync as readdirSync4, readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
+import { join as join8 } from "path";
+import matter3 from "gray-matter";
+async function handleLint(input, vaultPath, schema, linkResolver) {
+  const wikiDir = join8(vaultPath, schema.paths.wiki);
+  if (!existsSync7(wikiDir)) {
+    return {
+      orphan_pages: [],
+      broken_links: [],
+      missing_pages: [],
+      pages_without_frontmatter: [],
+      stale_index_entries: []
+    };
+  }
+  const files = readdirSync4(wikiDir).filter((f) => f.endsWith(".md")).map((f) => `${schema.paths.wiki}/${f}`);
+  const titleToPath = /* @__PURE__ */ new Map();
+  const pathToTitle = /* @__PURE__ */ new Map();
+  const inboundLinks = /* @__PURE__ */ new Set();
+  const brokenLinks = [];
+  const pagesWithoutFrontmatter = [];
+  for (const file of files) {
+    const absPath = join8(vaultPath, file);
+    const raw = readFileSync7(absPath, "utf-8");
+    const parsed = matter3(raw);
+    const title = parsed.data.title ?? file.replace(/.*\//, "").replace(".md", "");
+    titleToPath.set(title, file);
+    pathToTitle.set(file, title);
+    if (Object.keys(parsed.data).length === 0) {
+      pagesWithoutFrontmatter.push(file);
+    }
+    const links = linkResolver.parseLinks(raw);
+    for (const link of links) {
+      inboundLinks.add(link.target);
+    }
+  }
+  const orphanPages = [];
+  const missingPagesSet = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const title = pathToTitle.get(file);
+    if (!inboundLinks.has(title)) {
+      orphanPages.push(file);
+    }
+  }
+  for (const file of files) {
+    const absPath = join8(vaultPath, file);
+    const raw = readFileSync7(absPath, "utf-8");
+    const links = linkResolver.parseLinks(raw);
+    for (const link of links) {
+      if (!titleToPath.has(link.target)) {
+        brokenLinks.push({ from: file, to: link.target });
+        missingPagesSet.add(link.target);
+      }
+    }
+  }
+  const staleIndexEntries = [];
+  const indexPath = join8(vaultPath, "index.md");
+  if (existsSync7(indexPath)) {
+    const indexContent = readFileSync7(indexPath, "utf-8");
+    const indexLinks = linkResolver.parseLinks(indexContent);
+    for (const link of indexLinks) {
+      if (!titleToPath.has(link.target)) {
+        staleIndexEntries.push(link.target);
+      }
+    }
+  }
+  return {
+    orphan_pages: orphanPages,
+    broken_links: brokenLinks,
+    missing_pages: Array.from(missingPagesSet),
+    pages_without_frontmatter: pagesWithoutFrontmatter,
+    stale_index_entries: staleIndexEntries
+  };
+}
+
+// src/tools/index.ts
+function registerTools(server, services) {
+  const { wikiManager, linkResolver, searchProvider, schema, vaultPath } = services;
+  const wikiDir = `${vaultPath}/${schema.paths.wiki}`;
+  server.registerTool(
+    "wiki_init",
+    {
+      title: "Initialize Wiki Vault",
+      description: "Create a new wiki vault with folder structure and default config",
+      inputSchema: z.object({
+        path: z.string().describe("Absolute path for the new vault"),
+        name: z.string().optional().describe("Wiki name"),
+        linkStyle: z.enum(["wikilink", "markdown"]).optional().describe("Link format")
+      })
+    },
+    async ({ path, name, linkStyle }) => {
+      const result = await handleInit({ path, name, linkStyle });
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "wiki_ingest",
+    {
+      title: "Ingest Source",
+      description: "Read a raw source document and return its content with context for wiki processing",
+      inputSchema: z.object({
+        source_path: z.string().describe("Path to source file relative to vault root, e.g. raw/article.md")
+      })
+    },
+    async ({ source_path }) => {
+      const result = await handleIngest({ source_path }, vaultPath, schema);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "wiki_create_page",
+    {
+      title: "Create Wiki Page",
+      description: "Create a new wiki page with title, content (including frontmatter), and optional page type",
+      inputSchema: z.object({
+        title: z.string().describe("Page title"),
+        content: z.string().describe("Full markdown content including YAML frontmatter"),
+        pageType: z.string().optional().describe("Page type: source, concept, entity, or comparison")
+      })
+    },
+    async ({ title, content, pageType }) => {
+      const result = await handleCreatePage({ title, content, pageType }, wikiManager);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "wiki_read_page",
+    {
+      title: "Read Wiki Page",
+      description: "Read a wiki page by title or path",
+      inputSchema: z.object({
+        title: z.string().optional().describe("Page title to look up"),
+        path: z.string().optional().describe("Direct path to the page, e.g. wiki/page.md")
+      })
+    },
+    async ({ title, path }) => {
+      try {
+        const result = await handleReadPage({ title, path }, wikiManager);
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error: ${err.message}` }], isError: true };
+      }
+    }
+  );
+  server.registerTool(
+    "wiki_update_page",
+    {
+      title: "Update Wiki Page",
+      description: "Update an existing wiki page with new content",
+      inputSchema: z.object({
+        path: z.string().describe("Path to the page, e.g. wiki/page.md"),
+        content: z.string().describe("Full new markdown content including frontmatter")
+      })
+    },
+    async ({ path, content }) => {
+      const result = await handleUpdatePage({ path, content }, wikiManager);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "wiki_delete_page",
+    {
+      title: "Delete Wiki Page",
+      description: "Delete a wiki page and report any broken links",
+      inputSchema: z.object({
+        path: z.string().describe("Path to the page to delete, e.g. wiki/page.md")
+      })
+    },
+    async ({ path }) => {
+      const result = await handleDeletePage({ path }, wikiManager);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "wiki_search",
+    {
+      title: "Search Wiki",
+      description: "Search across wiki pages using text or semantic search",
+      inputSchema: z.object({
+        query: z.string().describe("Search query"),
+        max_results: z.number().optional().describe("Maximum results to return (default: 10)")
+      })
+    },
+    async ({ query, max_results }) => {
+      const result = await handleSearch({ query, max_results }, searchProvider, wikiDir);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "wiki_lint",
+    {
+      title: "Lint Wiki",
+      description: "Health-check the wiki: find orphan pages, broken links, missing frontmatter, stale index entries",
+      inputSchema: z.object({
+        scope: z.enum(["full", "recent"]).optional().describe("Scan scope: full or recent")
+      })
+    },
+    async ({ scope }) => {
+      const result = await handleLint({ scope }, vaultPath, schema, linkResolver);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+  );
+}
+
+// src/server.ts
+async function createServer(config) {
+  const { vaultPath } = config;
+  const schema = loadSchema(vaultPath);
+  const linkResolver = new LinkResolver(schema.linkStyle, schema.paths.wiki);
+  const logManager = new LogManager(vaultPath);
+  const indexManager = new IndexManager(vaultPath, linkResolver);
+  const wikiManager = new WikiManager(vaultPath, schema, linkResolver, indexManager, logManager);
+  const searchProvider = await detectSearchProvider();
+  const server = new McpServer({
+    name: "llm-wiki-mcp",
+    version: "0.1.0"
+  });
+  registerTools(server, {
+    wikiManager,
+    linkResolver,
+    searchProvider,
+    schema,
+    vaultPath
+  });
+  return server;
+}
+export {
+  createServer
+};