@compilr-dev/agents-coding-ts 0.1.2 → 0.1.4

package/dist/tools/get-complexity.js

@@ -4,53 +4,53 @@
  * Calculate code complexity metrics including cyclomatic complexity,
  * cognitive complexity, nesting depth, and identify complexity hotspots.
  */
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import * as ts from 'typescript';
-import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
-import { detectLanguage, isLanguageSupported } from '../parser/typescript-parser.js';
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as ts from "typescript";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { detectLanguage, isLanguageSupported, } from "../parser/typescript-parser.js";
 // Tool description
 const TOOL_DESCRIPTION = `Calculate code complexity metrics for files or directories.
 Returns cyclomatic complexity, cognitive complexity, nesting depth, and identifies hotspots.
 Useful for finding functions that may need refactoring.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'File or directory to analyze',
+            type: "string",
+            description: "File or directory to analyze",
         },
         recursive: {
-            type: 'boolean',
-            description: 'Recursive analysis for directories (default: false)',
+            type: "boolean",
+            description: "Recursive analysis for directories (default: false)",
             default: false,
         },
         threshold: {
-            type: 'number',
-            description: 'Complexity threshold for warnings (default: 10)',
+            type: "number",
+            description: "Complexity threshold for warnings (default: 10)",
             default: 10,
         },
         onlyAboveThreshold: {
-            type: 'boolean',
-            description: 'Only return items above threshold (default: false)',
+            type: "boolean",
+            description: "Only return items above threshold (default: false)",
             default: false,
         },
         maxFiles: {
-            type: 'number',
-            description: 'Maximum files to analyze (default: 50)',
+            type: "number",
+            description: "Maximum files to analyze (default: 50)",
             default: 50,
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 // Default exclusions
-const DEFAULT_EXCLUDE = ['node_modules', 'dist', 'build', '.git', 'coverage'];
+const DEFAULT_EXCLUDE = ["node_modules", "dist", "build", ".git", "coverage"];
 /**
  * getComplexity tool
  */
 export const getComplexityTool = defineTool({
-    name: 'get_complexity',
+    name: "get_complexity",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeGetComplexity,
@@ -124,7 +124,9 @@ async function executeGetComplexity(input) {
             summary: {
                 totalFiles: fileResults.length,
                 totalFunctions,
-                averageComplexity: totalFunctions > 0 ? Math.round((totalComplexity / totalFunctions) * 100) / 100 : 0,
+                averageComplexity: totalFunctions > 0
+                    ? Math.round((totalComplexity / totalFunctions) * 100) / 100
+                    : 0,
                 maxComplexity,
                 aboveThreshold: aboveThresholdCount,
                 threshold,
@@ -157,7 +159,8 @@ async function collectFiles(dirPath, files, maxDepth, maxFiles, currentDepth = 0
             }
             else if (entry.isFile()) {
                 // Only include TypeScript/JavaScript files
-                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) && !entry.name.endsWith('.d.ts')) {
+                if (/\.(ts|tsx|js|jsx)$/.test(entry.name) &&
+                    !entry.name.endsWith(".d.ts")) {
                     files.push(fullPath);
                 }
             }
@@ -172,12 +175,12 @@ async function collectFiles(dirPath, files, maxDepth, maxFiles, currentDepth = 0
  */
 async function analyzeFile(filePath, threshold) {
     try {
-        const content = await fs.readFile(filePath, 'utf-8');
+        const content = await fs.readFile(filePath, "utf-8");
         const detection = detectLanguage(filePath);
         if (!detection.language || !isLanguageSupported(detection.language)) {
             return null;
         }
-        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
         const functions = [];
         let classCount = 0;
         // Visit all nodes
@@ -200,14 +203,18 @@ async function analyzeFile(filePath, threshold) {
         };
         visit(sourceFile);
         // Calculate file metrics
-        const lines = content.split('\n');
+        const lines = content.split("\n");
         const totalLines = lines.length;
-        const blankLines = lines.filter((l) => l.trim() === '').length;
+        const blankLines = lines.filter((l) => l.trim() === "").length;
         const linesOfCode = totalLines - blankLines;
         const avgComplexity = functions.length > 0
-            ? Math.round((functions.reduce((sum, f) => sum + f.cyclomatic, 0) / functions.length) * 100) / 100
+            ? Math.round((functions.reduce((sum, f) => sum + f.cyclomatic, 0) /
+                functions.length) *
+                100) / 100
+            : 0;
+        const maxComplexity = functions.length > 0
+            ? Math.max(...functions.map((f) => f.cyclomatic))
             : 0;
-        const maxComplexity = functions.length > 0 ? Math.max(...functions.map((f) => f.cyclomatic)) : 0;
         return {
             path: filePath,
             metrics: {
@@ -230,12 +237,12 @@ async function analyzeFile(filePath, threshold) {
  */
 function analyzeFunctionComplexity(node, sourceFile, threshold) {
     // Get function name
-    let name = '<anonymous>';
+    let name = "<anonymous>";
     if (ts.isFunctionDeclaration(node) && node.name) {
         name = node.name.text;
     }
     else if (ts.isMethodDeclaration(node)) {
-        name = ts.isIdentifier(node.name) ? node.name.text : '<computed>';
+        name = ts.isIdentifier(node.name) ? node.name.text : "<computed>";
     }
     else if (ts.isFunctionExpression(node) && node.name) {
         name = node.name.text;
@@ -246,19 +253,22 @@ function analyzeFunctionComplexity(node, sourceFile, threshold) {
         if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
             name = parent.name.text;
         }
-        else if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
+        else if (ts.isPropertyAssignment(parent) &&
+            ts.isIdentifier(parent.name)) {
             name = parent.name.text;
         }
     }
     // Skip anonymous functions in certain contexts
-    if (name === '<anonymous>') {
+    if (name === "<anonymous>") {
         // Only include top-level anonymous functions or named expressions
         const parent = node.parent;
         if (!ts.isVariableDeclaration(parent) && !ts.isPropertyAssignment(parent)) {
             return null;
         }
     }
-    const body = ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isFunctionExpression(node)
+    const body = ts.isFunctionDeclaration(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isFunctionExpression(node)
         ? node.body
         : node.body;
     if (!body)
@@ -281,57 +291,95 @@ function analyzeFunctionComplexity(node, sourceFile, threshold) {
         if (ts.isIfStatement(n)) {
             cyclomatic++;
             cognitive += 1 + nestingLevel; // Cognitive adds nesting penalty
-            contributors.push({ type: 'if', line: line + 1, contribution: 1 + nestingLevel });
+            contributors.push({
+                type: "if",
+                line: line + 1,
+                contribution: 1 + nestingLevel,
+            });
         }
         else if (ts.isConditionalExpression(n)) {
             cyclomatic++;
             cognitive += 1 + nestingLevel;
-            contributors.push({ type: 'ternary', line: line + 1, contribution: 1 + nestingLevel });
+            contributors.push({
+                type: "ternary",
+                line: line + 1,
+                contribution: 1 + nestingLevel,
+            });
         }
-        else if (ts.isForStatement(n) || ts.isForInStatement(n) || ts.isForOfStatement(n)) {
+        else if (ts.isForStatement(n) ||
+            ts.isForInStatement(n) ||
+            ts.isForOfStatement(n)) {
             cyclomatic++;
             cognitive += 1 + nestingLevel;
-            contributors.push({ type: 'for', line: line + 1, contribution: 1 + nestingLevel });
+            contributors.push({
+                type: "for",
+                line: line + 1,
+                contribution: 1 + nestingLevel,
+            });
         }
         else if (ts.isWhileStatement(n)) {
             cyclomatic++;
             cognitive += 1 + nestingLevel;
-            contributors.push({ type: 'while', line: line + 1, contribution: 1 + nestingLevel });
+            contributors.push({
+                type: "while",
+                line: line + 1,
+                contribution: 1 + nestingLevel,
+            });
         }
         else if (ts.isDoStatement(n)) {
             cyclomatic++;
             cognitive += 1 + nestingLevel;
-            contributors.push({ type: 'do', line: line + 1, contribution: 1 + nestingLevel });
+            contributors.push({
+                type: "do",
+                line: line + 1,
+                contribution: 1 + nestingLevel,
+            });
         }
         else if (ts.isSwitchStatement(n)) {
             cyclomatic++;
             cognitive += 1 + nestingLevel;
-            contributors.push({ type: 'switch', line: line + 1, contribution: 1 + nestingLevel });
+            contributors.push({
+                type: "switch",
+                line: line + 1,
+                contribution: 1 + nestingLevel,
+            });
         }
         else if (ts.isCaseClause(n)) {
             cyclomatic++;
-            contributors.push({ type: 'case', line: line + 1, contribution: 1 });
+            contributors.push({ type: "case", line: line + 1, contribution: 1 });
         }
         else if (ts.isCatchClause(n)) {
             cyclomatic++;
             cognitive += 1 + nestingLevel;
-            contributors.push({ type: 'catch', line: line + 1, contribution: 1 + nestingLevel });
+            contributors.push({
+                type: "catch",
+                line: line + 1,
+                contribution: 1 + nestingLevel,
+            });
         }
         else if (ts.isBinaryExpression(n)) {
             if (n.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
                 cyclomatic++;
                 cognitive++;
-                contributors.push({ type: 'logical_and', line: line + 1, contribution: 1 });
+                contributors.push({
+                    type: "logical_and",
+                    line: line + 1,
+                    contribution: 1,
+                });
             }
             else if (n.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
                 cyclomatic++;
                 cognitive++;
-                contributors.push({ type: 'logical_or', line: line + 1, contribution: 1 });
+                contributors.push({
+                    type: "logical_or",
+                    line: line + 1,
+                    contribution: 1,
+                });
             }
             else if (n.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
                 cyclomatic++;
                 cognitive++;
-                contributors.push({ type: 'nullish', line: line + 1, contribution: 1 });
+                contributors.push({ type: "nullish", line: line + 1, contribution: 1 });
             }
         }
         // Increase nesting for blocks
@@ -343,7 +391,7 @@ function analyzeFunctionComplexity(node, sourceFile, threshold) {
     analyzeNode(body, 0);
     // Calculate LOC
     const bodyText = body.getText(sourceFile);
-    const bodyLines = bodyText.split('\n').filter((l) => l.trim() !== '').length;
+    const bodyLines = bodyText.split("\n").filter((l) => l.trim() !== "").length;
     // Parameter count
     const parameterCount = node.parameters.length;
     const aboveThreshold = cyclomatic >= threshold;
@@ -379,7 +427,7 @@ function isNestingNode(node) {
  */
 export function createGetComplexityTool(options) {
     return defineTool({
-        name: options?.name ?? 'get_complexity',
+        name: options?.name ?? "get_complexity",
         description: options?.description ?? TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/get-dependency-graph.d.ts

@@ -4,8 +4,8 @@
  * Analyze module-level dependencies across a directory.
  * Builds a dependency graph and detects circular dependencies.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { GetDependencyGraphInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { GetDependencyGraphInput } from "./types.js";
 /**
  * getDependencyGraph tool - Analyze module dependencies
  */

package/dist/tools/get-dependency-graph.js

@@ -4,50 +4,62 @@
  * Analyze module-level dependencies across a directory.
  * Builds a dependency graph and detects circular dependencies.
  */
-import * as fs from 'node:fs/promises';
-import * as fsSync from 'node:fs';
-import * as path from 'node:path';
-import * as ts from 'typescript';
-import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
-import { detectLanguage, isLanguageSupported } from '../parser/typescript-parser.js';
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import * as ts from "typescript";
+import { defineTool, createSuccessResult, createErrorResult, } from "@compilr-dev/agents";
+import { detectLanguage, isLanguageSupported, } from "../parser/typescript-parser.js";
 // Tool description
 const TOOL_DESCRIPTION = `Analyze module-level dependencies across a directory.
 Returns a dependency graph showing which modules import which other modules.
 Detects circular dependencies and provides dependency statistics.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'Directory or file to analyze',
