sdlc-agent-4-enterprise-server 1.0.0

package/dist/engine/analyzers/entry-points/detectors/MainDetector.js

@@ -0,0 +1,51 @@
+/**
+ * KSA-162: Main Function Detector — Detects main() entry points.
+ */
+export class MainDetector {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    /** Detect main entry points from source code. */
+    detect(symbols, source, language) {
+        const mainPattern = this.registry.getMainPattern(language);
+        if (!mainPattern)
+            return [];
+        const results = [];
+        // Check for main function in symbols
+        for (const sym of symbols) {
+            if (sym.name === 'main' || sym.name === '__main__') {
+                results.push(this.createEntryPoint(sym));
+            }
+        }
+        // Check source for language-specific main patterns
+        if (results.length === 0 && source.includes(mainPattern.pattern)) {
+            const lines = source.split('\n');
+            const patternLine = lines.findIndex(l => l.includes(mainPattern.pattern));
+            if (patternLine >= 0) {
+                const closest = symbols.reduce((best, sym) => {
+                    if (!best)
+                        return sym;
+                    const bestDist = Math.abs(best.startLine - patternLine);
+                    const symDist = Math.abs(sym.startLine - patternLine);
+                    return symDist < bestDist ? sym : best;
+                }, null);
+                if (closest) {
+                    results.push(this.createEntryPoint(closest));
+                }
+            }
+        }
+        return results;
+    }
+    createEntryPoint(sym) {
+        return {
+            symbol_id: sym.id, symbol_name: sym.name,
+            file_path: sym.filePath, start_line: sym.startLine,
+            entry_type: 'MAIN', framework: null,
+            http_method: null, route_path: null, full_route: null,
+            middleware: [], has_auth: false, controller: null,
+            event_name: null, confidence: 'High',
+        };
+    }
+}
+//# sourceMappingURL=MainDetector.js.map

package/dist/engine/analyzers/entry-points/detectors/MainDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MainDetector.js","sourceRoot":"","sources":["../../../../../src/engine/analyzers/entry-points/detectors/MainDetector.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,OAAO,YAAY;IACf,QAAQ,CAAkB;IAElC,YAAY,QAAyB;QACnC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;IAED,iDAAiD;IACjD,MAAM,CACJ,OAAiF,EACjF,MAAc,EACd,QAAgB;QAEhB,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC3D,IAAI,CAAC,WAAW;YAAE,OAAO,EAAE,CAAC;QAE5B,MAAM,OAAO,GAAiB,EAAE,CAAC;QAEjC,qCAAqC;QACrC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,IAAI,GAAG,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBACnD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC;YAC3C,CAAC;QACH,CAAC;QAED,mDAAmD;QACnD,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;YACjE,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACjC,MAAM,WAAW,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC;YAC1E,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;gBACrB,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAA2B,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;oBACrE,IAAI,CAAC,IAAI;wBAAE,OAAO,GAAG,CAAC;oBACtB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,CAAC;oBACxD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,GAAG,WAAW,CAAC,CAAC;oBACtD,OAAO,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;gBACzC,CAAC,EAAE,IAAI,CAAC,CAAC;gBAET,IAAI,OAAO,EAAE,CAAC;oBACZ,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;gBAC/C,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAEO,gBAAgB,CAAC,GAAsE;QAC7F,OAAO;YACL,SAAS,EAAE,GAAG,CAAC,EAAE,EAAE,WAAW,EAAE,GAAG,CAAC,IAAI;YACxC,SAAS,EAAE,GAAG,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,CAAC,SAAS;YAClD,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI;YACnC,WAAW,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI;YACrD,UAAU,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI;YACjD,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM;SACrC,CAAC;IACJ,CAAC;CACF"}

