sdlc-agent-4-enterprise-server 1.0.0

package/dist/engine/analyzers/complexity/ComplexityCalculator.js

@@ -0,0 +1,54 @@
+/**
+ * KSA-161: Core complexity calculation engine.
+ * Delegates to language-specific counters via strategy pattern.
+ */
+import { TypeScriptCounter } from './counters/TypeScriptCounter.js';
+import { PythonCounter } from './counters/PythonCounter.js';
+import { JavaCounter } from './counters/JavaCounter.js';
+import { KotlinCounter } from './counters/KotlinCounter.js';
+import { GoCounter } from './counters/GoCounter.js';
+export class ComplexityCalculator {
+    counters = new Map();
+    constructor() {
+        // Register built-in counters
+        this.registerCounter(new TypeScriptCounter());
+        this.registerCounter(new PythonCounter());
+        this.registerCounter(new JavaCounter());
+        this.registerCounter(new KotlinCounter());
+        this.registerCounter(new GoCounter());
+        // JS uses same rules as TS
+        this.counters.set('javascript', new TypeScriptCounter());
+    }
+    /** Register a language-specific counter. */
+    registerCounter(counter) {
+        this.counters.set(counter.language, counter);
+    }
+    /** Calculate cyclomatic complexity for a function body AST node. */
+    calculate(bodyNode, language) {
+        const counter = this.counters.get(language);
+        if (!counter)
+            return null;
+        const counts = counter.countDecisionPoints(bodyNode);
+        const nestingDepth = counter.calculateNestingDepth(bodyNode);
+        const earlyReturns = counter.countEarlyReturns(bodyNode);
+        const cc = 1 + counts.branches + counts.loops + counts.logical_ops + counts.exception_handlers;
+        return {
+            cyclomatic_complexity: cc,
+            branches: counts.branches,
+            loops: counts.loops,
+            logical_ops: counts.logical_ops,
+            exception_handlers: counts.exception_handlers,
+            nesting_depth: nestingDepth,
+            early_returns: earlyReturns,
+        };
+    }
+    /** Check if a language is supported. */
+    supportsLanguage(language) {
+        return this.counters.has(language);
+    }
+    /** Get list of supported languages. */
+    getSupportedLanguages() {
+        return [...this.counters.keys()];
+    }
+}
+//# sourceMappingURL=ComplexityCalculator.js.map

package/dist/engine/analyzers/complexity/ComplexityCalculator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComplexityCalculator.js","sourceRoot":"","sources":["../../../../src/engine/analyzers/complexity/ComplexityCalculator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,MAAM,OAAO,oBAAoB;IACvB,QAAQ,GAAiC,IAAI,GAAG,EAAE,CAAC;IAE3D;QACE,6BAA6B;QAC7B,IAAI,CAAC,eAAe,CAAC,IAAI,iBAAiB,EAAE,CAAC,CAAC;QAC9C,IAAI,CAAC,eAAe,CAAC,IAAI,aAAa,EAAE,CAAC,CAAC;QAC1C,IAAI,CAAC,eAAe,CAAC,IAAI,WAAW,EAAE,CAAC,CAAC;QACxC,IAAI,CAAC,eAAe,CAAC,IAAI,aAAa,EAAE,CAAC,CAAC;QAC1C,IAAI,CAAC,eAAe,CAAC,IAAI,SAAS,EAAE,CAAC,CAAC;QACtC,2BAA2B;QAC3B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,iBAAiB,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED,4CAA4C;IAC5C,eAAe,CAAC,OAAwB;QACtC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED,oEAAoE;IACpE,SAAS,CAAC,QAAoB,EAAE,QAAgB;QAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC5C,IAAI,CAAC,OAAO;YAAE,OAAO,IAAI,CAAC;QAE1B,MAAM,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;QACrD,MAAM,YAAY,GAAG,OAAO,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC;QAC7D,MAAM,YAAY,GAAG,OAAO,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC;QAEzD,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,kBAAkB,CAAC;QAE/F,OAAO;YACL,qBAAqB,EAAE,EAAE;YACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;YACzB,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,kBAAkB,EAAE,MAAM,CAAC,kBAAkB;YAC7C,aAAa,EAAE,YAAY;YAC3B,aAAa,EAAE,YAAY;SAC5B,CAAC;IACJ,CAAC;IAED,wCAAwC;IACxC,gBAAgB,CAAC,QAAgB;QAC/B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACrC,CAAC;IAED,uCAAuC;IACvC,qBAAqB;QACnB,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACnC,CAAC;CACF"}