+            type: "string",
+            description: "Directory or file to analyze",
         },
         includeExternal: {
-            type: 'boolean',
-            description: 'Include external package dependencies (default: true)',
+            type: "boolean",
+            description: "Include external package dependencies (default: true)",
             default: true,
         },
         includeTypeOnly: {
-            type: 'boolean',
-            description: 'Include type-only imports (default: true)',
+            type: "boolean",
+            description: "Include type-only imports (default: true)",
             default: true,
         },
         maxDepth: {
-            type: 'number',
-            description: 'Maximum depth for directory traversal (default: 10)',
+            type: "number",
+            description: "Maximum depth for directory traversal (default: 10)",
             default: 10,
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 // Default file patterns
-const DEFAULT_INCLUDE = ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx', '**/*.mts', '**/*.mjs'];
-const DEFAULT_EXCLUDE = ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.git/**'];
+const DEFAULT_INCLUDE = [
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.mts",
+    "**/*.mjs",
+];
+const DEFAULT_EXCLUDE = [
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**",
+];
 /**
  * getDependencyGraph tool - Analyze module dependencies
  */
 export const getDependencyGraphTool = defineTool({
-    name: 'get_dependency_graph',
+    name: "get_dependency_graph",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeGetDependencyGraph,
@@ -59,7 +71,7 @@ async function executeGetDependencyGraph(input) {
     const { path: inputPath, includeExternal = true, includeTypeOnly = true, maxDepth = 10, include = DEFAULT_INCLUDE, exclude = DEFAULT_EXCLUDE, } = input;
     // Validate input
     if (!inputPath || inputPath.trim().length === 0) {
-        return createErrorResult('Path is required');
+        return createErrorResult("Path is required");
     }
     try {
         // Check if path exists
@@ -123,7 +135,8 @@ async function collectFiles(dir, include, exclude, maxDepth, currentDepth = 0) {
             }
             else if (entry.isFile()) {
                 // Check if file matches include patterns
-                if (matchesPattern(relativePath, include) && isSupportedFile(fullPath)) {
+                if (matchesPattern(relativePath, include) &&
+                    isSupportedFile(fullPath)) {
                     files.push(fullPath);
                 }
             }
@@ -141,14 +154,14 @@ function matchesPattern(filePath, patterns) {
     const fileName = path.basename(filePath);
     for (const pattern of patterns) {
         // Handle simple glob patterns
-        if (pattern.includes('**')) {
+        if (pattern.includes("**")) {
             // Check if any directory in path matches
-            const patternDir = pattern.replace('**/', '').replace('/**', '');
-            if (filePath.includes(patternDir.replace('*', ''))) {
+            const patternDir = pattern.replace("**/", "").replace("/**", "");
+            if (filePath.includes(patternDir.replace("*", ""))) {
                 return true;
             }
         }
-        else if (pattern.startsWith('*.')) {
+        else if (pattern.startsWith("*.")) {
             // Extension pattern
             const ext = pattern.substring(1);
             if (fileName.endsWith(ext)) {
@@ -198,15 +211,15 @@ async function analyzeDependencies(files, rootPath, includeExternal, includeType
                 continue;
             }
             // Determine if external
-            const isExternal = !imp.source.startsWith('.') && !imp.source.startsWith('/');
+            const isExternal = !imp.source.startsWith(".") && !imp.source.startsWith("/");
             if (isExternal) {
                 if (!includeExternal) {
                     continue;
                 }
                 // Extract package name (handle scoped packages)
-                const packageName = imp.source.startsWith('@')
-                    ? imp.source.split('/').slice(0, 2).join('/')
-                    : imp.source.split('/')[0];
+                const packageName = imp.source.startsWith("@")
+                    ? imp.source.split("/").slice(0, 2).join("/")
+                    : imp.source.split("/")[0];
                 externalPackages.add(packageName);
                 // Add external module node
                 if (!modules.has(packageName)) {
@@ -300,7 +313,7 @@ async function analyzeDependencies(files, rootPath, includeExternal, includeType
 async function extractImports(filePath) {
     const imports = [];
     try {
-        const sourceCode = await fs.readFile(filePath, 'utf-8');
+        const sourceCode = await fs.readFile(filePath, "utf-8");
         const scriptKind = getScriptKind(filePath);
         const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true, scriptKind);
         ts.forEachChild(sourceFile, (node) => {
@@ -310,24 +323,25 @@ async function extractImports(filePath) {
                     const source = node.moduleSpecifier.text;
                     // Check for type-only import by looking at the import text
                     const importText = node.getText(sourceFile);
-                    const typeOnly = importText.includes('import type');
+                    const typeOnly = importText.includes("import type");
                     const symbols = [];
-                    let importType = 'side-effect';
+                    let importType = "side-effect";
                     if (node.importClause) {
                         // Default import
                         if (node.importClause.name) {
-                            importType = 'default';
+                            importType = "default";
                             symbols.push(node.importClause.name.text);
                         }
                         // Named or namespace imports
                         if (node.importClause.namedBindings) {
                             if (ts.isNamespaceImport(node.importClause.namedBindings)) {
-                                importType = 'namespace';
+                                importType = "namespace";
                                 symbols.push(node.importClause.namedBindings.name.text);
                             }
                             else if (ts.isNamedImports(node.importClause.namedBindings)) {
-                                importType = importType === 'default' ? 'default' : 'named';
-                                for (const element of node.importClause.namedBindings.elements) {
+                                importType = importType === "default" ? "default" : "named";
+                                for (const element of node.importClause.namedBindings
+                                    .elements) {
                                     symbols.push(element.name.text);
                                 }
                             }
@@ -342,9 +356,9 @@ async function extractImports(filePath) {
                     const source = node.moduleSpecifier.text;
                     const typeOnly = node.isTypeOnly;
                     const symbols = [];
-                    let importType = 'namespace';
+                    let importType = "namespace";
                     if (node.exportClause && ts.isNamedExports(node.exportClause)) {
-                        importType = 'named';
+                        importType = "named";
                         for (const element of node.exportClause.elements) {
                             symbols.push(element.name.text);
                         }
@@ -366,7 +380,7 @@ function resolveImportPath(fromFile, importSource, _rootPath) {
     const fromDir = path.dirname(fromFile);
     const basePath = path.resolve(fromDir, importSource);
     // Try various extensions
-    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs', ''];
+    const extensions = [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ""];
     for (const ext of extensions) {
         const candidate = basePath + ext;
         try {
@@ -377,7 +391,7 @@ function resolveImportPath(fromFile, importSource, _rootPath) {
         }
         catch {
             // Try index file
-            const indexCandidate = path.join(basePath, `index${ext || '.ts'}`);
+            const indexCandidate = path.join(basePath, `index${ext || ".ts"}`);
             try {
                 fsSync.accessSync(indexCandidate);
                 return indexCandidate;
@@ -404,8 +418,8 @@ function detectCircularDependencies(adjacency) {
             if (cycleStart !== -1) {
                 const cycle = [...path.slice(cycleStart), node];
                 // Avoid duplicate cycles
-                const cycleKey = [...cycle].sort().join('->');
-                if (!cycles.some((c) => [...c.cycle].sort().join('->') === cycleKey)) {
+                const cycleKey = [...cycle].sort().join("->");
+                if (!cycles.some((c) => [...c.cycle].sort().join("->") === cycleKey)) {
                     cycles.push({
                         cycle,
                         length: cycle.length - 1,
@@ -441,21 +455,21 @@ function detectCircularDependencies(adjacency) {
  * Get TypeScript script kind from file extension
  */
 function getScriptKind(filePath) {
-    const ext = filePath.toLowerCase().split('.').pop();
+    const ext = filePath.toLowerCase().split(".").pop();
     switch (ext) {
-        case 'ts':
+        case "ts":
             return ts.ScriptKind.TS;
-        case 'tsx':
+        case "tsx":
             return ts.ScriptKind.TSX;
-        case 'js':
+        case "js":
             return ts.ScriptKind.JS;
-        case 'jsx':
+        case "jsx":
             return ts.ScriptKind.JSX;
-        case 'mts':
-        case 'cts':
+        case "mts":
+        case "cts":
             return ts.ScriptKind.TS;
-        case 'mjs':
-        case 'cjs':
+        case "mjs":
+        case "cjs":
             return ts.ScriptKind.JS;
         default:
             return ts.ScriptKind.TS;
@@ -467,7 +481,7 @@ function getScriptKind(filePath) {
 export function createGetDependencyGraphTool(options) {
     const { defaultIncludeExternal = true, defaultIncludeTypeOnly = true, defaultMaxDepth = 10, } = options ?? {};
     return defineTool({
-        name: 'get_dependency_graph',
+        name: "get_dependency_graph",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/get-documentation.d.ts

@@ -4,8 +4,8 @@
  * Extract JSDoc/TSDoc documentation from source files.
  * Provides documentation coverage metrics and identifies undocumented exports.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { GetDocumentationInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { GetDocumentationInput } from "./types.js";
 /**
  * getDocumentation tool
  */