package/dist/engine/analyzers/entry-points/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * KSA-162: Entry Point Detection Module — HTTP handlers, main, CLI, events.
+ */
+export { EntryPointDetector } from './EntryPointDetector.js';
+export { FrameworkDetector } from './FrameworkDetector.js';
+export { PatternRegistry } from './PatternRegistry.js';
+export { RouteResolver } from './RouteResolver.js';
+export { EntryPointStore } from './EntryPointStore.js';
+export { HTTPHandlerDetector } from './detectors/HTTPHandlerDetector.js';
+export { MainDetector } from './detectors/MainDetector.js';
+export { CLIDetector } from './detectors/CLIDetector.js';
+export { EventDetector } from './detectors/EventDetector.js';
+export { ENTRY_POINT_TOOL_DEFINITION, handleEntryPointTool } from './EntryPointTool.js';
+export type { EntryPoint, HTTPEntryPoint, EntryPointFilters, EntryPointQueryResult, RouteInfo, FrameworkInfo, } from './types.js';

package/dist/engine/analyzers/entry-points/index.js

@@ -0,0 +1,14 @@
+/**
+ * KSA-162: Entry Point Detection Module — HTTP handlers, main, CLI, events.
+ */
+export { EntryPointDetector } from './EntryPointDetector.js';
+export { FrameworkDetector } from './FrameworkDetector.js';
+export { PatternRegistry } from './PatternRegistry.js';
+export { RouteResolver } from './RouteResolver.js';
+export { EntryPointStore } from './EntryPointStore.js';
+export { HTTPHandlerDetector } from './detectors/HTTPHandlerDetector.js';
+export { MainDetector } from './detectors/MainDetector.js';
+export { CLIDetector } from './detectors/CLIDetector.js';
+export { EventDetector } from './detectors/EventDetector.js';
+export { ENTRY_POINT_TOOL_DEFINITION, handleEntryPointTool } from './EntryPointTool.js';
+//# sourceMappingURL=index.js.map

package/dist/engine/analyzers/entry-points/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/engine/analyzers/entry-points/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,2BAA2B,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/engine/analyzers/entry-points/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * KSA-162: Entry Point Detection — Type definitions.
+ */
+export type EntryType = 'HTTP_HANDLER' | 'MAIN' | 'CLI_COMMAND' | 'EVENT_HANDLER' | 'SCHEDULED';
+export interface EntryPoint {
+    symbol_id: number;
+    symbol_name: string;
+    file_path: string;
+    start_line: number;
+    entry_type: EntryType;
+    framework: string | null;
+    http_method: string | null;
+    route_path: string | null;
+    full_route: string | null;
+    middleware: string[];
+    has_auth: boolean;
+    controller: string | null;
+    event_name: string | null;
+    confidence: 'High' | 'Medium' | 'Low';
+}
+export interface HTTPEntryPoint extends EntryPoint {
+    entry_type: 'HTTP_HANDLER';
+    http_method: string;
+    route_path: string;
+    full_route: string;
+}
+export interface RouteInfo {
+    method: string;
+    path: string;
+    fullRoute: string;
+}
+export interface FrameworkInfo {
+    name: string;
+    language: string;
+    confidence: 'High' | 'Medium' | 'Low';
+}
+export interface EntryPointFilters {
+    entryType?: EntryType;
+    framework?: string;
+    httpMethod?: string;
+    routePattern?: string;
+    hasAuth?: boolean;
+    filePath?: string;
+    limit: number;
+}
+export interface EntryPointQueryResult {
+    results: EntryPoint[];
+    total: number;
+    summary: {
+        byType: Record<string, number>;
+        byFramework: Record<string, number>;
+        authCoverage: {
+            withAuth: number;
+            withoutAuth: number;
+        };
+    };
+}
+export interface FrameworkPatterns {
+    language: string;
+    imports: string[];
+    decorators?: {
+        handler: string[];
+        prefix?: string[];
+    };
+    call_patterns?: {
+        handler: string[];
+        mount?: string[];
+    };
+    auth_indicators: string[];
+}
+export interface PatternConfig {
+    frameworks: Record<string, FrameworkPatterns>;
+    main_patterns: Record<string, {
+        pattern: string;
+        type: string;
+    }>;
+}

package/dist/engine/analyzers/entry-points/types.js

@@ -0,0 +1,5 @@
+/**
+ * KSA-162: Entry Point Detection — Type definitions.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/engine/analyzers/entry-points/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/engine/analyzers/entry-points/types.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/engine/analyzers/graph-analysis/CircularDepDetector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * KSA-163: Circular Dependency Detector using Tarjan's SCC.
+ */
+import type { CircularDep } from './types.js';
+import { GraphLoader } from './utils/GraphLoader.js';
+export declare class CircularDepDetector {
+    private graphLoader;
+    constructor(graphLoader: GraphLoader);
+    /** Find all circular dependencies in the codebase. */
+    detect(options?: {
+        module?: string;
+        maxLength?: number;
+    }): CircularDep[];
+    private extractCycleChain;
+    private classifySeverity;
+}