package/dist/engine/analyzers/complexity/ComplexityStore.d.ts

@@ -0,0 +1,22 @@
+/**
+ * KSA-161: SQLite CRUD for complexity results.
+ */
+import Database from 'better-sqlite3';
+import type { ComplexityResult, ComplexityFilters, ComplexityQueryResult } from './types.js';
+export declare class ComplexityStore {
+    private db;
+    private stmts;
+    constructor(db: Database.Database);
+    /** Store or update complexity result for a symbol. */
+    upsert(result: ComplexityResult): void;
+    /** Batch upsert complexity results. */
+    upsertBatch(results: ComplexityResult[]): void;
+    /** Get complexity for a specific symbol. */
+    getBySymbol(symbolId: number): ComplexityResult | null;
+    /** Query complexity results with filters. */
+    query(filters: ComplexityFilters): ComplexityQueryResult;
+    /** Delete complexity data for a symbol. */
+    deleteBySymbol(symbolId: number): void;
+    private ensureTable;
+    private prepareStatements;
+}

package/dist/engine/analyzers/complexity/ComplexityStore.js

@@ -0,0 +1,152 @@
+/**
+ * KSA-161: SQLite CRUD for complexity results.
+ */
+const CREATE_TABLE = `
+CREATE TABLE IF NOT EXISTS complexity (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  symbol_id INTEGER NOT NULL,
+  cyclomatic_complexity INTEGER NOT NULL DEFAULT 1,
+  branches INTEGER NOT NULL DEFAULT 0,
+  loops INTEGER NOT NULL DEFAULT 0,
+  logical_ops INTEGER NOT NULL DEFAULT 0,
+  nesting_depth INTEGER NOT NULL DEFAULT 0,
+  early_returns INTEGER NOT NULL DEFAULT 0,
+  exception_handlers INTEGER NOT NULL DEFAULT 0,
+  grade TEXT NOT NULL DEFAULT 'A',
+  computed_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (symbol_id) REFERENCES symbols(id) ON DELETE CASCADE,
+  UNIQUE(symbol_id)
+);
+CREATE INDEX IF NOT EXISTS idx_complexity_grade ON complexity(grade);
+CREATE INDEX IF NOT EXISTS idx_complexity_cc ON complexity(cyclomatic_complexity DESC);
+CREATE INDEX IF NOT EXISTS idx_complexity_symbol ON complexity(symbol_id);
+`;
+export class ComplexityStore {
+    db;
+    stmts;
+    constructor(db) {
+        this.db = db;
+        this.ensureTable();
+        this.prepareStatements();
+    }
+    /** Store or update complexity result for a symbol. */
+    upsert(result) {
+        this.stmts.upsert.run(result.symbol_id, result.cyclomatic_complexity, result.branches, result.loops, result.logical_ops, result.nesting_depth, result.early_returns, result.exception_handlers, result.grade);
+    }
+    /** Batch upsert complexity results. */
+    upsertBatch(results) {
+        const transaction = this.db.transaction((items) => {
+            for (const r of items)
+                this.upsert(r);
+        });
+        transaction(results);
+    }
+    /** Get complexity for a specific symbol. */
+    getBySymbol(symbolId) {
+        return this.stmts.getBySymbol.get(symbolId) ?? null;
+    }
+    /** Query complexity results with filters. */
+    query(filters) {
+        let sql = `
+      SELECT c.*, s.name as symbol_name, f.relative_path as file_path,
+             s.start_line, s.end_line
+      FROM complexity c
+      JOIN symbols s ON s.id = c.symbol_id
+      JOIN files f ON f.id = s.file_id
+      WHERE 1=1
+    `;
+        const params = [];
+        if (filters.filePath) {
+            sql += ' AND f.relative_path LIKE ?';
+            params.push(`%${filters.filePath}%`);
+        }
+        if (filters.symbolName) {
+            sql += ' AND s.name LIKE ?';
+            params.push(`%${filters.symbolName}%`);
+        }
+        if (filters.minComplexity !== undefined) {
+            sql += ' AND c.cyclomatic_complexity >= ?';
+            params.push(filters.minComplexity);
+        }
+        if (filters.gradeFilter && filters.gradeFilter.length > 0) {
+            const placeholders = filters.gradeFilter.map(() => '?').join(',');
+            sql += ` AND c.grade IN (${placeholders})`;
+            params.push(...filters.gradeFilter);
+        }
+        if (filters.module) {
+            sql += ' AND f.module = ?';
+            params.push(filters.module);
+        }
+        // Count total before limit
+        const countSql = sql.replace(/SELECT c\.\*.*?FROM/, 'SELECT COUNT(*) as total FROM');
+        const totalRow = this.db.prepare(countSql).get(...params);
+        const total = totalRow?.total ?? 0;
+        // Sort and limit
+        switch (filters.sortBy) {
+            case 'name':
+                sql += ' ORDER BY s.name ASC';
+                break;
+            case 'file':
+                sql += ' ORDER BY f.relative_path ASC, s.start_line ASC';
+                break;
+            default:
+                sql += ' ORDER BY c.cyclomatic_complexity DESC';
+                break;
+        }
+        sql += ' LIMIT ?';
+        params.push(filters.limit);
+        const results = this.db.prepare(sql).all(...params);
+        // Grade distribution
+        const distSql = `
+      SELECT c.grade, COUNT(*) as count
+      FROM complexity c
+      JOIN symbols s ON s.id = c.symbol_id
+      JOIN files f ON f.id = s.file_id
+      WHERE 1=1 ${filters.module ? 'AND f.module = ?' : ''}
+      GROUP BY c.grade
+    `;
+        const distParams = filters.module ? [filters.module] : [];
+        const distRows = this.db.prepare(distSql).all(...distParams);
+        const gradeDistribution = { A: 0, B: 0, C: 0, D: 0, F: 0 };
+        for (const row of distRows)
+            gradeDistribution[row.grade] = row.count;
+        // Average
+        const avgSql = `SELECT AVG(cyclomatic_complexity) as avg FROM complexity`;
+        const avgRow = this.db.prepare(avgSql).get();
+        return {
+            results,
+            total,
+            summary: {
+                average: avgRow?.avg ?? 0,
+                gradeDistribution,
+            },
+        };
+    }
+    /** Delete complexity data for a symbol. */
+    deleteBySymbol(symbolId) {
+        this.stmts.deleteBySymbol.run(symbolId);
+    }
+    ensureTable() {
+        this.db.exec(CREATE_TABLE);
+    }
+    prepareStatements() {
+        this.stmts = {
+            upsert: this.db.prepare(`
+        INSERT OR REPLACE INTO complexity
+          (symbol_id, cyclomatic_complexity, branches, loops, logical_ops,
+           nesting_depth, early_returns, exception_handlers, grade, computed_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+      `),
+            getBySymbol: this.db.prepare(`
+        SELECT c.*, s.name as symbol_name, f.relative_path as file_path,
+               s.start_line, s.end_line
+        FROM complexity c
+        JOIN symbols s ON s.id = c.symbol_id
+        JOIN files f ON f.id = s.file_id
+        WHERE c.symbol_id = ?
+      `),
+            deleteBySymbol: this.db.prepare('DELETE FROM complexity WHERE symbol_id = ?'),
+        };
+    }
+}
+//# sourceMappingURL=ComplexityStore.js.map

