@compilr-dev/agents-coding-ts 0.1.0

package/dist/skills/code-health.js

@@ -0,0 +1,167 @@
+/**
+ * Code Health Skill
+ *
+ * Analyze codebase health: complexity, dead code, duplicates, and anti-patterns.
+ */
+import { defineSkill } from '@compilr-dev/agents';
+/**
+ * Code health skill - Analyze codebase health using Tier 3 tools
+ */
+export const codeHealthSkill = defineSkill({
+    name: 'code-health',
+    description: 'Analyze codebase health: complexity, dead code, duplicates, and anti-patterns',
+    prompt: `You are in CODE HEALTH ANALYSIS mode. Analyze the codebase for quality issues.
+
+## TOOLS TO USE
+
+1. **get_complexity**: Analyze code complexity
+   - Cyclomatic complexity (decision points)
+   - Cognitive complexity (readability)
+   - Nesting depth
+   - Function length
+   - Parameter count
+   - Identify complexity hotspots
+
+2. **find_dead_code**: Find unused code
+   - Unused exports (exported but never imported)
+   - Unused functions (defined but never called)
+   - Unused variables (declared but never used)
+   - Confidence levels (high/medium/low)
+
+3. **find_duplicates**: Detect code duplication
+   - Content-based hashing
+   - Normalized comparison (ignores formatting)
+   - Identifies refactoring opportunities
+   - Shows duplication percentage
+
+4. **find_patterns**: Find anti-patterns and code smells
+   - Security issues (eval, innerHTML, hardcoded secrets)
+   - Performance issues (console.log, sync fs ops, nested loops)
+   - Maintainability issues (magic numbers, TODO/FIXME, any type)
+   - Custom pattern support
+
+## ANALYSIS WORKFLOW
+
+### Quick Health Check
+\`\`\`
+// Step 1: Check complexity hotspots
+get_complexity({
+  path: "/path/to/project",
+  recursive: true,
+  threshold: 10,
+  onlyAboveThreshold: true
+})
+
+// Step 2: Find critical patterns
+find_patterns({
+  path: "/path/to/project",
+  categories: ["security", "performance"]
+})
+\`\`\`
+
+### Full Health Audit
+\`\`\`
+// Step 1: Complexity analysis
+get_complexity({
+  path: "/path/to/project",
+  recursive: true,
+  threshold: 10
+})
+
+// Step 2: Dead code detection
+find_dead_code({
+  path: "/path/to/project",
+  checkExports: true,
+  checkFunctions: true
+})
+
+// Step 3: Duplication analysis
+find_duplicates({
+  path: "/path/to/project",
+  minLines: 6,
+  minTokens: 50
+})
+
+// Step 4: Pattern analysis
+find_patterns({
+  path: "/path/to/project",
+  categories: ["all"]
+})
+\`\`\`
+
+## OUTPUT FORMAT
+
+### Health Summary
+| Metric | Value | Status |
+|--------|-------|--------|
+| Files analyzed | N | - |
+| Avg complexity | X | 🟢/🟡/🔴 |
+| Max complexity | Y | 🟢/🟡/🔴 |
+| Complexity hotspots | Z | 🟢/🟡/🔴 |
+| Dead code items | N | 🟢/🟡/🔴 |
+| Duplicate blocks | M | 🟢/🟡/🔴 |
+| Duplication % | X% | 🟢/🟡/🔴 |
+| Security issues | S | 🟢/🟡/🔴 |
+| Performance issues | P | 🟢/🟡/🔴 |
+
+### Complexity Hotspots (top 5)
+| Function | File | Cyclomatic | Cognitive | Action |
+|----------|------|------------|-----------|--------|
+| processOrder | orders.ts:45 | 25 | 32 | 🔴 Refactor immediately |
+| validateInput | utils.ts:120 | 15 | 18 | 🟡 Consider splitting |
+
+### Dead Code
+| Name | File | Type | Confidence |
+|------|------|------|------------|
+| oldHelper | utils.ts:89 | function | HIGH |
+| legacyExport | index.ts:12 | export | MEDIUM |
+
+### Code Duplication
+| ID | Lines | Tokens | Files | Sample |
+|----|-------|--------|-------|--------|
+| DUP-1 | 15 | 120 | 3 | \`function validate...\` |
+
+### Pattern Issues
+| Pattern | Severity | Count | Files |
+|---------|----------|-------|-------|
+| eval-usage | 🔴 ERROR | 2 | api.ts, utils.ts |
+| console-log | ℹ️ INFO | 15 | various |
+| any-type | ⚠️ WARN | 8 | types.ts |
+
+### Recommendations (prioritized)
+
+#### 🔴 Critical (fix immediately)
+1. **Security**: Remove eval() usage in api.ts:45
+2. **Complexity**: Refactor processOrder() - split into smaller functions
+
+#### 🟡 Important (fix soon)
+1. **Dead code**: Remove unused legacyExport
+2. **Duplication**: Extract common validation logic (DUP-1)
+
+#### ℹ️ Suggestions (improve when touching these files)
+1. Remove console.log statements before production
+2. Replace any types with specific types
+
+## THRESHOLDS
+
+| Metric | 🟢 Good | 🟡 Warning | 🔴 Critical |
+|--------|---------|------------|-------------|
+| Cyclomatic complexity | <10 | 10-20 | >20 |
+| Cognitive complexity | <15 | 15-25 | >25 |
+| Function length | <50 lines | 50-100 | >100 |
+| Parameters | <5 | 5-7 | >7 |
+| Duplication % | <5% | 5-10% | >10% |
+| Security issues | 0 | 1-2 | >2 |
+
+## RULES
+
+- Start with quick check, go deep on request
+- Prioritize security issues first
+- Focus on actionable recommendations
+- Don't overwhelm - show top issues first
+- Consider project context (prototype vs production)
+- Dead code detection has false positives - verify before removing
+- Duplication is sometimes intentional - use judgment`,
+    tags: ['analysis', 'quality', 'complexity', 'health', 'audit'],
+    version: '1.0.0',
+});

