@massu/core 1.10.8 → 1.12.0

package/src/team-knowledge.ts

@@ -1,407 +0,0 @@
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-import type Database from 'better-sqlite3';
-import type { ToolDefinition, ToolResult } from './tools.ts';
-import { getConfig } from './config.ts';
-
-// ============================================================
-// Team Knowledge Graph
-// ============================================================
-
-/** Prefix a base tool name with the configured tool prefix. */
-function p(baseName: string): string {
-  return `${getConfig().toolPrefix}_${baseName}`;
-}
-
-/**
- * Calculate expertise score for a developer in a module.
- * Based on session depth (how many sessions) and observation quality.
- */
-export function calculateExpertise(
-  sessionCount: number,
-  observationCount: number
-): number {
-  const config = getConfig();
-  const sessionWeight = config.team?.expertise_weights?.session ?? 20;
-  const observationWeight = config.team?.expertise_weights?.observation ?? 10;
-
-  const sessionScore = Math.log2(sessionCount + 1) * sessionWeight;
-  const obsScore = Math.log2(observationCount + 1) * observationWeight;
-  return Math.min(100, Math.round(sessionScore + obsScore));
-}
-
-/**
- * Update developer expertise based on session observations.
- */
-export function updateExpertise(
-  db: Database.Database,
-  developerId: string,
-  sessionId: string
-): void {
-  const fileChanges = db.prepare(`
-    SELECT DISTINCT files_involved FROM observations
-    WHERE session_id = ? AND type IN ('file_change', 'feature', 'bugfix', 'refactor')
-  `).all(sessionId) as Array<{ files_involved: string }>;
-
-  const modules = new Set<string>();
-  for (const fc of fileChanges) {
-    try {
-      const files = JSON.parse(fc.files_involved) as string[];
-      for (const file of files) {
-        const module = extractModule(file);
-        if (module) modules.add(module);
-      }
-    } catch { /* skip */ }
-  }
-
-  for (const module of modules) {
-    const existing = db.prepare(
-      'SELECT session_count, observation_count FROM developer_expertise WHERE developer_id = ? AND module = ?'
-    ).get(developerId, module) as { session_count: number; observation_count: number } | undefined;
-
-    const sessionCount = (existing?.session_count ?? 0) + 1;
-    const obsCount = (existing?.observation_count ?? 0) + fileChanges.length;
-    const score = calculateExpertise(sessionCount, obsCount);
-
-    db.prepare(`
-      INSERT INTO developer_expertise (developer_id, module, session_count, observation_count, expertise_score, last_active)
-      VALUES (?, ?, ?, ?, ?, datetime('now'))
-      ON CONFLICT(developer_id, module) DO UPDATE SET
-        session_count = ?,
-        observation_count = ?,
-        expertise_score = ?,
-        last_active = datetime('now')
-    `).run(
-      developerId, module, sessionCount, obsCount, score,
-      sessionCount, obsCount, score
-    );
-  }
-}
-
-/**
- * Detect potential conflicts between developers working on same files.
- */
-export function detectConflicts(
-  db: Database.Database,
-  daysBack: number = 7
-): Array<{
-  filePath: string;
-  developerA: string;
-  developerB: string;
-  conflictType: string;
-}> {
-  const conflicts = db.prepare(`
-    SELECT so1.file_path,
-           so1.developer_id as developer_a,
-           so2.developer_id as developer_b,
-           'concurrent_edit' as conflict_type
-    FROM shared_observations so1
-    JOIN shared_observations so2 ON so1.file_path = so2.file_path
-    WHERE so1.developer_id != so2.developer_id
-      AND so1.file_path IS NOT NULL
-      AND so1.created_at >= datetime('now', ?)
-      AND so2.created_at >= datetime('now', ?)
-    GROUP BY so1.file_path, so1.developer_id, so2.developer_id
-  `).all(`-${daysBack} days`, `-${daysBack} days`) as Array<{
-    file_path: string;
-    developer_a: string;
-    developer_b: string;
-    conflict_type: string;
-  }>;
-
-  return conflicts.map(c => ({
-    filePath: c.file_path,
-    developerA: c.developer_a,
-    developerB: c.developer_b,
-    conflictType: c.conflict_type,
-  }));
-}
-
-/**
- * Share an observation for team visibility.
- */
-export function shareObservation(
-  db: Database.Database,
-  developerId: string,
-  project: string,
-  observationType: string,
-  summary: string,
-  opts?: {
-    originalId?: number;
-    filePath?: string;
-    module?: string;
-    severity?: number;
-  }
-): number {
-  const result = db.prepare(`
-    INSERT INTO shared_observations
-    (original_id, developer_id, project, observation_type, summary, file_path, module, severity, is_shared, shared_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, TRUE, datetime('now'))
-  `).run(
-    opts?.originalId ?? null,
-    developerId, project, observationType, summary,
-    opts?.filePath ?? null,
-    opts?.module ?? null,
-    opts?.severity ?? 3
-  );
-  return Number(result.lastInsertRowid);
-}
-
-/**
- * Extract business module from a file path.
- * Uses configurable module extraction patterns if provided.
- */
-function extractModule(filePath: string): string | null {
-  // Route-based modules
-  const routerMatch = filePath.match(/routers\/([^/.]+)/);
-  if (routerMatch) return routerMatch[1];
-
-  // Page-based modules
-  const pageMatch = filePath.match(/app\/\(([^)]+)\)/);
-  if (pageMatch) return pageMatch[1];
-
-  // Component-based
-  const compMatch = filePath.match(/components\/([^/.]+)/);
-  if (compMatch) return compMatch[1];
-
-  return null;
-}
-
-// ============================================================
-// MCP Tool Definitions & Handlers
-// ============================================================
-
-export function getTeamToolDefinitions(): ToolDefinition[] {
-  return [
-    {
-      name: p('team_search'),
-      description: 'Search team-shared observations. Find what other developers learned about a module or file.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          query: { type: 'string', description: 'Search text' },
-          module: { type: 'string', description: 'Filter by business module' },
-        },
-        required: ['query'],
-      },
-    },
-    {
-      name: p('team_expertise'),
-      description: 'Who knows what. Shows developers ranked by expertise for a module or file area.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          module: { type: 'string', description: 'Business module (e.g., orders, products, design)' },
-          file_path: { type: 'string', description: 'File path to find experts for' },
-        },
-        required: [],
-      },
-    },
-    {
-      name: p('team_conflicts'),
-      description: 'Detect concurrent work conflicts. Find areas where multiple developers are making changes.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          file_path: { type: 'string', description: 'Check specific file for conflicts' },
-          days: { type: 'number', description: 'Days to look back (default: 7)' },
-        },
-        required: [],
-      },
-    },
-  ];
-}
-
-const TEAM_BASE_NAMES = new Set(['team_search', 'team_expertise', 'team_conflicts']);
-
-export function isTeamTool(name: string): boolean {
-  const pfx = getConfig().toolPrefix + '_';
-  const baseName = name.startsWith(pfx) ? name.slice(pfx.length) : name;
-  return TEAM_BASE_NAMES.has(baseName);
-}
-
-export function handleTeamToolCall(
-  name: string,
-  args: Record<string, unknown>,
-  memoryDb: Database.Database
-): ToolResult {
-  try {
-    const pfx = getConfig().toolPrefix + '_';
-    const baseName = name.startsWith(pfx) ? name.slice(pfx.length) : name;
-
-    switch (baseName) {
-      case 'team_search':
-        return handleTeamSearch(args, memoryDb);
-      case 'team_expertise':
-        return handleTeamExpertise(args, memoryDb);
-      case 'team_conflicts':
-        return handleTeamConflicts(args, memoryDb);
-      default:
-        return text(`Unknown team tool: ${name}`);
-    }
-  } catch (error) {
-    return text(`Error in ${name}: ${error instanceof Error ? error.message : String(error)}\n\nUsage: ${p('team_search')} { query: "pattern" }, ${p('team_expertise')} { module: "tasks" }`);
-  }
-}
-
-function handleTeamSearch(args: Record<string, unknown>, db: Database.Database): ToolResult {
-  const query = args.query as string;
-  if (!query) return text(`Usage: ${p('team_search')} { query: "search term", module: "optional-module" } - Search team-shared observations.`);
-
-  const module = args.module as string | undefined;
-
-  let sql = `
-    SELECT id, developer_id, observation_type, summary, file_path, module, severity, created_at
-    FROM shared_observations
-    WHERE is_shared = TRUE AND summary LIKE ?
-  `;
-  const params: (string | number)[] = [`%${query}%`];
-
-  if (module) {
-    sql += ' AND module = ?';
-    params.push(module);
-  }
-
-  sql += ' ORDER BY created_at DESC LIMIT 20';
-
-  const results = db.prepare(sql).all(...params) as Array<Record<string, unknown>>;
-
-  if (results.length === 0) {
-    return text(`No shared observations found for "${query}". Team knowledge is populated when developers share observations across sessions. Try: ${p('team_expertise')} {} to see module expertise, or broaden your search term.`);
-  }
-
-  const lines = [
-    `## Team Knowledge: "${query}" (${results.length} results)`,
-    '',
-    '| Developer | Type | Summary | Module | Date |',
-    '|-----------|------|---------|--------|------|',
-  ];
-
-  for (const r of results) {
-    lines.push(
-      `| ${r.developer_id} | ${r.observation_type} | ${(r.summary as string).slice(0, 60)} | ${r.module ?? '-'} | ${(r.created_at as string).split('T')[0]} |`
-    );
-  }
-
-  return text(lines.join('\n'));
-}
-
-function handleTeamExpertise(args: Record<string, unknown>, db: Database.Database): ToolResult {
-  const module = args.module as string | undefined;
-  const filePath = args.file_path as string | undefined;
-
-  let targetModule = module;
-  if (!targetModule && filePath) {
-    targetModule = extractModule(filePath) ?? undefined;
-  }
-
-  if (!targetModule) {
-    const modules = db.prepare(`
-      SELECT module, COUNT(DISTINCT developer_id) as developers, MAX(expertise_score) as top_score
-      FROM developer_expertise
-      GROUP BY module
-      ORDER BY developers DESC
-    `).all() as Array<Record<string, unknown>>;
-
-    if (modules.length === 0) {
-      return text(`No expertise data yet. Expertise is built automatically as developers work on modules across sessions. Try: ${p('team_search')} { query: "keyword" } to search shared observations instead.`);
-    }
-
-    const lines = [
-      '## Team Expertise Overview',
-      '',
-      '| Module | Developers | Top Score |',
-      '|--------|-----------|-----------|',
-    ];
-
-    for (const m of modules) {
-      lines.push(`| ${m.module} | ${m.developers} | ${m.top_score} |`);
-    }
-
-    lines.push('');
-    lines.push(`Use ${p('team_expertise')} { module: "module_name" } to see developers ranked by expertise.`);
-
-    return text(lines.join('\n'));
-  }
-
-  const experts = db.prepare(`
-    SELECT developer_id, expertise_score, session_count, observation_count, last_active
-    FROM developer_expertise
-    WHERE module = ?
-    ORDER BY expertise_score DESC
-  `).all(targetModule) as Array<Record<string, unknown>>;
-
-  if (experts.length === 0) {
-    return text(`No expertise data for module "${targetModule}". Expertise builds as developers work on files in this module across sessions. Try: ${p('team_expertise')} {} to see all modules with tracked expertise.`);
-  }
-
-  const lines = [
-    `## Expertise: ${targetModule}`,
-    '',
-    '| Developer | Score | Sessions | Observations | Last Active |',
-    '|-----------|-------|----------|--------------|-------------|',
-  ];
-
-  for (const e of experts) {
-    lines.push(
-      `| ${e.developer_id} | ${e.expertise_score} | ${e.session_count} | ${e.observation_count} | ${(e.last_active as string).split('T')[0]} |`
-    );
-  }
-
-  return text(lines.join('\n'));
-}
-
-function handleTeamConflicts(args: Record<string, unknown>, db: Database.Database): ToolResult {
-  const days = (args.days as number) ?? 7;
-  const filePath = args.file_path as string | undefined;
-
-  if (filePath) {
-    const conflicts = db.prepare(`
-      SELECT developer_a, developer_b, conflict_type, detected_at, resolved
-      FROM knowledge_conflicts
-      WHERE file_path = ?
-      ORDER BY detected_at DESC LIMIT 10
-    `).all(filePath) as Array<Record<string, unknown>>;
-
-    if (conflicts.length === 0) {
-      return text(`No conflicts detected for "${filePath}". Conflicts are detected when multiple developers modify the same file within the lookback window. Try: ${p('team_conflicts')} { days: 30 } to check for conflicts across all files.`);
-    }
-
-    const lines = [
-      `## Conflicts: ${filePath}`,
-      '',
-    ];
-
-    for (const c of conflicts) {
-      lines.push(`- ${c.developer_a} vs ${c.developer_b} (${c.conflict_type}) - ${c.resolved ? 'resolved' : 'ACTIVE'}`);
-    }
-
-    return text(lines.join('\n'));
-  }
-
-  // General conflict detection
-  const conflicts = detectConflicts(db, days);
-
-  if (conflicts.length === 0) {
-    return text(`No concurrent work conflicts detected in the last ${days} days. Conflicts are tracked when multiple developers modify the same files. Try a longer time range: ${p('team_conflicts')} { days: 90 }.`);
-  }
-
-  const lines = [
-    `## Work Conflicts (${days} days)`,
-    `Detected: ${conflicts.length}`,
-    '',
-    '| File | Developer A | Developer B | Type |',
-    '|------|-----------|-----------|------|',
-  ];
-
-  for (const c of conflicts) {
-    lines.push(`| ${c.filePath} | ${c.developerA} | ${c.developerB} | ${c.conflictType} |`);
-  }
-
-  return text(lines.join('\n'));
-}
-
-function text(content: string): ToolResult {
-  return { content: [{ type: 'text', text: content }] };
-}