package/dist/engine/analyzers/complexity/ComplexityStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ComplexityStore.js","sourceRoot":"","sources":["../../../../src/engine/analyzers/complexity/ComplexityStore.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,YAAY,GAAG;;;;;;;;;;;;;;;;;;;CAmBpB,CAAC;AAEF,MAAM,OAAO,eAAe;IAClB,EAAE,CAAoB;IACtB,KAAK,CAIX;IAEF,YAAY,EAAqB;QAC/B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC3B,CAAC;IAED,sDAAsD;IACtD,MAAM,CAAC,MAAwB;QAC7B,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CACnB,MAAM,CAAC,SAAS,EAChB,MAAM,CAAC,qBAAqB,EAC5B,MAAM,CAAC,QAAQ,EACf,MAAM,CAAC,KAAK,EACZ,MAAM,CAAC,WAAW,EAClB,MAAM,CAAC,aAAa,EACpB,MAAM,CAAC,aAAa,EACpB,MAAM,CAAC,kBAAkB,EACzB,MAAM,CAAC,KAAK,CACb,CAAC;IACJ,CAAC;IAED,uCAAuC;IACvC,WAAW,CAAC,OAA2B;QACrC,MAAM,WAAW,GAAG,IAAI,CAAC,EAAE,CAAC,WAAW,CAAC,CAAC,KAAyB,EAAE,EAAE;YACpE,KAAK,MAAM,CAAC,IAAI,KAAK;gBAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;QACH,WAAW,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,4CAA4C;IAC5C,WAAW,CAAC,QAAgB;QAC1B,OAAQ,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,GAAG,CAAC,QAAQ,CAAsB,IAAI,IAAI,CAAC;IAC5E,CAAC;IAED,6CAA6C;IAC7C,KAAK,CAAC,OAA0B;QAC9B,IAAI,GAAG,GAAG;;;;;;;KAOT,CAAC;QACF,MAAM,MAAM,GAAc,EAAE,CAAC;QAE7B,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,GAAG,IAAI,6BAA6B,CAAC;YACrC,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;QACvC,CAAC;QACD,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YACvB,GAAG,IAAI,oBAAoB,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,UAAU,GAAG,CAAC,CAAC;QACzC,CAAC;QACD,IAAI,OAAO,CAAC,aAAa,KAAK,SAAS,EAAE,CAAC;YACxC,GAAG,IAAI,mCAAmC,CAAC;YAC3C,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACrC,CAAC;QACD,IAAI,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1D,MAAM,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAClE,GAAG,IAAI,oBAAoB,YAAY,GAAG,CAAC;YAC3C,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YACnB,GAAG,IAAI,mBAAmB,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;QAED,2BAA2B;QAC3B,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,+BAA+B,CAAC,CAAC;QACrF,MAAM,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,GAAG,MAAM,CAAkC,CAAC;QAC3F,MAAM,KAAK,GAAG,QAAQ,EAAE,KAAK,IAAI,CAAC,CAAC;QAEnC,iBAAiB;QACjB,QAAQ,OAAO,CAAC,MAAM,EAAE,CAAC;YACvB,KAAK,MAAM;gBAAE,GAAG,IAAI,sBAAsB,CAAC;gBAAC,MAAM;YAClD,KAAK,MAAM;gBAAE,GAAG,IAAI,iDAAiD,CAAC;gBAAC,MAAM;YAC7E;gBAAS,GAAG,IAAI,wCAAwC,CAAC;gBAAC,MAAM;QAClE,CAAC;QACD,GAAG,IAAI,UAAU,CAAC;QAClB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QAE3B,MAAM,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,MAAM,CAAuB,CAAC;QAE1E,qBAAqB;QACrB,MAAM,OAAO,GAAG;;;;;kBAKF,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE;;KAErD,CAAC;QACF,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC1D,MAAM,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,GAAG,UAAU,CAAsC,CAAC;QAClG,MAAM,iBAAiB,GAA0B,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QAClF,KAAK,MAAM,GAAG,IAAI,QAAQ;YAAE,iBAAiB,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC;QAErE,UAAU;QACV,MAAM,MAAM,GAAG,0DAA0D,CAAC;QAC1E,MAAM,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAA4B,CAAC;QAEvE,OAAO;YACL,OAAO;YACP,KAAK;YACL,OAAO,EAAE;gBACP,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;gBACzB,iBAAiB;aAClB;SACF,CAAC;IACJ,CAAC;IAED,2CAA2C;IAC3C,cAAc,CAAC,QAAgB;QAC7B,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAEO,WAAW;QACjB,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAC7B,CAAC;IAEO,iBAAiB;QACvB,IAAI,CAAC,KAAK,GAAG;YACX,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC;;;;;OAKvB,CAAC;YACF,WAAW,EAAE,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC;;;;;;;OAO5B,CAAC;YACF,cAAc,EAAE,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,4CAA4C,CAAC;SAC9E,CAAC;IACJ,CAAC;CACF"}

