@vpxa/kb 0.1.1

package/bin/kb.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+
+// Dispatch to the CLI package
+const cliPath = resolve(__dirname, '..', 'packages', 'cli', 'dist', 'index.js');
+const cli = await import(pathToFileURL(cliPath).href);
+await cli.run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@vpxa/kb",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Local-first AI developer toolkit — knowledge base, code analysis, context management, and developer tools for LLM agents",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anvpx/kb.git"
+  },
+  "keywords": [
+    "knowledge-base",
+    "mcp",
+    "ai",
+    "developer-tools",
+    "local-first",
+    "embeddings",
+    "vector-search",
+    "code-analysis"
+  ],
+  "author": "AnVPX",
+  "files": [
+    "bin/",
+    "packages/*/dist/**/*.js",
+    "packages/*/dist/**/*.d.ts",
+    "skills/",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./packages/core/dist/index.js",
+    "./tools": "./packages/tools/dist/index.js",
+    "./store": "./packages/store/dist/index.js",
+    "./embeddings": "./packages/embeddings/dist/index.js"
+  },
+  "types": "./packages/core/dist/index.d.ts",
+  "bin": {
+    "kb": "./bin/kb.mjs"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.x",
+    "@types/node": "^24.x",
+    "esbuild": "^0.x",
+    "glob": "^13.x",
+    "rimraf": "^6.x",
+    "typescript": "^5.x",
+    "vitest": "^4.x"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "typecheck": "tsc -b tsconfig.build.json --emitDeclarationOnly",
+    "clean": "rimraf --glob packages/*/dist packages/*/*.tsbuildinfo",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "start": "node packages/server/dist/index.js",
+    "start:http": "node packages/server/dist/index.js --transport http",
+    "test": "vitest run",
+    "release": "node scripts/release.mjs",
+    "release:dry": "node scripts/release.mjs --dry-run",
+    "nodeprune": "pnpm clean && pnpm store prune && pnpm -s dlx npkill -D -y",
+    "test:watch": "vitest"
+  }
+}

package/packages/analyzers/dist/blast-radius-analyzer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Blast-radius analyzer.
+ *
+ * Given a set of changed files, traces the dependency graph to find all
+ * affected files (direct + transitive importers) and their associated tests.
+ * Returns a minimal review context optimized for token efficiency.
+ */
+import type { AnalysisResult } from './types.js';
+export interface BlastRadiusOptions {
+    /** Changed file paths (relative to root) */
+    files: string[];
+    /** Maximum depth of transitive dependency traversal (default: 5) */
+    maxDepth?: number;
+    /** Output format */
+    format?: 'json' | 'markdown';
+}
+export declare class BlastRadiusAnalyzer {
+    readonly name = "blast-radius";
+    private depAnalyzer;
+    analyze(rootPath: string, options: BlastRadiusOptions): Promise<AnalysisResult>;
+    private formatMarkdown;
+}
+//# sourceMappingURL=blast-radius-analyzer.d.ts.map

package/packages/analyzers/dist/blast-radius-analyzer.js