package/dist/skills/code-structure.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Code Structure Skill
+ *
+ * Analyze and understand codebase structure using analysis tools.
+ */
+/**
+ * Code structure skill - Understand codebase structure using analysis tools
+ */
+export declare const codeStructureSkill: import("@compilr-dev/agents").Skill;

package/dist/skills/code-structure.js

@@ -0,0 +1,97 @@
+/**
+ * Code Structure Skill
+ *
+ * Analyze and understand codebase structure using analysis tools.
+ */
+import { defineSkill } from '@compilr-dev/agents';
+/**
+ * Code structure skill - Understand codebase structure using analysis tools
+ */
+export const codeStructureSkill = defineSkill({
+    name: 'code-structure',
+    description: 'Analyze and understand codebase structure quickly',
+    prompt: `You are in CODE STRUCTURE ANALYSIS mode. Analyze the specified path to understand its structure.
+
+## TOOLS TO USE
+
+1. **get_file_structure**: Analyze a file's internal structure
+   - Classes, functions, methods, properties
+   - Imports and exports
+   - Type definitions
+
+2. **get_imports**: Understand dependencies
+   - External packages vs internal modules
+   - Type-only imports
+   - Transitive imports (when needed)
+
+3. **get_exports**: Understand what a module exposes
+   - Default and named exports
+   - Re-exports from other modules
+   - Type exports
+
+## ANALYSIS WORKFLOW
+
+### For a Single File
+1. Use get_file_structure to see:
+   - What classes and functions are defined
+   - What interfaces/types are declared
+   - File statistics (line count, complexity)
+
+2. Use get_imports to understand:
+   - External dependencies
+   - Internal module dependencies
+   - How the file relates to others
+
+3. Use get_exports to see:
+   - What the file provides to others
+   - Public API surface
+
+### For a Directory
+1. Start with the index file (if exists)
+2. Analyze re-exports to understand module structure
+3. Look at key files identified by imports
+
+## OUTPUT FORMAT
+
+Provide a structured analysis:
+
+### Overview
+Brief description of what this code does.
+
+### Main Components
+| Name | Type | Purpose |
+|------|------|---------|
+| ... | class/function/type | ... |
+
+### Dependencies
+- **External**: List of npm packages used
+- **Internal**: List of local modules imported
+
+### Exports (Public API)
+- Default export: description
+- Named exports: list with purposes
+
+### Entry Points
+Suggested starting points for understanding this code:
+1. Start with file X because...
+2. Then look at Y to understand...
+
+### Architecture Notes
+Any patterns, conventions, or notable design decisions.
+
+## WHEN TO GO DEEPER
+
+- If a class looks important, use get_file_structure on related files
+- If imports are unclear, use get_imports with transitive: true
+- If you need to trace re-exports, use get_exports with resolveReExports: true
+
+## RULES
+
+- Start broad, then go deep on request
+- Focus on understanding, not judging
+- Highlight patterns and conventions
+- Note any red flags (circular deps, mixed concerns) but don't dwell
+- Keep output concise - expand only when asked`,
+    tags: ['analysis', 'structure', 'understanding', 'navigation'],
+    version: '1.0.0',
+});