package/dist/engine/analyzers/complexity/ComplexityTool.d.ts

@@ -0,0 +1,45 @@
+/**
+ * KSA-161: MCP Tool registration for complexity_analysis.
+ */
+import Database from 'better-sqlite3';
+export declare const COMPLEXITY_TOOL_DEFINITION: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            file_path: {
+                type: string;
+                description: string;
+            };
+            symbol_name: {
+                type: string;
+                description: string;
+            };
+            min_complexity: {
+                type: string;
+                description: string;
+            };
+            grade_filter: {
+                type: string;
+                description: string;
+            };
+            module: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            sort_by: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+};
+/** Handle complexity_analysis tool call. */
+export declare function handleComplexityTool(args: Record<string, unknown>, db: Database.Database): string;
+/** Register the complexity tool in the dispatch system. */
+export declare function registerComplexityTool(): typeof COMPLEXITY_TOOL_DEFINITION;

package/dist/engine/analyzers/complexity/ComplexityTool.js

@@ -0,0 +1,58 @@
+/**
+ * KSA-161: MCP Tool registration for complexity_analysis.
+ */
+import { ComplexityAnalyzer } from './ComplexityAnalyzer.js';
+export const COMPLEXITY_TOOL_DEFINITION = {
+    name: 'complexity_analysis',
+    description: 'Analyze cyclomatic complexity of functions with breakdown and A-F grading. Query by file, symbol, grade, or module.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            file_path: { type: 'string', description: 'Filter by file path (partial match)' },
+            symbol_name: { type: 'string', description: 'Filter by function/method name' },
+            min_complexity: { type: 'number', description: 'Minimum CC threshold (default: 1)' },
+            grade_filter: { type: 'string', description: 'Comma-separated grades to include (e.g. "C,D,F")' },
+            module: { type: 'string', description: 'Filter by module name' },
+            limit: { type: 'number', description: 'Max results (default: 20)' },
+            sort_by: { type: 'string', description: 'Sort by: complexity (default), name, file' },
+        },
+    },
+};
+/** Handle complexity_analysis tool call. */
+export function handleComplexityTool(args, db) {
+    const analyzer = new ComplexityAnalyzer(db);
+    const filters = {
+        filePath: args.file_path,
+        symbolName: args.symbol_name,
+        minComplexity: args.min_complexity,
+        gradeFilter: args.grade_filter
+            ? args.grade_filter.split(',').map(g => g.trim())
+            : undefined,
+        module: args.module,
+        limit: args.limit ?? 20,
+        sortBy: args.sort_by ?? 'complexity',
+    };
+    const result = analyzer.query(filters);
+    if (result.results.length === 0) {
+        return 'No complexity data found. Run indexing first to compute complexity metrics.';
+    }
+    const lines = [
+        `Complexity Analysis — ${result.total} functions found\n`,
+        `Average CC: ${result.summary.average.toFixed(1)} | Grade Distribution: ` +
+            `A=${result.summary.gradeDistribution.A} B=${result.summary.gradeDistribution.B} ` +
+            `C=${result.summary.gradeDistribution.C} D=${result.summary.gradeDistribution.D} ` +
+            `F=${result.summary.gradeDistribution.F}\n`,
+    ];
+    for (const r of result.results) {
+        lines.push(`[${r.grade}] ${r.symbol_name} — CC=${r.cyclomatic_complexity} ` +
+            `(branches=${r.branches} loops=${r.loops} logic=${r.logical_ops} ` +
+            `exceptions=${r.exception_handlers} depth=${r.nesting_depth})`);
+        lines.push(`    ${r.file_path}:${r.start_line}-${r.end_line}`);
+    }
+    return lines.join('\n');
+}
+/** Register the complexity tool in the dispatch system. */
+export function registerComplexityTool() {
+    return COMPLEXITY_TOOL_DEFINITION;
+}
+//# sourceMappingURL=ComplexityTool.js.map