@@ -0,0 +1,114 @@
+import { DependencyAnalyzer } from "./dependency-analyzer.js";
+class BlastRadiusAnalyzer {
+  name = "blast-radius";
+  depAnalyzer = new DependencyAnalyzer();
+  async analyze(rootPath, options) {
+    const { files, maxDepth = 5, format = "markdown" } = options;
+    const startTime = Date.now();
+    const depResult = await this.depAnalyzer.analyze(rootPath, { format: "json" });
+    const depData = depResult.data;
+    const reverseGraph = depData.reverseGraph ?? {};
+    const testCoverage = depData.testCoverage ?? {};
+    const affected = /* @__PURE__ */ new Map();
+    const queue = [];
+    for (const file of files) {
+      affected.set(file, { path: file, reason: "changed", depth: 0 });
+      const norm = file.replace(/\.[jt]sx?$/, "");
+      queue.push({ path: norm, depth: 0 });
+    }
+    while (queue.length > 0) {
+      const item = queue.shift();
+      if (!item) break;
+      const { path, depth } = item;
+      if (depth >= maxDepth) continue;
+      const importers = reverseGraph[path] ?? [];
+      for (const importer of importers) {
+        if (affected.has(importer)) continue;
+        const reason = depth === 0 ? "direct-importer" : "transitive-importer";
+        affected.set(importer, { path: importer, reason, depth: depth + 1 });
+        const importerNorm = importer.replace(/\.[jt]sx?$/, "");
+        queue.push({ path: importerNorm, depth: depth + 1 });
+      }
+    }
+    const affectedTests = /* @__PURE__ */ new Set();
+    for (const [filePath] of affected) {
+      const norm = filePath.replace(/\.[jt]sx?$/, "");
+      const tests = testCoverage[norm] ?? [];
+      for (const test of tests) {
+        if (!affected.has(test)) {
+          affectedTests.add(test);
+          affected.set(test, { path: test, reason: "test", depth: 999 });
+        }
+      }
+    }
+    const affectedList = [...affected.values()].sort((a, b) => a.depth - b.depth);
+    const output = format === "json" ? JSON.stringify({ changedFiles: files, affected: affectedList }, null, 2) : this.formatMarkdown(files, affectedList, reverseGraph);
+    return {
+      output,
+      data: { changedFiles: files, affected: affectedList },
+      meta: {
+        analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        scope: rootPath,
+        fileCount: affectedList.length,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  formatMarkdown(changedFiles, affected, _reverseGraph) {
+    const lines = [];
+    lines.push("## Blast Radius Analysis\n");
+    lines.push(`**Changed files:** ${changedFiles.length}`);
+    lines.push(`**Total affected:** ${affected.length}
+`);
+    const changed = affected.filter((a) => a.reason === "changed");
+    if (changed.length > 0) {
+      lines.push("### Changed Files\n");
+      for (const f of changed) {
+        lines.push(`- \`${f.path}\``);
+      }
+    }
+    const direct = affected.filter((a) => a.reason === "direct-importer");
+    if (direct.length > 0) {
+      lines.push(`
+### Direct Importers (${direct.length} files)
+`);
+      for (const f of direct) {
+        lines.push(`- \`${f.path}\``);
+      }
+    }
+    const transitive = affected.filter((a) => a.reason === "transitive-importer");
+    if (transitive.length > 0) {
+      lines.push(`
+### Transitive Importers (${transitive.length} files)
+`);
+      for (const f of transitive.slice(0, 20)) {
+        lines.push(`- \`${f.path}\` (depth ${f.depth})`);
+      }
+      if (transitive.length > 20) {
+        lines.push(`- ... and ${transitive.length - 20} more`);
+      }
+    }
+    const tests = affected.filter((a) => a.reason === "test");
+    if (tests.length > 0) {
+      lines.push(`
+### Affected Tests (${tests.length} files)
+`);
+      for (const f of tests) {
+        lines.push(`- \`${f.path}\``);
+      }
+    }
+    lines.push("\n### Review Summary\n");
+    lines.push(`| Category | Count |`);
+    lines.push(`|----------|-------|`);
+    lines.push(`| Changed | ${changed.length} |`);
+    lines.push(`| Direct importers | ${direct.length} |`);
+    lines.push(`| Transitive importers | ${transitive.length} |`);
+    lines.push(`| Affected tests | ${tests.length} |`);
+    lines.push(`| **Total review scope** | **${affected.length}** |`);
+    return lines.join("\n");
+  }
+}
+export {
+  BlastRadiusAnalyzer
+};
+//# sourceMappingURL=blast-radius-analyzer.js.map

package/packages/analyzers/dist/dependency-analyzer.d.ts

@@ -0,0 +1,29 @@
+import type { AnalysisResult, DependencyAnalyzerOptions, IAnalyzer, ImportInfo } from './types.js';
+export declare class DependencyAnalyzer implements IAnalyzer<DependencyAnalyzerOptions> {
+    readonly name = "dependencies";
+    /** Map of workspace package names to their relative entry point paths */
+    private workspacePackages;
+    analyze(rootPath: string, options?: DependencyAnalyzerOptions): Promise<AnalysisResult>;
+    private collectFiles;
+    private extractImports;
+    private groupExternalDeps;
+    private groupInternalDeps;
+    /**
+     * Build reverse graph: for each source file, who imports it?
+     */
+    buildReverseGraph(imports: ImportInfo[], _rootPath: string): Record<string, string[]>;
+    /**
+     * Build test coverage map: for each source file, which test files exercise it?
+     */
+    buildTestCoverage(imports: ImportInfo[], _rootPath: string): Record<string, string[]>;
+    /** Resolve a relative import path to a normalized file path (best-effort). */
+    private resolveImportPath;
+    /**
+     * Build a map of workspace package names → relative entry point paths.
+     * Scans for package.json files in common workspace dirs.
+     */
+    private buildWorkspaceMap;
+    private formatMarkdown;
+    private formatMermaid;
+}
+//# sourceMappingURL=dependency-analyzer.d.ts.map

package/packages/analyzers/dist/dependency-analyzer.js

@@ -0,0 +1,425 @@
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, extname, join, relative, resolve } from "node:path";
+const CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".java",
+  ".go",
+  ".cs",
+  ".kt",
+  ".scala",
+  ".rb",
+  ".rs",
+  ".php",
+  ".swift"
+]);
+const IMPORT_PATTERNS = [
+  // ── JS/TS ──
+  // ES import: import { x } from 'module'  /  import x from 'module'
+  {
+    regex: /import\s+(?:(?:type\s+)?(?:(?:\{[^}]*\}|[\w*]+)\s+from\s+)?)['"]([^'"]+)['"]/g,
+    confidence: "high"
+  },
+  // Dynamic import: import('module')
+  {
+    regex: /import\(\s*['"]([^'"]+)['"]\s*\)/g,
+    confidence: "medium"
+  },
+  // CommonJS require: require('module')
+  {
+    regex: /require\(\s*['"]([^'"]+)['"]\s*\)/g,
+    confidence: "medium"
+  },
+  // ── Python ──
+  // from package import module
+  {
+    regex: /^from\s+([\w.]+)\s+import\b/gm,
+    confidence: "high",
+    lang: "python"
+  },
+  // import package
+  {
+    regex: /^import\s+([\w.]+)\s*$/gm,
+    confidence: "high",
+    lang: "python"
+  },
+  // ── Java / Kotlin / Scala ──
+  // import com.example.Class;
+  {
+    regex: /^import\s+(?:static\s+)?([\w.]+(?:\.\*)?)\s*;/gm,
+    confidence: "high",
+    lang: "java"
+  },
+  // ── Go ──
+  // import "package"  or  "package"  inside import block
+  {
+    regex: /(?:^import\s+|^\s+)[""]([^""]+)[""]/gm,
+    confidence: "high",
+    lang: "go"
+  },
+  // ── C# ──
+  // using Namespace.Something;
+  {
+    regex: /^using\s+(?:static\s+)?([\w.]+)\s*;/gm,
+    confidence: "high",
+    lang: "csharp"
+  },
+  // ── Rust ──
+  // use crate::module;  use std::io;
+  {
+    regex: /^use\s+([\w:]+(?:::\w+)*)/gm,
+    confidence: "high",
+    lang: "rust"
+  },
+  // ── PHP ──
+  // use Namespace\Class;
+  {
+    regex: /^use\s+([\w\\]+)\s*;/gm,
+    confidence: "high",
+    lang: "php"
+  },
+  // ── Ruby ──
+  // require 'gem'  or  require_relative 'file'
+  {
+    regex: /require(?:_relative)?\s+['"]([^'"]+)['"]/g,
+    confidence: "medium",
+    lang: "ruby"
+  },
+  // ── Swift ──
+  // import Foundation
+  {
+    regex: /^import\s+(\w+)\s*$/gm,
+    confidence: "high",
+    lang: "swift"
+  }
+];
+const DEFAULT_EXCLUDES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".turbo",
+  ".cache",
+  "cdk.out"
+]);
+const TEST_PATTERNS = [/\.(test|spec)\.[jt]sx?$/, /\/__tests__\//, /\/test\//, /\/tests\//];
+const EXT_TO_LANG = {
+  ".ts": "js",
+  ".tsx": "js",
+  ".js": "js",
+  ".jsx": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".py": "python",
+  ".java": "java",
+  ".kt": "java",
+  ".scala": "java",
+  ".go": "go",
+  ".cs": "csharp",
+  ".rs": "rust",
+  ".php": "php",
+  ".rb": "ruby",
+  ".swift": "swift"
+};
+function classifyExternal(source, lang) {
+  if (!lang || lang === "js") {
+    return !source.startsWith(".") && !source.startsWith("/");
+  }
+  if (lang === "python") {
+    return !source.startsWith(".");
+  }
+  if (lang === "java") {
+    return !source.startsWith("com.") || source.startsWith("com.amazonaws") || source.startsWith("com.google") || source.startsWith("com.fasterxml");
+  }
+  if (lang === "go") {
+    return source.includes(".") && !source.startsWith(".");
+  }
+  if (lang === "csharp") {
+    return source.startsWith("System") || source.startsWith("Microsoft") || source.startsWith("Newtonsoft") || source.startsWith("Amazon");
+  }
+  if (lang === "rust") {
+    return !source.startsWith("crate::") && !source.startsWith("self::") && !source.startsWith("super::");
+  }
+  return true;
+}
+function isTestFile(filePath) {
+  return TEST_PATTERNS.some((p) => p.test(filePath));
+}
+class DependencyAnalyzer {
+  name = "dependencies";
+  /** Map of workspace package names to their relative entry point paths */
+  workspacePackages = /* @__PURE__ */ new Map();
+  async analyze(rootPath, options = {}) {
+    const { format = "markdown" } = options;
+    const startTime = Date.now();
+    this.workspacePackages = await this.buildWorkspaceMap(rootPath);
+    const files = await this.collectFiles(rootPath);
+    const imports = [];
+    for (const filePath of files) {
+      const content = await readFile(filePath, "utf-8");
+      const fileImports = this.extractImports(content, filePath, rootPath);
+      imports.push(...fileImports);
+    }
+    const external = this.groupExternalDeps(imports);
+    const internal = this.groupInternalDeps(imports, rootPath);
+    const reverseGraph = this.buildReverseGraph(imports, rootPath);
+    const testCoverage = this.buildTestCoverage(imports, rootPath);
+    const output = format === "json" ? JSON.stringify({ external, internal, reverseGraph, testCoverage }, null, 2) : format === "mermaid" ? this.formatMermaid(internal) : this.formatMarkdown(external, internal, rootPath, testCoverage);
+    return {
+      output,
+      data: { external, internal, reverseGraph, testCoverage, totalImports: imports.length },
+      meta: {
+        analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        scope: rootPath,
+        fileCount: files.length,
+        durationMs: Date.now() - startTime
+      }
+    };
+  }
+  async collectFiles(dirPath) {
+    const files = [];
+    const walk = async (dir) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (DEFAULT_EXCLUDES.has(entry.name)) continue;
+        if (entry.name.startsWith(".")) continue;
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+        } else if (CODE_EXTENSIONS.has(extname(entry.name))) {
+          files.push(fullPath);
+        }
+      }
+    };
+    await walk(dirPath);
+    return files;
+  }
+  extractImports(content, filePath, rootPath) {
+    const results = [];
+    const ext = extname(filePath).toLowerCase();
+    const fileLang = EXT_TO_LANG[ext];
+    for (const pattern of IMPORT_PATTERNS) {
+      if (pattern.lang && pattern.lang !== fileLang) continue;
+      if (!pattern.lang && fileLang && fileLang !== "js") continue;
+      const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        const source = match[1];
+        const isExternal = classifyExternal(source, fileLang);
+        results.push({
+          source,
+          specifiers: [],
+          filePath: relative(rootPath, filePath).replace(/\\/g, "/"),
+          isExternal,
+          confidence: pattern.confidence
+        });
+      }
+    }
+    return results;
+  }
+  groupExternalDeps(imports) {
+    const deps = {};
+    for (const imp of imports) {
+      if (!imp.isExternal) continue;
+      const ext = extname(imp.filePath).toLowerCase();
+      const lang = EXT_TO_LANG[ext];
+      let pkg;
+      if (lang === "java") {
+        const parts = imp.source.split(".");
+        while (parts.length > 1) {
+          const last = parts[parts.length - 1];
+          if (last === "*" || /^[A-Z]/.test(last)) {
+            parts.pop();
+          } else {
+            break;
+          }
+        }
+        if (parts.length >= 2) {
+          pkg = parts.slice(0, 2).join(".");
+        } else {
+          pkg = parts.join(".");
+        }
+      } else if (lang === "python") {
+        pkg = imp.source.split(".")[0];
+      } else if (lang === "go") {
+        pkg = imp.source;
+      } else if (lang === "csharp") {
+        const parts = imp.source.split(".");
+        pkg = parts.length >= 2 ? parts.slice(0, 2).join(".") : imp.source;
+      } else {
+        pkg = imp.source.startsWith("@") ? imp.source.split("/").slice(0, 2).join("/") : imp.source.split("/")[0];
+      }
+      if (!deps[pkg]) deps[pkg] = { count: 0, confidence: imp.confidence, usedBy: /* @__PURE__ */ new Set() };
+      deps[pkg].count++;
+      deps[pkg].usedBy.add(imp.filePath);
+      if (imp.confidence === "high") deps[pkg].confidence = "high";
+      else if (imp.confidence === "medium" && deps[pkg].confidence === "low")
+        deps[pkg].confidence = "medium";
+    }
+    const result = {};
+    for (const [pkg, data] of Object.entries(deps)) {
+      result[pkg] = { count: data.count, confidence: data.confidence, usedBy: [...data.usedBy] };
+    }
+    return result;
+  }
+  groupInternalDeps(imports, _rootPath) {
+    const deps = {};
+    for (const imp of imports) {
+      if (imp.isExternal) continue;
+      if (!deps[imp.filePath]) deps[imp.filePath] = /* @__PURE__ */ new Set();
+      deps[imp.filePath].add(imp.source);
+    }
+    const result = {};
+    for (const [file, sources] of Object.entries(deps)) {
+      result[file] = [...sources];
+    }
+    return result;
+  }
+  /**
+   * Build reverse graph: for each source file, who imports it?
+   */
+  buildReverseGraph(imports, _rootPath) {
+    const reverse = {};
+    for (const imp of imports) {
+      const importerDir = dirname(imp.filePath);
+      const resolved = this.resolveImportPath(imp.source, importerDir);
+      if (!resolved) continue;
+      if (!reverse[resolved]) reverse[resolved] = /* @__PURE__ */ new Set();
+      reverse[resolved].add(imp.filePath);
+    }
+    const result = {};
+    for (const [file, importers] of Object.entries(reverse)) {
+      result[file] = [...importers];
+    }
+    return result;
+  }
+  /**
+   * Build test coverage map: for each source file, which test files exercise it?
+   */
+  buildTestCoverage(imports, _rootPath) {
+    const coverage = {};
+    for (const imp of imports) {
+      if (!isTestFile(imp.filePath)) continue;
+      const importerDir = dirname(imp.filePath);
+      const resolved = this.resolveImportPath(imp.source, importerDir);
+      if (!resolved || isTestFile(resolved)) continue;
+      if (!coverage[resolved]) coverage[resolved] = /* @__PURE__ */ new Set();
+      coverage[resolved].add(imp.filePath);
+    }
+    const result = {};
+    for (const [file, tests] of Object.entries(coverage)) {
+      result[file] = [...tests];
+    }
+    return result;
+  }
+  /** Resolve a relative import path to a normalized file path (best-effort). */
+  resolveImportPath(source, fromDir) {
+    if (source.startsWith(".")) {
+      const resolved = join(fromDir, source).replace(/\\/g, "/");
+      return resolved.replace(/\.[jt]sx?$/, "");
+    }
+    const pkg = source.startsWith("@") ? source.split("/").slice(0, 2).join("/") : source.split("/")[0];
+    const entryPath = this.workspacePackages.get(pkg);
+    if (entryPath) {
+      return entryPath.replace(/\.[jt]sx?$/, "");
+    }
+    return null;
+  }
+  /**
+   * Build a map of workspace package names → relative entry point paths.
+   * Scans for package.json files in common workspace dirs.
+   */
+  async buildWorkspaceMap(rootPath) {
+    const map = /* @__PURE__ */ new Map();
+    const searchDirs = ["packages", "functions", "libs", "apps", "cdk"];
+    for (const dir of searchDirs) {
+      const dirPath = join(rootPath, dir);
+      try {
+        const entries = await readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory() || DEFAULT_EXCLUDES.has(entry.name)) continue;
+          try {
+            const pkgJsonPath = join(dirPath, entry.name, "package.json");
+            const pkgJson = JSON.parse(await readFile(pkgJsonPath, "utf-8"));
+            if (pkgJson.name) {
+              const main = pkgJson.main ?? pkgJson.exports?.["."] ?? "src/index.ts";
+              const entryRelative = relative(rootPath, resolve(dirPath, entry.name, main)).replace(
+                /\\/g,
+                "/"
+              );
+              map.set(pkgJson.name, entryRelative);
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    return map;
+  }
+  formatMarkdown(external, internal, rootPath, testCoverage) {
+    const lines = [];
+    lines.push(`## Dependencies: ${rootPath}
+`);
+    const sortedExternal = Object.entries(external).sort((a, b) => b[1].count - a[1].count);
+    const totalExternal = sortedExternal.length;
+    const totalImports = sortedExternal.reduce((sum, [, d]) => sum + d.count, 0);
+    const top5 = sortedExternal.slice(0, 5).map(([pkg]) => pkg);
+    lines.push(
+      `**${totalExternal} external packages**, **${totalImports} total imports**, **${Object.keys(internal).length} files** with internal imports.
+`
+    );
+    if (top5.length > 0) {
+      lines.push(`**Top dependencies**: ${top5.join(", ")}
+`);
+    }
+    lines.push("### External Dependencies\n");
+    lines.push("| Package | Imports | Used By |");
+    lines.push("|---------|---------|---------|");
+    for (const [pkg, data] of sortedExternal) {
+      lines.push(
+        `| ${pkg} | ${data.count} | ${data.usedBy.length} ${data.usedBy.length === 1 ? "file" : "files"} |`
+      );
+    }
+    if (testCoverage && Object.keys(testCoverage).length > 0) {
+      const totalTested = Object.keys(testCoverage).length;
+      const untested = Object.keys(internal).filter(
+        (f) => !isTestFile(f) && !testCoverage[f.replace(/\\.[jt]sx?$/, "")]
+      );
+      lines.push("\n### Test Coverage Summary\n");
+      lines.push(`**${totalTested} source modules** with test coverage.`);
+      if (untested.length > 0) {
+        lines.push(`**${untested.length} source files** with no detected test coverage.`);
+      }
+      const sorted = Object.entries(testCoverage).sort((a, b) => b[1].length - a[1].length);
+      lines.push("\n**Most-tested modules:**\n");
+      for (const [source, tests] of sorted.slice(0, 10)) {
+        const displayPath = source.replace(/\/dist\/[^/]*$/, "/src/index").replace(/\.mjs$/, ".ts");
+        lines.push(`- ${displayPath} (${tests.length} ${tests.length === 1 ? "test" : "tests"})`);
+      }
+    }
+    return lines.join("\n");
+  }
+  formatMermaid(internal) {
+    const lines = ["graph LR"];
+    const nodeId = (path) => path.replace(/[^a-zA-Z0-9]/g, "_");
+    for (const [file, deps] of Object.entries(internal).slice(0, 40)) {
+      const fromId = nodeId(file);
+      for (const dep of deps) {
+        const toId = nodeId(dep);
+        lines.push(`  ${fromId}["${file}"] --> ${toId}["${dep}"]`);
+      }
+    }
+    return lines.join("\n");
+  }
+}
+export {
+  DependencyAnalyzer
+};
+//# sourceMappingURL=dependency-analyzer.js.map

package/packages/analyzers/dist/diagram-generator.d.ts

@@ -0,0 +1,13 @@
+import type { AnalysisResult, DiagramOptions, IAnalyzer } from './types.js';
+/**
+ * Generates Mermaid diagrams by combining output from other analyzers.
+ */
+export declare class DiagramGenerator implements IAnalyzer<DiagramOptions> {
+    readonly name = "diagrams";
+    private readonly structureAnalyzer;
+    private readonly dependencyAnalyzer;
+    analyze(rootPath: string, options?: DiagramOptions): Promise<AnalysisResult>;
+    private generateArchitectureDiagram;
+    private generateDependencyDiagram;
+}
+//# sourceMappingURL=diagram-generator.d.ts.map