package/dist/engine/analyzers/graph-analysis/CircularDepDetector.js

@@ -0,0 +1,80 @@
+/**
+ * KSA-163: Circular Dependency Detector using Tarjan's SCC.
+ */
+import { TarjanSCC } from './utils/TarjanSCC.js';
+export class CircularDepDetector {
+    graphLoader;
+    constructor(graphLoader) {
+        this.graphLoader = graphLoader;
+    }
+    /** Find all circular dependencies in the codebase. */
+    detect(options = {}) {
+        const graph = this.graphLoader.loadDependencyGraph(options.module);
+        if (graph.size === 0)
+            return [];
+        const tarjan = new TarjanSCC();
+        const sccs = tarjan.findSCCs(graph);
+        const results = [];
+        for (const scc of sccs) {
+            if (options.maxLength && scc.length > options.maxLength)
+                continue;
+            const cycle = this.extractCycleChain(scc, graph);
+            results.push({
+                cycle,
+                length: scc.length,
+                severity: this.classifySeverity(scc.length),
+                module: options.module,
+            });
+        }
+        // Sort by severity (high first) then by length
+        return results.sort((a, b) => {
+            const sevOrder = { high: 0, medium: 1, low: 2 };
+            const sevDiff = sevOrder[a.severity] - sevOrder[b.severity];
+            return sevDiff !== 0 ? sevDiff : a.length - b.length;
+        });
+    }
+    extractCycleChain(scc, graph) {
+        // Get symbol info for all nodes in the SCC
+        const symbolInfos = this.graphLoader.getSymbolInfoBatch(scc);
+        const sccSet = new Set(scc);
+        const nodes = [];
+        const edges = [];
+        // Build ordered cycle by following edges within the SCC
+        const visited = new Set();
+        const ordered = [];
+        let current = scc[0];
+        while (!visited.has(current)) {
+            visited.add(current);
+            ordered.push(current);
+            const neighbors = graph.get(current) || [];
+            const next = neighbors.find(n => sccSet.has(n) && !visited.has(n));
+            if (next === undefined)
+                break;
+            current = next;
+        }
+        // If we didn't visit all, just use original order
+        const finalOrder = ordered.length === scc.length ? ordered : scc;
+        for (let i = 0; i < finalOrder.length; i++) {
+            const id = finalOrder[i];
+            const info = symbolInfos.get(id);
+            nodes.push({
+                symbolId: id,
+                name: info?.name ?? `symbol_${id}`,
+                filePath: info?.filePath ?? 'unknown',
+                kind: info?.kind ?? 'unknown',
+            });
+            const nextId = finalOrder[(i + 1) % finalOrder.length];
+            const nextInfo = symbolInfos.get(nextId);
+            edges.push(`${info?.name ?? id} → ${nextInfo?.name ?? nextId}`);
+        }
+        return { nodes, edges };
+    }
+    classifySeverity(length) {
+        if (length <= 2)
+            return 'high'; // Direct mutual dependency
+        if (length <= 4)
+            return 'medium'; // Short cycle
+        return 'low'; // Long cycle (less impactful)
+    }
+}
+//# sourceMappingURL=CircularDepDetector.js.map

package/dist/engine/analyzers/graph-analysis/CircularDepDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CircularDepDetector.js","sourceRoot":"","sources":["../../../../src/engine/analyzers/graph-analysis/CircularDepDetector.ts"],"names":[],"mappings":"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"}

package/dist/engine/analyzers/graph-analysis/DeadImportDetector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * KSA-163: Dead Import Detector — Finds unused imports.
+ */
+import Database from 'better-sqlite3';
+import type { DeadImport } from './types.js';
+export declare class DeadImportDetector {
+    private db;
+    constructor(db: Database.Database);
+    /** Find dead (unused) imports in a file or across the project. */
+    detect(options?: {
+        filePath?: string;
+        module?: string;
+        limit?: number;
+    }): DeadImport[];
+}