package/dist/engine/analyzers/complexity/ComplexityTool.js.map

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

package/dist/engine/analyzers/complexity/GradeAssigner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * KSA-161: Grade assignment based on cyclomatic complexity thresholds.
+ */
+import type { Grade, GradeThresholds } from './types.js';
+export declare class GradeAssigner {
+    private thresholds;
+    constructor(thresholds?: Partial<GradeThresholds>);
+    /** Assign a letter grade based on cyclomatic complexity score. */
+    assignGrade(cc: number): Grade;
+    /** Get the current thresholds. */
+    getThresholds(): GradeThresholds;
+}

package/dist/engine/analyzers/complexity/GradeAssigner.js

@@ -0,0 +1,32 @@
+/**
+ * KSA-161: Grade assignment based on cyclomatic complexity thresholds.
+ */
+const DEFAULT_THRESHOLDS = {
+    A: 5,
+    B: 10,
+    C: 20,
+    D: 50,
+};
+export class GradeAssigner {
+    thresholds;
+    constructor(thresholds) {
+        this.thresholds = { ...DEFAULT_THRESHOLDS, ...thresholds };
+    }
+    /** Assign a letter grade based on cyclomatic complexity score. */
+    assignGrade(cc) {
+        if (cc <= this.thresholds.A)
+            return 'A';
+        if (cc <= this.thresholds.B)
+            return 'B';
+        if (cc <= this.thresholds.C)
+            return 'C';
+        if (cc <= this.thresholds.D)
+            return 'D';
+        return 'F';
+    }
+    /** Get the current thresholds. */
+    getThresholds() {
+        return { ...this.thresholds };
+    }
+}
+//# sourceMappingURL=GradeAssigner.js.map