package/src/tool-db-needs.ts

@@ -1,232 +0,0 @@
-// Copyright (c) 2026 Massu. All rights reserved.
-// Licensed under BSL 1.1 - see LICENSE file for details.
-
-/**
- * Per-tool SQLite database dependency manifest.
- *
- * **Role**: SOLE source of truth declaring which SQLite connections each MCP
- * tool needs. The dispatcher (`server.ts` → `tools.ts:handleToolCall`) reads
- * this map to lazy-resolve connections, opening ONLY the DBs a tool requires.
- *
- * **Why this exists**:
- * Before plan `plan-1.6.2-server-lazy-db-deps`, the dispatcher eagerly opened
- * BOTH CodeGraph + Data DBs on every tool/call (see legacy `server.ts:51-55,96`
- * and `tools.ts:279`). When `.codegraph/codegraph.db` was missing, EVERY tool
- * call failed — even memory/audit/knowledge tools that have no codegraph
- * dependency. This manifest makes that bug class structurally impossible:
- * a missing peripheral DB only blocks the tools that need it.
- *
- * **Structural drift-prevention (3 layers)**:
- *   - L1: TypeScript compile time — exhaustiveness check via `keyof TOOL_DB_NEEDS`.
- *   - L2: `tool-db-needs-completeness.test.ts` — TypeScript AST walk of every
- *         tool module verifies declared needs match actual DB access pattern.
- *         Aliasing/destructuring renames cannot bypass the AST walk.
- *   - L3: `scripts/massu-pattern-scanner.sh` Check 14 — grep-level enforcement
- *         that every tool in `getToolDefinitions()` has a manifest entry.
- *
- * **Adding a new MCP tool**:
- *   1. Register in `tools.ts` (CR-11).
- *   2. Add an entry here. Missing entries throw `UnknownToolError` at first
- *      dispatch AND fail L2 + L3 above.
- *
- * @see `docs/plans/2026-05-10-server-lazy-db-deps.md` (`plan-1.6.2-server-lazy-db-deps`)
- */
-
-/** SQLite connections the MCP server can resolve for a tool call. */
-export type DbNeed = 'codegraph' | 'data' | 'memory' | 'knowledge';
-
-/**
- * Custom error thrown when `getToolDbNeeds()` is called with a tool name that
- * isn't in the manifest. Caught at the JSON-RPC layer and translated to a
- * structured `-32602` (Invalid params) error to the client.
- */
-export class UnknownToolError extends Error {
-  readonly toolName: string;
-  constructor(toolName: string) {
-    super(`Tool not registered in TOOL_DB_NEEDS manifest: ${toolName}. Add an entry to packages/core/src/tool-db-needs.ts.`);
-    this.name = 'UnknownToolError';
-    this.toolName = toolName;
-  }
-}
-
-/**
- * Per-tool DB-need declarations. Keys are tool SHORT-NAMES (without the
- * `${toolPrefix}_` prefix). Values are the SQLite connections the handler
- * (or its routed module) actually accesses.
- *
- * Sourced from exhaustive grep of `packages/core/src/{*-tools,analytics,
- * cost-tracker,prompt-analyzer,audit-trail,validation-engine,adr-generator,
- * security-scorer,dependency-scorer,team-knowledge,regression-detector,
- * python-tools,license}.ts` on 2026-05-10. Verified line citations in
- * `docs/plans/2026-05-10-server-lazy-db-deps.md §1.4`.
- */
-export const TOOL_DB_NEEDS = {
-  // === Core code-intel tools (tools.ts:393-406) ===
-  // Use CodeGraph DB (read-only AST) + Data DB (Massu's import/trpc/sentinel
-  // tables). All call `ensureIndexes` directly or via shared infrastructure.
-  sync: ['codegraph', 'data'],
-  context: ['codegraph', 'data'],
-  coupling_check: ['codegraph', 'data'],
-  impact: ['codegraph', 'data'],
-  domains: ['codegraph', 'data'],
-
-  // P-H009 (plan-stage-c-high-batch): `trpc_map` queries Data DB tables
-  // populated by `ensureIndexes(d, codegraphDb)` — without CodeGraph the
-  // index never builds and the flagship code-intel tool silently returns
-  // "0 procedures" on fresh installs. Declaring `codegraph` here makes the
-  // dispatcher open the CodeGraph DB so `buildTrpcIndex` can run; the
-  // handler also surfaces an actionable hint when no procedures + no
-  // codegraph (covered by `trpc-map-empty-codegraph-hint.test.ts`).
-  trpc_map: ['codegraph', 'data'],
-
-  // `schema` reads filesystem (Prisma schema files); no DB access at all.
-  schema: [],
-
-  // === Memory tools (memory-tools.ts) ===
-  // Routed via `name.startsWith(pfx + '_memory_')` at tools.ts:284-290.
-  // Handler opens memory DB per-call (with try/finally close).
-  memory_search: ['memory'],
-  memory_timeline: ['memory'],
-  memory_detail: ['memory'],
-  memory_sessions: ['memory'],
-  memory_failures: ['memory'],
-  memory_ingest: ['memory'],
-  memory_backfill: ['memory'],
-
-  // === Observability tools (observability-tools.ts) ===
-  // Routed via `isObservabilityTool(name)` at tools.ts:294-300. Memory DB only.
-  session_replay: ['memory'],
-  session_stats: ['memory'],
-  tool_patterns: ['memory'],
-  prompt_analysis: ['memory'],
-
-  // === Docs tools (docs-tools.ts) ===
-  // Routed via `name.startsWith(pfx + '_docs_')` at tools.ts:303-306.
-  // No DB access — pure filesystem traversal.
-  docs_audit: [],
-  docs_coverage: [],
-
-  // === Sentinel registry tools (sentinel-tools.ts:180-184) ===
-  // Routed via `name.startsWith(pfx + '_sentinel_')` at tools.ts:308.
-  // Handler signature: `(name, args, dataDb)` — Data DB only.
-  sentinel_register: ['data'],
-  sentinel_validate: ['data'],
-  sentinel_search: ['data'],
-  sentinel_detail: ['data'],
-  sentinel_impact: ['data'],
-  sentinel_parity: ['data'],
-
-  // === Knowledge layer tools (knowledge-tools.ts) ===
-  // Routed via `isKnowledgeTool(name)` at tools.ts:372-376. Primary DB is
-  // `knowledgeDb` (separate SQLite file). Handlers ALSO call `getDataDb()`
-  // (knowledge-tools.ts:1187,1275) and `getMemoryDb()` (knowledge-tools.ts:1332)
-  // for cross-DB joins — declare all three so the AST completeness test
-  // (P-B-002) verifies the full access pattern.
-  knowledge_search: ['knowledge', 'data', 'memory'],
-  knowledge_pattern: ['knowledge', 'data', 'memory'],
-  knowledge_rule: ['knowledge', 'data', 'memory'],
-  knowledge_correct: ['knowledge', 'data', 'memory'],
-  knowledge_incident: ['knowledge', 'data', 'memory'],
-  knowledge_plan: ['knowledge', 'data', 'memory'],
-  knowledge_command: ['knowledge', 'data', 'memory'],
-  knowledge_gaps: ['knowledge', 'data', 'memory'],
-  knowledge_verification: ['knowledge', 'data', 'memory'],
-  knowledge_effectiveness: ['knowledge', 'data', 'memory'],
-  knowledge_graph: ['knowledge', 'data', 'memory'],
-  knowledge_schema_check: ['knowledge', 'data', 'memory'],
-
-  // === Analytics / quality (analytics.ts) ===
-  // Routed via `isAnalyticsTool(name)`. Memory DB only.
-  quality_score: ['memory'],
-  quality_report: ['memory'],
-  quality_trend: ['memory'],
-
-  // === Cost tracker (cost-tracker.ts) ===
-  cost_session: ['memory'],
-  cost_feature: ['memory'],
-  cost_trend: ['memory'],
-
-  // === Prompt analyzer (prompt-analyzer.ts) ===
-  prompt_effectiveness: ['memory'],
-  prompt_suggestions: ['memory'],
-
-  // === Audit trail (audit-trail.ts) ===
-  audit_chain: ['memory'],
-  audit_log: ['memory'],
-  audit_report: ['memory'],
-
-  // === Validation engine (validation-engine.ts) ===
-  validation_check: ['memory'],
-  validation_report: ['memory'],
-
-  // === ADR generator (adr-generator.ts) ===
-  adr_create: ['memory'],
-  adr_list: ['memory'],
-  adr_detail: ['memory'],
-
-  // === Security scorer (security-scorer.ts) ===
-  security_score: ['memory'],
-  security_heatmap: ['memory'],
-  security_trend: ['memory'],
-
-  // === Dependency scorer (dependency-scorer.ts) ===
-  dep_score: ['memory'],
-  dep_alternatives: ['memory'],
-
-  // === Team knowledge (team-knowledge.ts) ===
-  team_expertise: ['memory'],
-  team_conflicts: ['memory'],
-  team_search: ['memory'],
-
-  // === Regression detector (regression-detector.ts) ===
-  regression_risk: ['memory'],
-  feature_health: ['memory'],
-
-  // === Python code-intel tools (python-tools.ts) ===
-  // Routed via `isPythonTool(name)` at tools.ts:379-381. Data DB only.
-  py_imports: ['data'],
-  py_routes: ['data'],
-  py_models: ['data'],
-  py_migrations: ['data'],
-  py_coupling: ['data'],
-  py_context: ['data'],
-  py_impact: ['data'],
-  py_domains: ['data'],
-
-  // === License tool (license.ts) ===
-  license_status: ['memory'],
-} as const satisfies Readonly<Record<string, readonly DbNeed[]>>;
-
-/**
- * Configured tool-prefix-stripping helper. Pulled from the runtime config
- * so this module stays project-prefix-agnostic.
- */
-function stripConfiguredPrefix(toolName: string, prefix: string): string {
-  const pfx = `${prefix}_`;
-  return toolName.startsWith(pfx) ? toolName.slice(pfx.length) : toolName;
-}
-
-/**
- * Look up the DB needs for a tool by its full name (with prefix). Strips the
- * configured prefix and consults `TOOL_DB_NEEDS`. Throws `UnknownToolError`
- * for tool names not in the manifest — the dispatcher MUST catch this and
- * translate to a structured JSON-RPC error.
- *
- * @param toolName Full tool name including prefix (e.g., `"massu_memory_search"`)
- * @param prefix Tool prefix (e.g., `"massu"`) — read from config at dispatch time
- * @returns Array of DB connections the tool requires (may be empty)
- * @throws {UnknownToolError} if `stripPrefix(toolName)` not in the manifest
- */
-export function getToolDbNeeds(toolName: string, prefix: string): readonly DbNeed[] {
-  const shortName = stripConfiguredPrefix(toolName, prefix);
-  const needs = (TOOL_DB_NEEDS as Record<string, readonly DbNeed[]>)[shortName];
-  if (needs === undefined) {
-    throw new UnknownToolError(toolName);
-  }
-  return needs;
-}
-
-/** Convenience predicate: does a tool need CodeGraph DB? */
-export function toolNeedsCodegraph(toolName: string, prefix: string): boolean {
-  return getToolDbNeeds(toolName, prefix).includes('codegraph');
-}