codebase-wiki 0.1.0

package/dist/chunks/config.mjs

@@ -0,0 +1,174 @@
+import pino from 'pino';
+import { promises } from 'node:fs';
+import path__default from 'node:path';
+import 'node:os';
+
+const level = process.env.CODEWIKI_LOG ?? (process.env.NODE_ENV === "test" ? "silent" : "info");
+const log = pino({
+  level,
+  base: { name: "code-wiki" },
+  timestamp: pino.stdTimeFunctions.isoTime
+});
+const child = (bindings) => log.child(bindings);
+
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+async function exists(filePath) {
+  try {
+    await promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readText(filePath) {
+  return promises.readFile(filePath, "utf8");
+}
+async function readJson(filePath) {
+  try {
+    const text = await readText(filePath);
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function writeText(filePath, content) {
+  const dir = path__default.dirname(filePath);
+  await promises.mkdir(dir, { recursive: true });
+  await promises.writeFile(filePath, content, "utf8");
+}
+async function writeJson(filePath, value) {
+  const text = JSON.stringify(value, null, 2) + "\n";
+  await writeText(filePath, text);
+}
+async function atomicWriteText(target, content) {
+  const dir = path__default.dirname(target);
+  await promises.mkdir(dir, { recursive: true });
+  const tmp = path__default.join(dir, `.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`);
+  await promises.writeFile(tmp, content, "utf8");
+  await promises.rename(tmp, target);
+}
+function repoRel(absolute, root) {
+  const rel = path__default.relative(root, absolute);
+  return toPosix(rel).replace(/^\.\//, "");
+}
+
+const DEFAULT_CONFIG = {
+  outDir: ".codewiki",
+  sourceRoots: ["."],
+  ignore: [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+    "**/.turbo/**",
+    "**/coverage/**",
+    "**/target/**",
+    "**/__pycache__/**",
+    "**/.venv/**",
+    "**/venv/**",
+    "**/*.min.js",
+    "**/*.lock",
+    "**/package-lock.json",
+    "**/yarn.lock",
+    "**/pnpm-lock.yaml",
+    "**/Cargo.lock",
+    "**/*.wasm"
+  ],
+  includeExtensions: [],
+  modules: {
+    rule: "by-directory",
+    alias: {},
+    ignore: ["_tests", "_root"]
+  },
+  nudge: {
+    enabled: true,
+    ttlSeconds: 300,
+    minFileLines: 30,
+    blockOnFirstRead: false,
+    scope: "all"
+  },
+  enrichment: {
+    enabled: false,
+    concurrency: 4,
+    fileModel: "claude-haiku-4-5",
+    moduleModel: "claude-sonnet-4-5"
+  },
+  budgets: {
+    file: 600,
+    symbol: 150,
+    module: 800,
+    architecture: 1200,
+    mermaidNodes: 30
+  }
+};
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeConfig(base, override) {
+  if (!isPlainObject(override)) return base;
+  const merged = JSON.parse(JSON.stringify(base));
+  for (const [k, v] of Object.entries(override)) {
+    if (k in merged) {
+      merged[k] = isPlainObject(v) && isPlainObject(merged[k]) ? mergeConfig(merged[k], v) : v;
+    }
+  }
+  return merged;
+}
+async function loadConfig(cwd, configPath) {
+  let config = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+  if (configPath) {
+    const override = await readJson(configPath);
+    config = mergeConfig(config, override);
+    return config;
+  }
+  const jsonRc = path__default.join(cwd, ".codewikirc.json");
+  if (await fileExists(jsonRc)) {
+    const override = await readJson(jsonRc);
+    config = mergeConfig(config, override);
+    return config;
+  }
+  const rc = path__default.join(cwd, ".codewikirc");
+  if (await fileExists(rc)) {
+    const text = await promises.readFile(rc, "utf8");
+    try {
+      const override = JSON.parse(text);
+      config = mergeConfig(config, override);
+      return config;
+    } catch {
+    }
+  }
+  const pkg = path__default.join(cwd, "package.json");
+  const pkgJson = await readJson(pkg);
+  if (pkgJson && pkgJson["code-wiki"]) {
+    config = mergeConfig(config, pkgJson["code-wiki"]);
+  }
+  return config;
+}
+async function fileExists(p) {
+  try {
+    const s = await promises.stat(p);
+    return s.isFile();
+  } catch {
+    return false;
+  }
+}
+function configSummary(c) {
+  return [
+    `outDir=${toPosix(c.outDir)}`,
+    `modules=${c.modules.rule}`,
+    `languages=${c.includeExtensions.length || "auto"}`,
+    `nudge=${c.nudge.enabled ? "on" : "off"}`,
+    `enrichment=${c.enrichment.enabled ? "on" : "off"}`
+  ].join(" ");
+}
+
+const config = {
+  __proto__: null,
+  DEFAULT_CONFIG: DEFAULT_CONFIG,
+  configSummary: configSummary,
+  loadConfig: loadConfig
+};
+
+export { DEFAULT_CONFIG as D, log as a, atomicWriteText as b, repoRel as c, child as d, exists as e, configSummary as f, config as g, loadConfig as l, readJson as r, toPosix as t, writeJson as w };

package/dist/chunks/llm.mjs

@@ -0,0 +1,214 @@
+import { promises } from 'node:fs';
+import path__default from 'node:path';
+import { createHash } from 'node:crypto';
+import Anthropic from '@anthropic-ai/sdk';
+import PQueue from 'p-queue';
+import pRetry from 'p-retry';
+import { a as log, r as readJson, w as writeJson } from './config.mjs';
+import { g as groupModules, c as countTokens } from './build.mjs';
+import 'pino';
+import 'node:os';
+import 'ignore';
+import 'globby';
+import 'gpt-tokenizer/encoding/cl100k_base';
+import 'web-tree-sitter';
+
+const SYSTEM_PROMPT = "You are a precise code summarizer. Output ONLY a one-line PURPOSE and a 1-3 sentence NOTES section. No bullet lists, no headings, no markdown formatting. Tone: terse, technical, factual.";
+function client(opts) {
+  if (opts.client) return opts.client;
+  const key = opts.env?.ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_API_KEY;
+  if (!key) return null;
+  const sdk = new Anthropic({ apiKey: key });
+  return sdk;
+}
+function sha256(s) {
+  return createHash("sha256").update(s).digest("hex");
+}
+async function readCache(cwd, hash) {
+  const p = path__default.join(cwd, ".codewiki", ".summary-cache", `${hash}.json`);
+  const cached = await readJson(p);
+  return cached ?? null;
+}
+async function writeCache(cwd, hash, payload) {
+  const p = path__default.join(cwd, ".codewiki", ".summary-cache", `${hash}.json`);
+  await writeJson(p, payload);
+}
+function isEligible(file) {
+  if (!file.language) return false;
+  if (file.symbols.length === 0) return false;
+  if (file.symbols.every((s) => !s.docstring)) return true;
+  const maxCx = file.symbols.reduce((m, s) => Math.max(m, s.complexity), 0);
+  if (maxCx > 15) return true;
+  if (countTokens(file.oneLineSummary + "\n" + file.symbols.map((s) => s.signature).join("\n")) > 800) {
+    return true;
+  }
+  return false;
+}
+async function enrichFiles(opts) {
+  const { cwd, files, config } = opts;
+  const eligible = files.filter(isEligible);
+  if (eligible.length === 0) return /* @__PURE__ */ new Map();
+  const anthropic = client({});
+  if (!anthropic) {
+    log.info({ count: eligible.length }, "enrichment skipped: ANTHROPIC_API_KEY not set");
+    return /* @__PURE__ */ new Map();
+  }
+  log.info(
+    { count: eligible.length, model: config.enrichment.fileModel, concurrency: config.enrichment.concurrency },
+    "starting file-level enrichment"
+  );
+  const queue = new PQueue({ concurrency: config.enrichment.concurrency });
+  const out = /* @__PURE__ */ new Map();
+  const tasks = eligible.map(
+    (file) => queue.add(async () => {
+      const hash = sha256(file.contentHash + "|enrich-file");
+      const cached = await readCache(cwd, hash);
+      if (cached) {
+        out.set(file.repoPath, cached);
+        return;
+      }
+      try {
+        const summary = await pRetry(
+          () => callFileSummary(anthropic, file, config).then((s) => ({
+            purpose: s.purpose,
+            notes: s.notes
+          })),
+          { retries: 2, minTimeout: 500, factor: 2 }
+        );
+        await writeCache(cwd, hash, summary);
+        out.set(file.repoPath, summary);
+      } catch (err) {
+        log.warn({ path: file.repoPath, err: String(err) }, "file enrichment failed");
+      }
+    })
+  );
+  await Promise.all(tasks);
+  log.info({ written: out.size }, "file enrichment done");
+  return out;
+}
+async function callFileSummary(anthropic, file, config) {
+  const symbols = file.symbols.slice(0, 30).map((s) => `[${s.kind}] ${s.signature}${s.docstring ? ` \u2014 ${s.docstring}` : ""}`).join("\n");
+  const userPrompt = `File: ${file.repoPath} (language=${file.language})
+
+Symbols:
+${symbols}
+
+Return JSON: {"purpose": "...", "notes": "..."} with at most 30 words of notes. No markdown.`;
+  const resp = await anthropic.messages({
+    model: config.enrichment.fileModel,
+    max_tokens: 400,
+    messages: [
+      { role: "user", content: SYSTEM_PROMPT + "\n\n" + userPrompt }
+    ]
+  });
+  const text = resp.content.map((c) => c.text).join("");
+  return parseSummaryJson(text);
+}
+function parseSummaryJson(text) {
+  try {
+    const m = /\{[\s\S]*?\}/.exec(text);
+    if (m) {
+      const obj = JSON.parse(m[0]);
+      if (typeof obj.purpose === "string" && typeof obj.notes === "string") {
+        return { purpose: obj.purpose, notes: obj.notes };
+      }
+    }
+  } catch {
+  }
+  const lines = text.split("\n").filter(Boolean);
+  return {
+    purpose: (lines[0] ?? "").slice(0, 200),
+    notes: lines.slice(1).join(" ").slice(0, 400)
+  };
+}
+async function enrichModules(opts) {
+  const { cwd, files, config } = opts;
+  const anthropic = client({});
+  if (!anthropic) return /* @__PURE__ */ new Map();
+  const modules = groupModules(files, config);
+  const out = /* @__PURE__ */ new Map();
+  const queue = new PQueue({ concurrency: config.enrichment.concurrency });
+  const tasks = [];
+  for (const [id, m] of modules) {
+    tasks.push(
+      queue.add(async () => {
+        const memberHashes = m.files.map((p) => files.find((f) => f.repoPath === p)?.contentHash ?? "").sort().join("|");
+        const hash = sha256(memberHashes + "|enrich-module");
+        const cached = await readCache(cwd, hash);
+        if (cached) {
+          out.set(id, cached);
+          return;
+        }
+        try {
+          const summary = await pRetry(
+            () => callModuleSummary(anthropic, id, m, files, config).then((s) => ({
+              purpose: s.purpose,
+              notes: s.notes
+            })),
+            { retries: 2, minTimeout: 500, factor: 2 }
+          );
+          await writeCache(cwd, hash, summary);
+          out.set(id, summary);
+        } catch (err) {
+          log.warn({ module: id, err: String(err) }, "module enrichment failed");
+        }
+      })
+    );
+  }
+  await Promise.all(tasks);
+  log.info({ written: out.size }, "module enrichment done");
+  return out;
+}
+async function callModuleSummary(anthropic, moduleId, m, files, config) {
+  const fileLines = m.files.slice(0, 12).map((p) => {
+    const f = files.find((x) => x.repoPath === p);
+    return f ? `${p}: ${f.oneLineSummary}` : p;
+  }).join("\n");
+  const userPrompt = `Module: ${moduleId}
+
+Files:
+${fileLines}
+
+Return JSON: {"purpose": "...", "notes": "..."}. <=25 words notes. No markdown.`;
+  const resp = await anthropic.messages({
+    model: config.enrichment.moduleModel,
+    max_tokens: 350,
+    messages: [
+      { role: "user", content: SYSTEM_PROMPT + "\n\n" + userPrompt }
+    ]
+  });
+  const text = resp.content.map((c) => c.text).join("");
+  return parseSummaryJson(text);
+}
+async function enrichAll(opts) {
+  const [files, modules] = await Promise.all([
+    enrichFiles(opts),
+    enrichModules(opts)
+  ]);
+  return { files, modules };
+}
+async function runEnrichmentCli(cwd, opts = {}) {
+  const { loadConfig } = await import('./config.mjs').then(function (n) { return n.g; });
+  const { walkFiles } = await import('./build.mjs').then(function (n) { return n.a; });
+  const cfg = await loadConfig(cwd);
+  const walked = await walkFiles({ root: cwd, ignoreGlobs: cfg.ignore });
+  const fileIndexes = walked.map((f) => ({
+    repoPath: f.repoPath,
+    absPath: f.absPath,
+    language: f.language,
+    size: f.size,
+    mtimeMs: f.mtimeMs,
+    contentHash: "",
+    symbols: [],
+    publicSymbols: [],
+    oneLineSummary: ""
+  }));
+  await enrichAll({ cwd, files: fileIndexes, config: cfg, client: opts.client });
+}
+async function ensureCacheDir(cwd) {
+  const dir = path__default.join(cwd, ".codewiki", ".summary-cache");
+  await promises.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+export { enrichAll, enrichFiles, enrichModules, ensureCacheDir, parseSummaryJson, runEnrichmentCli };