package/dist/engine/analyzers/complexity/GradeAssigner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GradeAssigner.js","sourceRoot":"","sources":["../../../../src/engine/analyzers/complexity/GradeAssigner.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,MAAM,kBAAkB,GAAoB;IAC1C,CAAC,EAAE,CAAC;IACJ,CAAC,EAAE,EAAE;IACL,CAAC,EAAE,EAAE;IACL,CAAC,EAAE,EAAE;CACN,CAAC;AAEF,MAAM,OAAO,aAAa;IAChB,UAAU,CAAkB;IAEpC,YAAY,UAAqC;QAC/C,IAAI,CAAC,UAAU,GAAG,EAAE,GAAG,kBAAkB,EAAE,GAAG,UAAU,EAAE,CAAC;IAC7D,CAAC;IAED,kEAAkE;IAClE,WAAW,CAAC,EAAU;QACpB,IAAI,EAAE,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;YAAE,OAAO,GAAG,CAAC;QACxC,IAAI,EAAE,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;YAAE,OAAO,GAAG,CAAC;QACxC,IAAI,EAAE,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;YAAE,OAAO,GAAG,CAAC;QACxC,IAAI,EAAE,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;YAAE,OAAO,GAAG,CAAC;QACxC,OAAO,GAAG,CAAC;IACb,CAAC;IAED,kCAAkC;IAClC,aAAa;QACX,OAAO,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;IAChC,CAAC;CACF"}

package/dist/engine/analyzers/complexity/counters/BaseNodeCounter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * KSA-161: Abstract base class for language-specific AST node counters.
+ * Each language subclass defines which node types represent decision points.
+ */
+import type { SyntaxNode } from '../../../parsers/types.js';
+import type { DecisionPointCounts } from '../types.js';
+export declare abstract class BaseNodeCounter {
+    abstract readonly language: string;
+    abstract readonly branchNodeTypes: string[];
+    abstract readonly loopNodeTypes: string[];
+    abstract readonly logicalOperators: string[];
+    abstract readonly exceptionNodeTypes: string[];
+    /** Count all decision points in an AST subtree (single pass). */
+    countDecisionPoints(node: SyntaxNode): DecisionPointCounts;
+    /** Calculate maximum nesting depth of control structures. */
+    calculateNestingDepth(node: SyntaxNode): number;
+    /** Count early return statements in a function body. */
+    countEarlyReturns(node: SyntaxNode): number;
+    /** Override in subclass to check if a node represents a logical operator. */
+    protected isLogicalOp(node: SyntaxNode): boolean;
+    /** Override in subclass for language-specific return node types. */
+    protected getReturnNodeTypes(): string[];
+    /** Walk all nodes in the tree, calling visitor for each. */
+    protected walkTree(node: SyntaxNode, visitor: (n: SyntaxNode) => void): void;
+}

package/dist/engine/analyzers/complexity/counters/BaseNodeCounter.js