package/dist/engine/analyzers/graph-analysis/DeadImportDetector.js

@@ -0,0 +1,56 @@
+/**
+ * KSA-163: Dead Import Detector — Finds unused imports.
+ */
+export class DeadImportDetector {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Find dead (unused) imports in a file or across the project. */
+    detect(options = {}) {
+        const limit = options.limit ?? 50;
+        // Find imports where the target symbol is never referenced elsewhere in the same file
+        let sql = `
+      SELECT r.file_path as filePath, r.line, r.target_symbol as importedSymbol,
+             r.metadata
+      FROM relationships r
+      WHERE r.kind = 'imports'
+        AND NOT EXISTS (
+          SELECT 1 FROM relationships r2
+          WHERE r2.file_path = r.file_path
+            AND r2.kind IN ('calls', 'uses')
+            AND r2.target_symbol = r.target_symbol
+            AND r2.id != r.id
+        )
+    `;
+        const params = [];
+        if (options.filePath) {
+            sql += ' AND r.file_path LIKE ?';
+            params.push(`%${options.filePath}%`);
+        }
+        if (options.module) {
+            sql += ' AND r.file_path LIKE ?';
+            params.push(`%${options.module}%`);
+        }
+        sql += ' ORDER BY r.file_path, r.line LIMIT ?';
+        params.push(limit);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(row => {
+            let fromModule = '';
+            if (row.metadata) {
+                try {
+                    const meta = JSON.parse(row.metadata);
+                    fromModule = meta.source ?? meta.from ?? '';
+                }
+                catch { /* ignore */ }
+            }
+            return {
+                filePath: row.filePath,
+                line: row.line,
+                importedSymbol: row.importedSymbol,
+                fromModule,
+            };
+        });
+    }
+}
+//# sourceMappingURL=DeadImportDetector.js.map

package/dist/engine/analyzers/graph-analysis/DeadImportDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeadImportDetector.js","sourceRoot":"","sources":["../../../../src/engine/analyzers/graph-analysis/DeadImportDetector.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,OAAO,kBAAkB;IACrB,EAAE,CAAoB;IAE9B,YAAY,EAAqB;QAC/B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;IAED,kEAAkE;IAClE,MAAM,CAAC,UAAkE,EAAE;QACzE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC;QAElC,sFAAsF;QACtF,IAAI,GAAG,GAAG;;;;;;;;;;;;KAYT,CAAC;QACF,MAAM,MAAM,GAAc,EAAE,CAAC;QAE7B,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,GAAG,IAAI,yBAAyB,CAAC;YACjC,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;QACvC,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,GAAG,IAAI,yBAAyB,CAAC;YACjC,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QACrC,CAAC;QAED,GAAG,IAAI,uCAAuC,CAAC;QAC/C,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEnB,MAAM,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,MAAM,CAK7C,CAAC;QAEH,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;YACpB,IAAI,UAAU,GAAG,EAAE,CAAC;YACpB,IAAI,GAAG,CAAC,QAAQ,EAAE,CAAC;gBACjB,IAAI,CAAC;oBACH,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;oBACtC,UAAU,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;gBAC9C,CAAC;gBAAC,MAAM,CAAC,CAAC,YAAY,CAAC,CAAC;YAC1B,CAAC;YACD,OAAO;gBACL,QAAQ,EAAE,GAAG,CAAC,QAAQ;gBACtB,IAAI,EAAE,GAAG,CAAC,IAAI;gBACd,cAAc,EAAE,GAAG,CAAC,cAAc;gBAClC,UAAU;aACX,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/engine/analyzers/graph-analysis/GraphAnalysisTools.d.ts