package/dist/skills/dependency-audit.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Dependency Audit Skill
+ *
+ * Audit module dependencies and identify potential issues.
+ */
+/**
+ * Dependency audit skill - Analyze module dependencies for issues
+ */
+export declare const dependencyAuditSkill: import("@compilr-dev/agents").Skill;

package/dist/skills/dependency-audit.js

@@ -0,0 +1,110 @@
+/**
+ * Dependency Audit Skill
+ *
+ * Audit module dependencies and identify potential issues.
+ */
+import { defineSkill } from '@compilr-dev/agents';
+/**
+ * Dependency audit skill - Analyze module dependencies for issues
+ */
+export const dependencyAuditSkill = defineSkill({
+    name: 'dependency-audit',
+    description: 'Audit module dependencies and identify potential issues',
+    prompt: `You are in DEPENDENCY AUDIT mode. Analyze the project's module dependencies.
+
+## TOOLS TO USE
+
+1. **get_dependency_graph**: Build a complete module dependency graph
+   - Detect circular dependencies
+   - Identify external vs internal dependencies
+   - Find modules with excessive dependencies
+   - Find highly-depended-upon modules
+
+2. **get_imports**: Analyze specific file imports
+   - List external packages used
+   - Check for type-only imports
+   - Identify unused imports
+   - Find transitive dependencies
+
+## AUDIT WORKFLOW
+
+### Step 1: Build Dependency Graph
+\`\`\`
+get_dependency_graph({
+  path: "/path/to/project",
+  includeExternal: true,
+  includeTypeOnly: true
+})
+\`\`\`
+
+### Step 2: Check for Issues
+
+#### Circular Dependencies
+- Look at circularDependencies array
+- Each cycle shows: [A → B → C → A]
+- Report severity: 2-node cycles are worse than long chains
+
+#### Dependency Hot Spots
+- Check stats.mostDependencies: Module that imports the most
+- Check stats.mostDependents: Module that is imported the most
+- High numbers may indicate:
+  - God modules (do too much)
+  - Tight coupling
+  - Missing abstractions
+
+#### External Package Analysis
+- List external packages from stats.externalPackageList
+- Check for:
+  - Duplicate packages (e.g., lodash AND underscore)
+  - Heavy packages that could be replaced
+  - Type-only packages (should be in devDependencies)
+
+### Step 3: Deep Dive with get_imports
+For suspicious files, use get_imports to see:
+- What exactly is imported from each source
+- Which imports are type-only
+- Whether default, named, or namespace imports are used
+
+## OUTPUT FORMAT
+
+### Dependency Graph Summary
+| Metric | Value |
+|--------|-------|
+| Total modules | X |
+| Internal modules | Y |
+| External packages | Z |
+| Total edges | N |
+| Circular dependencies | M |
+
+### Circular Dependencies (if any)
+1. \`module-a.ts\` → \`module-b.ts\` → \`module-a.ts\`
+   - Severity: HIGH (2-node cycle)
+   - Suggested fix: Extract shared code to new module
+
+### Hot Spots
+| Module | Incoming | Outgoing | Risk |
+|--------|----------|----------|------|
+| utils/index.ts | 15 | 3 | HIGH - God module |
+| services/api.ts | 2 | 12 | MEDIUM - Many deps |
+
+### External Packages (N total)
+- **Core**: react, express, lodash
+- **Dev**: typescript, eslint, vitest
+- **Potential issues**:
+  - lodash + underscore (duplicate functionality)
+
+### Recommendations
+1. Break up utils/index.ts into focused modules
+2. Resolve circular dependency between A and B
+3. Consider replacing moment with date-fns (smaller bundle)
+
+## RULES
+
+- Focus on structural issues, not code quality
+- Prioritize circular dependencies (they cause real problems)
+- Don't flag normal patterns as issues
+- Provide actionable recommendations
+- Be concise - expand only on request`,
+    tags: ['analysis', 'dependencies', 'audit', 'architecture'],
+    version: '1.0.0',
+});

package/dist/skills/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * TypeScript/JavaScript Analysis Skills
+ *
+ * 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';
+/**
+ * All TypeScript/JavaScript analysis skills
+ */
+export declare const tsSkills: Skill[];

package/dist/skills/index.js

@@ -0,0 +1,27 @@
+/**
+ * TypeScript/JavaScript Analysis Skills
+ *
+ * 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';
+// 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';
+/**
+ * All TypeScript/JavaScript analysis skills
+ */
+export const tsSkills = [
+    codeStructureSkill,
+    dependencyAuditSkill,
+    refactorImpactSkill,
+    typeAnalysisSkill,
+    codeHealthSkill,
+];