@@ -0,0 +1,85 @@
+/**
+ * KSA-161: Abstract base class for language-specific AST node counters.
+ * Each language subclass defines which node types represent decision points.
+ */
+export class BaseNodeCounter {
+    /** Count all decision points in an AST subtree (single pass). */
+    countDecisionPoints(node) {
+        const counts = {
+            branches: 0,
+            loops: 0,
+            logical_ops: 0,
+            exception_handlers: 0,
+        };
+        this.walkTree(node, (child) => {
+            if (this.branchNodeTypes.includes(child.type)) {
+                counts.branches++;
+            }
+            else if (this.loopNodeTypes.includes(child.type)) {
+                counts.loops++;
+            }
+            else if (this.exceptionNodeTypes.includes(child.type)) {
+                counts.exception_handlers++;
+            }
+            // Check for logical operators in binary expressions
+            if (this.isLogicalOp(child)) {
+                counts.logical_ops++;
+            }
+        });
+        return counts;
+    }
+    /** Calculate maximum nesting depth of control structures. */
+    calculateNestingDepth(node) {
+        const controlTypes = [...this.branchNodeTypes, ...this.loopNodeTypes];
+        let maxDepth = 0;
+        const walk = (n, depth) => {
+            if (controlTypes.includes(n.type)) {
+                depth++;
+                if (depth > maxDepth)
+                    maxDepth = depth;
+            }
+            for (let i = 0; i < n.childCount; i++) {
+                const child = n.child(i);
+                if (child)
+                    walk(child, depth);
+            }
+        };
+        walk(node, 0);
+        return maxDepth;
+    }
+    /** Count early return statements in a function body. */
+    countEarlyReturns(node) {
+        let count = 0;
+        const returnTypes = this.getReturnNodeTypes();
+        this.walkTree(node, (child) => {
+            if (returnTypes.includes(child.type)) {
+                count++;
+            }
+        });
+        // The last return doesn't count as "early"
+        return Math.max(0, count - 1);
+    }
+    /** Override in subclass to check if a node represents a logical operator. */
+    isLogicalOp(node) {
+        if (node.type === 'binary_expression' || node.type === 'logical_expression') {
+            const op = node.childForFieldName('operator');
+            if (op && this.logicalOperators.includes(op.text))
+                return true;
+        }
+        return false;
+    }
+    /** Override in subclass for language-specific return node types. */
+    getReturnNodeTypes() {
+        return ['return_statement'];
+    }
+    /** Walk all nodes in the tree, calling visitor for each. */
+    walkTree(node, visitor) {
+        visitor(node);
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child)
+                this.walkTree(child, visitor);
+        }
+    }
+}
+//# sourceMappingURL=BaseNodeCounter.js.map

package/dist/engine/analyzers/complexity/counters/BaseNodeCounter.js.map

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

package/dist/engine/analyzers/complexity/counters/GoCounter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * KSA-161: Go decision point counter.
+ */
+import type { SyntaxNode } from '../../../parsers/types.js';
+import { BaseNodeCounter } from './BaseNodeCounter.js';
+export declare class GoCounter extends BaseNodeCounter {
+    readonly language = "go";
+    readonly branchNodeTypes: string[];
+    readonly loopNodeTypes: string[];
+    readonly logicalOperators: string[];
+    readonly exceptionNodeTypes: string[];
+    protected isLogicalOp(node: SyntaxNode): boolean;
+    protected getReturnNodeTypes(): string[];
+}

package/dist/engine/analyzers/complexity/counters/GoCounter.js

@@ -0,0 +1,31 @@
+/**
+ * KSA-161: Go decision point counter.
+ */
+import { BaseNodeCounter } from './BaseNodeCounter.js';
+export class GoCounter extends BaseNodeCounter {
+    language = 'go';
+    branchNodeTypes = [
+        'if_statement',
+        'expression_case', // switch case
+        'type_case', // type switch case
+        'select_statement',
+        'communication_case',
+    ];
+    loopNodeTypes = [
+        'for_statement',
+    ];
+    logicalOperators = ['&&', '||'];
+    exceptionNodeTypes = []; // Go uses error returns, not exceptions
+    isLogicalOp(node) {
+        if (node.type === 'binary_expression') {
+            const op = node.childForFieldName('operator');
+            if (op && this.logicalOperators.includes(op.text))
+                return true;
+        }
+        return false;
+    }
+    getReturnNodeTypes() {
+        return ['return_statement'];
+    }
+}
+//# sourceMappingURL=GoCounter.js.map