@@ -0,0 +1,123 @@
+/**
+ * KSA-163: MCP Tool registrations for graph analysis tools.
+ */
+import Database from 'better-sqlite3';
+export declare const GRAPH_ANALYSIS_TOOL_DEFINITIONS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            module: {
+                type: string;
+                description: string;
+            };
+            max_length: {
+                type: string;
+                description: string;
+            };
+            symbol_name?: undefined;
+            file_path?: undefined;
+            max_depth?: undefined;
+            limit?: undefined;
+            min_callers?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            symbol_name: {
+                type: string;
+                description: string;
+            };
+            file_path: {
+                type: string;
+                description: string;
+            };
+            max_depth: {
+                type: string;
+                description: string;
+            };
+            module?: undefined;
+            max_length?: undefined;
+            limit?: undefined;
+            min_callers?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            module: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            min_callers: {
+                type: string;
+                description: string;
+            };
+            max_length?: undefined;
+            symbol_name?: undefined;
+            file_path?: undefined;
+            max_depth?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            file_path: {
+                type: string;
+                description: string;
+            };
+            module: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            max_length?: undefined;
+            symbol_name?: undefined;
+            max_depth?: undefined;
+            min_callers?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            module: {
+                type: string;
+                description: string;
+            };
+            max_length?: undefined;
+            symbol_name?: undefined;
+            file_path?: undefined;
+            max_depth?: undefined;
+            limit?: undefined;
+            min_callers?: undefined;
+        };
+        required?: undefined;
+    };
+})[];
+/** Dispatch a graph analysis tool call. */
+export declare function handleGraphAnalysisTool(name: string, args: Record<string, unknown>, db: Database.Database): string | null;

package/dist/engine/analyzers/graph-analysis/GraphAnalysisTools.js