package/dist/skills/refactor-impact.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Refactor Impact Skill
+ *
+ * Analyze the impact of refactoring a symbol across the codebase.
+ */
+/**
+ * Refactor impact skill - Analyze impact of refactoring a symbol
+ */
+export declare const refactorImpactSkill: import("@compilr-dev/agents").Skill;

package/dist/skills/refactor-impact.js

@@ -0,0 +1,135 @@
+/**
+ * Refactor Impact Skill
+ *
+ * Analyze the impact of refactoring a symbol across the codebase.
+ */
+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',
+    prompt: `You are in REFACTOR IMPACT ANALYSIS mode. Analyze what would be affected by refactoring a symbol.
+
+## TOOLS TO USE
+
+1. **find_symbol**: Locate the symbol definition
+   - Find where the symbol is defined
+   - Get its type (function, class, interface, etc.)
+   - Check if it's exported
+
+2. **find_references**: Find all usages of the symbol
+   - Direct usages in code
+   - Import statements
+   - Type references
+   - Inheritance (extends/implements)
+
+3. **get_call_graph**: Understand call relationships
+   - What functions call this symbol?
+   - What does this symbol call?
+   - Trace the impact chain
+
+4. **get_type_hierarchy**: For classes/interfaces
+   - What extends or implements this?
+   - What does this extend or implement?
+   - Interface implementations affected
+
+## ANALYSIS WORKFLOW
+
+### Step 1: Locate the Symbol
+\`\`\`
+find_symbol({
+  symbol: "SymbolName",
+  scope: "/path/to/project",
+  kind: "any"  // or specific: function, class, interface
+})
+\`\`\`
+
+### Step 2: Find All References
+\`\`\`
+find_references({
+  symbol: "SymbolName",
+  scope: "/path/to/project",
+  groupByFile: true
+})
+\`\`\`
+
+### Step 3: Analyze Call Graph (for functions/methods)
+\`\`\`
+get_call_graph({
+  path: "/path/to/file.ts",
+  functionName: "functionName",
+  direction: "both",
+  maxDepth: 2
+})
+\`\`\`
+
+### Step 4: Check Type Hierarchy (for classes/interfaces)
+\`\`\`
+get_type_hierarchy({
+  path: "/path/to/file.ts",
+  typeName: "TypeName",
+  direction: "both"
+})
+\`\`\`
+
+## OUTPUT FORMAT
+
+### Symbol Overview
+| Property | Value |
+|----------|-------|
+| Name | \`SymbolName\` |
+| Type | function / class / interface |
+| Defined in | path/to/file.ts:42 |
+| Exported | Yes / No |
+
+### Direct Impact (files that directly use this symbol)
+| File | Usages | Types |
+|------|--------|-------|
+| src/index.ts | 3 | import, call, call |
+| src/service.ts | 1 | import |
+
+### Indirect Impact (files affected through call chain)
+| File | Distance | Path |
+|------|----------|------|
+| src/api.ts | 2 | api.ts → service.ts → Symbol |
+
+### Type Hierarchy Impact (if applicable)
+- **Extends**: ParentClass (changes may break parent contract)
+- **Extended by**: ChildClass1, ChildClass2 (children may need updates)
+- **Implements**: IInterface (interface changes affect all implementors)
+- **Implemented by**: ClassA, ClassB (N implementations to update)
+
+### Risk Assessment
+| Risk Level | Reason |
+|------------|--------|
+| 🔴 HIGH | 15+ files affected, exported from public API |
+| 🟡 MEDIUM | 5-15 files affected |
+| 🟢 LOW | <5 files affected, internal only |
+
+### Refactoring Checklist
+- [ ] Update definition in source file
+- [ ] Update N import statements
+- [ ] Update N call sites
+- [ ] Update N type references
+- [ ] Update N child classes (if applicable)
+- [ ] Run tests to verify
+
+### Suggested Approach
+1. Start with X because...
+2. Then update Y...
+3. Finally, verify with tests
+
+## RULES
+
+- Always start with find_symbol to understand what you're dealing with
+- Use find_references to get complete picture
+- Only use get_call_graph for functions/methods
+- Only use get_type_hierarchy for classes/interfaces
+- 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',
+});

package/dist/skills/type-analysis.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Type Analysis Skill
+ *
+ * Analyze type hierarchies, interfaces, and their implementations.
+ */
+/**
+ * Type analysis skill - Analyze type hierarchies and implementations
+ */
+export declare const typeAnalysisSkill: import("@compilr-dev/agents").Skill;