package/dist/engine/analyzers/complexity/counters/GoCounter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GoCounter.js","sourceRoot":"","sources":["../../../../../src/engine/analyzers/complexity/counters/GoCounter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,OAAO,SAAU,SAAQ,eAAe;IACnC,QAAQ,GAAG,IAAI,CAAC;IAChB,eAAe,GAAG;QACzB,cAAc;QACd,iBAAiB,EAAQ,cAAc;QACvC,WAAW,EAAc,mBAAmB;QAC5C,kBAAkB;QAClB,oBAAoB;KACrB,CAAC;IACO,aAAa,GAAG;QACvB,eAAe;KAChB,CAAC;IACO,gBAAgB,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAChC,kBAAkB,GAAa,EAAE,CAAC,CAAC,wCAAwC;IAE1E,WAAW,CAAC,IAAgB;QACpC,IAAI,IAAI,CAAC,IAAI,KAAK,mBAAmB,EAAE,CAAC;YACtC,MAAM,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;YAC9C,IAAI,EAAE,IAAI,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAC;QACjE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAES,kBAAkB;QAC1B,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC9B,CAAC;CACF"}

package/dist/engine/analyzers/complexity/counters/JavaCounter.d.ts

@@ -0,0 +1,13 @@
+/**
+ * KSA-161: Java decision point counter.
+ */
+import type { SyntaxNode } from '../../../parsers/types.js';
+import { BaseNodeCounter } from './BaseNodeCounter.js';
+export declare class JavaCounter extends BaseNodeCounter {
+    readonly language = "java";
+    readonly branchNodeTypes: string[];
+    readonly loopNodeTypes: string[];
+    readonly logicalOperators: string[];
+    readonly exceptionNodeTypes: string[];
+    protected isLogicalOp(node: SyntaxNode): boolean;
+}

package/dist/engine/analyzers/complexity/counters/JavaCounter.js

@@ -0,0 +1,29 @@
+/**
+ * KSA-161: Java decision point counter.
+ */
+import { BaseNodeCounter } from './BaseNodeCounter.js';
+export class JavaCounter extends BaseNodeCounter {
+    language = 'java';
+    branchNodeTypes = [
+        'if_statement',
+        'switch_expression',
+        'ternary_expression',
+    ];
+    loopNodeTypes = [
+        'for_statement',
+        'enhanced_for_statement',
+        'while_statement',
+        'do_statement',
+    ];
+    logicalOperators = ['&&', '||'];
+    exceptionNodeTypes = ['catch_clause'];
+    isLogicalOp(node) {
+        if (node.type === 'binary_expression') {
+            const op = node.childForFieldName('operator');
+            if (op && this.logicalOperators.includes(op.text))
+                return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=JavaCounter.js.map

package/dist/engine/analyzers/complexity/counters/JavaCounter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JavaCounter.js","sourceRoot":"","sources":["../../../../../src/engine/analyzers/complexity/counters/JavaCounter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,OAAO,WAAY,SAAQ,eAAe;IACrC,QAAQ,GAAG,MAAM,CAAC;IAClB,eAAe,GAAG;QACzB,cAAc;QACd,mBAAmB;QACnB,oBAAoB;KACrB,CAAC;IACO,aAAa,GAAG;QACvB,eAAe;QACf,wBAAwB;QACxB,iBAAiB;QACjB,cAAc;KACf,CAAC;IACO,gBAAgB,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAChC,kBAAkB,GAAG,CAAC,cAAc,CAAC,CAAC;IAErC,WAAW,CAAC,IAAgB;QACpC,IAAI,IAAI,CAAC,IAAI,KAAK,mBAAmB,EAAE,CAAC;YACtC,MAAM,EAAE,GAAG,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;YAC9C,IAAI,EAAE,IAAI,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAC;QACjE,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

package/dist/engine/analyzers/complexity/counters/KotlinCounter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * KSA-161: Kotlin decision point counter.
+ */
+import type { SyntaxNode } from '../../../parsers/types.js';
+import { BaseNodeCounter } from './BaseNodeCounter.js';
+export declare class KotlinCounter extends BaseNodeCounter {
+    readonly language = "kotlin";
+    readonly branchNodeTypes: string[];
+    readonly loopNodeTypes: string[];
+    readonly logicalOperators: string[];
+    readonly exceptionNodeTypes: string[];
+    protected isLogicalOp(node: SyntaxNode): boolean;
+    protected getReturnNodeTypes(): string[];
+}