@compilr-dev/agents-coding-ts 0.1.3 → 0.1.5

package/dist/skills/index.d.ts

@@ -3,13 +3,13 @@
  *
  * Specialized skills for code analysis workflows using AST-based tools.
  */
-import type { Skill } from '@compilr-dev/agents';
-export { defineSkill, type Skill } from '@compilr-dev/agents';
-export { codeStructureSkill } from './code-structure.js';
-export { dependencyAuditSkill } from './dependency-audit.js';
-export { refactorImpactSkill } from './refactor-impact.js';
-export { typeAnalysisSkill } from './type-analysis.js';
-export { codeHealthSkill } from './code-health.js';
+import type { Skill } from "@compilr-dev/agents";
+export { defineSkill, type Skill } from "@compilr-dev/agents";
+export { codeStructureSkill } from "./code-structure.js";
+export { dependencyAuditSkill } from "./dependency-audit.js";
+export { refactorImpactSkill } from "./refactor-impact.js";
+export { typeAnalysisSkill } from "./type-analysis.js";
+export { codeHealthSkill } from "./code-health.js";
 /**
  * All TypeScript/JavaScript analysis skills
  */

package/dist/skills/index.js

@@ -3,18 +3,18 @@
  *
  * Specialized skills for code analysis workflows using AST-based tools.
  */
-export { defineSkill } from '@compilr-dev/agents';
-export { codeStructureSkill } from './code-structure.js';
-export { dependencyAuditSkill } from './dependency-audit.js';
-export { refactorImpactSkill } from './refactor-impact.js';
-export { typeAnalysisSkill } from './type-analysis.js';
-export { codeHealthSkill } from './code-health.js';
+export { defineSkill } from "@compilr-dev/agents";
+export { codeStructureSkill } from "./code-structure.js";
+export { dependencyAuditSkill } from "./dependency-audit.js";
+export { refactorImpactSkill } from "./refactor-impact.js";
+export { typeAnalysisSkill } from "./type-analysis.js";
+export { codeHealthSkill } from "./code-health.js";
 // Import for collection
-import { codeStructureSkill } from './code-structure.js';
-import { dependencyAuditSkill } from './dependency-audit.js';
-import { refactorImpactSkill } from './refactor-impact.js';
-import { typeAnalysisSkill } from './type-analysis.js';
-import { codeHealthSkill } from './code-health.js';
+import { codeStructureSkill } from "./code-structure.js";
+import { dependencyAuditSkill } from "./dependency-audit.js";
+import { refactorImpactSkill } from "./refactor-impact.js";
+import { typeAnalysisSkill } from "./type-analysis.js";
+import { codeHealthSkill } from "./code-health.js";
 /**
  * All TypeScript/JavaScript analysis skills
  */

package/dist/skills/refactor-impact.js

@@ -3,13 +3,13 @@
  *
  * Analyze the impact of refactoring a symbol across the codebase.
  */
-import { defineSkill } from '@compilr-dev/agents';
+import { defineSkill } from "@compilr-dev/agents";
 /**
  * Refactor impact skill - Analyze impact of refactoring a symbol
  */
 export const refactorImpactSkill = defineSkill({
-    name: 'refactor-impact',
-    description: 'Analyze the impact of refactoring a symbol across the codebase',
+    name: "refactor-impact",
+    description: "Analyze the impact of refactoring a symbol across the codebase",
     prompt: `You are in REFACTOR IMPACT ANALYSIS mode. Analyze what would be affected by refactoring a symbol.
 
 ## When to Use
@@ -141,6 +141,6 @@ get_type_hierarchy({
 - Quantify the impact (number of files, usages)
 - Provide actionable checklist
 - Highlight breaking changes for exported/public symbols`,
-    tags: ['refactoring', 'analysis', 'impact', 'planning'],
-    version: '1.0.0',
+    tags: ["refactoring", "analysis", "impact", "planning"],
+    version: "1.0.0",
 });