@@ -0,0 +1,187 @@
+/**
+ * KSA-163: MCP Tool registrations for graph analysis tools.
+ */
+import { GraphLoader } from './utils/GraphLoader.js';
+import { CircularDepDetector } from './CircularDepDetector.js';
+import { RelatedTestFinder } from './RelatedTestFinder.js';
+import { HotPathAnalyzer } from './HotPathAnalyzer.js';
+import { DeadImportDetector } from './DeadImportDetector.js';
+import { ModuleSummarizer } from './ModuleSummarizer.js';
+export const GRAPH_ANALYSIS_TOOL_DEFINITIONS = [
+    {
+        name: 'find_circular_deps',
+        description: 'Find circular dependencies in the codebase using Tarjan\'s SCC algorithm.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                module: { type: 'string', description: 'Filter by module name' },
+                max_length: { type: 'number', description: 'Max cycle length to report (default: unlimited)' },
+            },
+        },
+    },
+    {
+        name: 'find_related_tests',
+        description: 'Find test files/functions that test a given symbol (reverse BFS on call graph).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                symbol_name: { type: 'string', description: 'Symbol name to find tests for' },
+                file_path: { type: 'string', description: 'File path to disambiguate symbol' },
+                max_depth: { type: 'number', description: 'Max call chain depth (default: 3)' },
+            },
+            required: ['symbol_name'],
+        },
+    },
+    {
+        name: 'find_hot_paths',
+        description: 'Find most-called functions (hot paths) by transitive caller count.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                module: { type: 'string', description: 'Filter by module name' },
+                limit: { type: 'number', description: 'Max results (default: 20)' },
+                min_callers: { type: 'number', description: 'Minimum direct callers threshold (default: 2)' },
+            },
+        },
+    },
+    {
+        name: 'find_dead_imports',
+        description: 'Find unused/dead imports in the codebase.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                file_path: { type: 'string', description: 'Filter by file path' },
+                module: { type: 'string', description: 'Filter by module name' },
+                limit: { type: 'number', description: 'Max results (default: 50)' },
+            },
+        },
+    },
+    {
+        name: 'module_summary',
+        description: 'Get quality summary for a module: circular deps, hot paths, dead imports, avg complexity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                module: { type: 'string', description: 'Module name (omit for all modules)' },
+            },
+        },
+    },
+];
+/** Dispatch a graph analysis tool call. */
+export function handleGraphAnalysisTool(name, args, db) {
+    const graphLoader = new GraphLoader(db);
+    switch (name) {
+        case 'find_circular_deps':
+            return handleCircularDeps(args, graphLoader);
+        case 'find_related_tests':
+            return handleRelatedTests(args, graphLoader);
+        case 'find_hot_paths':
+            return handleHotPaths(args, graphLoader);
+        case 'find_dead_imports':
+            return handleDeadImports(args, db);
+        case 'module_summary':
+            return handleModuleSummary(args, db);
+        default:
+            return null;
+    }
+}
+function handleCircularDeps(args, graphLoader) {
+    const detector = new CircularDepDetector(graphLoader);
+    const results = detector.detect({
+        module: args.module,
+        maxLength: args.max_length,
+    });
+    if (results.length === 0)
+        return 'No circular dependencies found.';
+    const lines = [`Found ${results.length} circular dependencies:\n`];
+    for (const dep of results) {
+        lines.push(`[${dep.severity.toUpperCase()}] Cycle (length ${dep.length}):`);
+        lines.push(`  ${dep.cycle.edges.join(' → ')}`);
+        for (const node of dep.cycle.nodes) {
+            lines.push(`    - ${node.name} (${node.kind}) — ${node.filePath}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function handleRelatedTests(args, graphLoader) {
+    const symbolName = args.symbol_name;
+    if (!symbolName)
+        return 'Parameter "symbol_name" is required.';
+    const finder = new RelatedTestFinder(graphLoader);
+    const result = finder.find(symbolName, {
+        maxDepth: args.max_depth,
+        filePath: args.file_path,
+    });
+    if (!result)
+        return `Symbol "${symbolName}" not found in index.`;
+    if (result.totalTests === 0)
+        return `No tests found for "${symbolName}".`;
+    const lines = [
+        `Tests for ${result.symbol.name} (${result.symbol.filePath}):\n`,
+        `Direct tests (${result.directTests.length}):`,
+    ];
+    for (const t of result.directTests) {
+        lines.push(`  ✓ ${t.testName} — ${t.filePath}`);
+    }
+    if (result.indirectTests.length > 0) {
+        lines.push(`\nIndirect tests (${result.indirectTests.length}):`);
+        for (const t of result.indirectTests) {
+            lines.push(`  ○ ${t.testName} — ${t.filePath} (depth: ${t.depth})`);
+            lines.push(`    Chain: ${t.path.join(' → ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+function handleHotPaths(args, graphLoader) {
+    const analyzer = new HotPathAnalyzer(graphLoader);
+    const results = analyzer.analyze({
+        module: args.module,
+        limit: args.limit,
+        minCallers: args.min_callers,
+    });
+    if (results.length === 0)
+        return 'No hot paths found (no functions with multiple callers).';
+    const lines = [`Hot Paths — Top ${results.length} most-called functions:\n`];
+    for (let i = 0; i < results.length; i++) {
+        const hp = results[i];
+        lines.push(`${i + 1}. ${hp.symbolName} (${hp.kind}) — ` +
+            `${hp.directCallers} direct, ${hp.transitiveCallers} transitive callers`);
+        lines.push(`   ${hp.filePath}`);
+    }
+    return lines.join('\n');
+}
+function handleDeadImports(args, db) {
+    const detector = new DeadImportDetector(db);
+    const results = detector.detect({
+        filePath: args.file_path,
+        module: args.module,
+        limit: args.limit,
+    });
+    if (results.length === 0)
+        return 'No dead imports found.';
+    const lines = [`Found ${results.length} potentially unused imports:\n`];
+    for (const imp of results) {
+        lines.push(`  ${imp.filePath}:${imp.line} — ${imp.importedSymbol}${imp.fromModule ? ` from "${imp.fromModule}"` : ''}`);
+    }
+    return lines.join('\n');
+}
+function handleModuleSummary(args, db) {
+    const summarizer = new ModuleSummarizer(db);
+    const results = summarizer.summarize(args.module);
+    if (results.length === 0)
+        return 'No modules found.';
+    const lines = [`Module Quality Summary (${results.length} modules):\n`];
+    for (const mod of results) {
+        lines.push(`📦 ${mod.module}`);
+        lines.push(`   Files: ${mod.fileCount} | Symbols: ${mod.symbolCount}`);
+        lines.push(`   Circular Deps: ${mod.circularDeps} | Dead Imports: ${mod.deadImports}`);
+        lines.push(`   Avg Complexity: ${mod.avgComplexity?.toFixed(1) ?? 'N/A'}`);
+        if (mod.hotPaths.length > 0) {
+            lines.push(`   Hot Paths: ${mod.hotPaths.map(h => h.symbolName).join(', ')}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=GraphAnalysisTools.js.map