package/dist/skills/type-analysis.js

@@ -3,13 +3,13 @@
  *
  * Analyze type hierarchies, interfaces, and their implementations.
  */
-import { defineSkill } from '@compilr-dev/agents';
+import { defineSkill } from "@compilr-dev/agents";
 /**
  * Type analysis skill - Analyze type hierarchies and implementations
  */
 export const typeAnalysisSkill = defineSkill({
-    name: 'type-analysis',
-    description: 'Analyze type hierarchies, interfaces, and their implementations',
+    name: "type-analysis",
+    description: "Analyze type hierarchies, interfaces, and their implementations",
     prompt: `You are in TYPE ANALYSIS mode. Analyze type relationships in the codebase.
 
 ## When to Use
@@ -156,6 +156,6 @@ TypeName
 - Highlight incomplete implementations
 - Note generic type parameters when present
 - Keep diagrams simple - expand on request`,
-    tags: ['types', 'analysis', 'inheritance', 'interfaces', 'architecture'],
-    version: '1.0.0',
+    tags: ["types", "analysis", "inheritance", "interfaces", "architecture"],
+    version: "1.0.0",
 });

package/dist/tools/find-dead-code.d.ts

@@ -4,8 +4,8 @@
  * Find potentially unused exports, functions, and variables across a codebase.
  * Uses static analysis to identify code that may be dead.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { FindDeadCodeInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { FindDeadCodeInput } from "./types.js";
 /**
  * findDeadCode tool
  */

package/dist/tools/find-dead-code.js

@@ -4,59 +4,59 @@
  * Find potentially unused exports, functions, and variables across a codebase.
  * Uses static analysis to identify code that may be dead.
  */
-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 = `Find potentially unused exports, functions, and variables.
 Analyzes the codebase to identify code that may be dead (never used).
 Useful for cleanup and reducing bundle size.`;
 // Tool input schema
 const TOOL_INPUT_SCHEMA = {
-    type: 'object',
+    type: "object",
     properties: {
         path: {
-            type: 'string',
-            description: 'Directory to analyze',
+            type: "string",
+            description: "Directory to analyze",
         },
         includeTests: {
-            type: 'boolean',
-            description: 'Include test files in analysis (default: false)',
+            type: "boolean",
+            description: "Include test files in analysis (default: false)",
             default: false,
         },
         checkExports: {
-            type: 'boolean',
-            description: 'Check for unused exports (default: true)',
+            type: "boolean",
+            description: "Check for unused exports (default: true)",
             default: true,
         },
         checkFunctions: {
-            type: 'boolean',
-            description: 'Check for unused functions (default: true)',
+            type: "boolean",
+            description: "Check for unused functions (default: true)",
             default: true,
         },
         checkVariables: {
-            type: 'boolean',
-            description: 'Check for unused variables (default: false)',
+            type: "boolean",
+            description: "Check for unused variables (default: false)",
             default: false,
         },
         maxFiles: {
-            type: 'number',
-            description: 'Maximum files to analyze (default: 100)',
+            type: "number",
+            description: "Maximum files to analyze (default: 100)",
             default: 100,
         },
     },
-    required: ['path'],
+    required: ["path"],
 };
 // Default exclusions
-const DEFAULT_EXCLUDE = ['node_modules', 'dist', 'build', '.git', 'coverage'];
-const TEST_PATTERNS = ['.test.', '.spec.', '__tests__', '__mocks__'];
+const DEFAULT_EXCLUDE = ["node_modules", "dist", "build", ".git", "coverage"];
+const TEST_PATTERNS = [".test.", ".spec.", "__tests__", "__mocks__"];
 /**
  * findDeadCode tool
  */
 export const findDeadCodeTool = defineTool({
-    name: 'find_dead_code',
+    name: "find_dead_code",
     description: TOOL_DESCRIPTION,
     inputSchema: TOOL_INPUT_SCHEMA,
     execute: executeFindDeadCode,
@@ -77,7 +77,7 @@ async function executeFindDeadCode(input) {
         }
         const stats = await fs.stat(resolvedPath);
         if (!stats.isDirectory()) {
-            return createErrorResult('findDeadCode requires a directory path');
+            return createErrorResult("findDeadCode requires a directory path");
         }
         // Collect files
         const files = [];
@@ -101,7 +101,7 @@ async function executeFindDeadCode(input) {
         let unusedVariables = 0;
         for (const def of definitions) {
             // Skip index files (re-exports)
-            if (def.path.endsWith('index.ts') || def.path.endsWith('index.js')) {
+            if (def.path.endsWith("index.ts") || def.path.endsWith("index.js")) {
                 continue;
             }
             const isUsed = usages.has(def.name) || importedSymbols.has(def.name);
@@ -117,16 +117,16 @@ async function executeFindDeadCode(input) {
                             name: def.name,
                             path: def.path,
                             line: def.line,
-                            kind: 'export',
+                            kind: "export",
                             exported: true,
-                            confidence: 'medium',
-                            reason: 'Export is not imported anywhere in the codebase',
+                            confidence: "medium",
+                            reason: "Export is not imported anywhere in the codebase",
                         });
                     }
                 }
             }
             // Check functions
-            if (def.kind === 'function' && checkFunctions) {
+            if (def.kind === "function" && checkFunctions) {
                 totalFunctions++;
                 if (!isUsed && !def.exported) {
                     unusedFunctions++;
@@ -134,15 +134,15 @@ async function executeFindDeadCode(input) {
                         name: def.name,
                         path: def.path,
                         line: def.line,
-                        kind: 'function',
+                        kind: "function",
                         exported: false,
-                        confidence: 'high',
-                        reason: 'Function is not called anywhere in the file',
+                        confidence: "high",
+                        reason: "Function is not called anywhere in the file",
                     });
                 }
             }
             // Check variables
-            if (def.kind === 'variable' && checkVariables) {
+            if (def.kind === "variable" && checkVariables) {
                 totalVariables++;
                 if (!isUsed && !def.exported) {
                     unusedVariables++;
@@ -150,10 +150,10 @@ async function executeFindDeadCode(input) {
                         name: def.name,
                         path: def.path,
                         line: def.line,
-                        kind: 'variable',
+                        kind: "variable",
                         exported: false,
-                        confidence: 'medium',
-                        reason: 'Variable is not referenced after declaration',
+                        confidence: "medium",
+                        reason: "Variable is not referenced after declaration",
                     });
                 }
             }
@@ -193,15 +193,17 @@ async function collectFiles(dirPath, files, includeTests, maxFiles, currentDepth
             if (entry.isDirectory()) {
                 if (DEFAULT_EXCLUDE.includes(entry.name))
                     continue;
-                if (!includeTests && entry.name === '__tests__')
+                if (!includeTests && entry.name === "__tests__")
                     continue;
                 await collectFiles(fullPath, files, includeTests, maxFiles, currentDepth + 1);
             }
             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")) {
                     // Skip test files if not including tests
-                    if (!includeTests && TEST_PATTERNS.some((p) => fullPath.includes(p))) {
+                    if (!includeTests &&
+                        TEST_PATTERNS.some((p) => fullPath.includes(p))) {
                         continue;
                     }
                     files.push(fullPath);
@@ -218,47 +220,51 @@ async function collectFiles(dirPath, files, includeTests, maxFiles, currentDepth
  */
 async function analyzeFile(filePath, definitions, usages, importedSymbols) {
     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;
         }
-        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);
         // Collect definitions
         const visit = (node) => {
             const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             // Function declarations
             if (ts.isFunctionDeclaration(node) && node.name) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'function',
+                    kind: "function",
                     exported: isExported,
                 });
             }
             // Class declarations
             if (ts.isClassDeclaration(node) && node.name) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'class',
+                    kind: "class",
                     exported: isExported,
                 });
             }
             // Variable declarations (const, let, var)
             if (ts.isVariableStatement(node)) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 for (const decl of node.declarationList.declarations) {
                     if (ts.isIdentifier(decl.name)) {
                         // Check if it's a function expression
                         const kind = decl.initializer &&
-                            (ts.isFunctionExpression(decl.initializer) || ts.isArrowFunction(decl.initializer))
-                            ? 'function'
-                            : 'variable';
+                            (ts.isFunctionExpression(decl.initializer) ||
+                                ts.isArrowFunction(decl.initializer))
+                            ? "function"
+                            : "variable";
                         definitions.push({
                             name: decl.name.text,
                             path: filePath,
@@ -271,41 +277,45 @@ async function analyzeFile(filePath, definitions, usages, importedSymbols) {
             }
             // Interface declarations
             if (ts.isInterfaceDeclaration(node)) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'interface',
+                    kind: "interface",
                     exported: isExported,
                 });
             }
             // Type alias declarations
             if (ts.isTypeAliasDeclaration(node)) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'type',
+                    kind: "type",
                     exported: isExported,
                 });
             }
             // Enum declarations
             if (ts.isEnumDeclaration(node)) {
-                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+                const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                    false;
                 definitions.push({
                     name: node.name.text,
                     path: filePath,
                     line: line + 1,
-                    kind: 'enum',
+                    kind: "enum",
                     exported: isExported,
                 });
             }
             // Import declarations - track what's imported
             if (ts.isImportDeclaration(node) && node.importClause) {
                 // Named imports
-                if (node.importClause.namedBindings && ts.isNamedImports(node.importClause.namedBindings)) {
+                if (node.importClause.namedBindings &&
+                    ts.isNamedImports(node.importClause.namedBindings)) {
                     for (const specifier of node.importClause.namedBindings.elements) {
                         importedSymbols.add(specifier.name.text);
                     }
@@ -344,13 +354,27 @@ async function analyzeFile(filePath, definitions, usages, importedSymbols) {
  */
 function isLikelyEntryPoint(filePath, symbolName) {
     // Main entry files
-    const entryPatterns = ['index.ts', 'index.js', 'main.ts', 'main.js', 'app.ts', 'app.js'];
+    const entryPatterns = [
+        "index.ts",
+        "index.js",
+        "main.ts",
+        "main.js",
+        "app.ts",
+        "app.js",
+    ];
     const fileName = path.basename(filePath);
     if (entryPatterns.includes(fileName)) {
         return true;
     }
     // Common exported names that are likely entry points
-    const entrySymbols = ['default', 'main', 'app', 'handler', 'server', 'client'];
+    const entrySymbols = [
+        "default",
+        "main",
+        "app",
+        "handler",
+        "server",
+        "client",
+    ];
     if (entrySymbols.includes(symbolName.toLowerCase())) {
         return true;
     }
@@ -361,7 +385,7 @@ function isLikelyEntryPoint(filePath, symbolName) {
  */
 export function createFindDeadCodeTool(options) {
     return defineTool({
-        name: options?.name ?? 'find_dead_code',
+        name: options?.name ?? "find_dead_code",
         description: options?.description ?? TOOL_DESCRIPTION,
         inputSchema: TOOL_INPUT_SCHEMA,
         execute: async (input) => {

package/dist/tools/find-duplicates.d.ts

@@ -4,8 +4,8 @@
  * Detect duplicate code blocks across the codebase using content hashing.
  * Helps identify opportunities for refactoring and code reuse.
  */
-import type { Tool } from '@compilr-dev/agents';
-import type { FindDuplicatesInput } from './types.js';
+import type { Tool } from "@compilr-dev/agents";
+import type { FindDuplicatesInput } from "./types.js";
 /**
  * findDuplicates tool
  */