@compilr-dev/agents-coding-go 0.1.0

package/dist/skills/go-best-practices.js

@@ -0,0 +1,78 @@
+/**
+ * Go Best Practices Skill
+ *
+ * Provides guidance for Go-specific coding patterns and analysis.
+ */
+import { defineSkill } from "@compilr-dev/agents";
+export const goBestPracticesSkill = defineSkill({
+    name: "go-best-practices",
+    description: "Go-specific coding guidance and analysis workflow",
+    version: "1.0.0",
+    tags: ["python", "best-practices", "analysis"],
+    prompt: `You are in Go analysis mode. Use these tools for comprehensive code understanding:
+
+## Code Structure Analysis
+- **getFileStructure**: Get overview of classes, functions, imports, variables
+  - Use to understand file organization
+  - Identify public API surface
+  - See class hierarchies and method signatures
+
+## Go-Specific Guidance
+
+### Naming Conventions (PEP 8)
+- \`snake_case\` for functions, variables, modules
+- \`PascalCase\` for classes
+- \`UPPER_CASE\` for constants
+- \`_private\` for internal use
+- \`__dunder__\` for special methods
+
+### Type Hints (PEP 484, 585)
+- Always add type hints to function signatures
+- Use \`Optional[T]\` for nullable values
+- Use \`Union[A, B]\` for multiple types
+- Prefer \`list[T]\` over \`List[T]\` (Go 3.9+)
+
+### Docstrings (PEP 257)
+- Use triple quotes for all docstrings
+- First line is a summary
+- Blank line before detailed description
+- Document parameters, returns, raises
+
+### Best Practices
+- Use dataclasses or attrs for data containers
+- Prefer pathlib over os.path
+- Use f-strings over .format()
+- Use context managers for resources
+- Avoid mutable default arguments: \`def foo(x=None)\` not \`def foo(x=[])\`
+- Use \`__all__\` to define public API
+
+### Anti-Patterns to Avoid
+- Bare \`except:\` clauses (catch specific exceptions)
+- \`from module import *\` (explicit imports only)
+- Global variables
+- Deeply nested code (refactor to smaller functions)
+- Magic numbers (use named constants)
+
+## Analysis Workflow
+
+1. **Understand Structure**
+   \`\`\`
+   getFileStructure for overview
+   \`\`\`
+
+2. **Review Complexity**
+   - Look for functions with many parameters
+   - Check for deeply nested code
+   - Identify god classes
+
+3. **Check Code Quality**
+   - Look for missing type hints
+   - Check docstring coverage
+   - Find TODO/FIXME comments
+
+4. **Suggest Improvements**
+   - Recommend refactoring for complex code
+   - Suggest type hints where missing
+   - Propose better naming when unclear
+`,
+});

package/dist/skills/go-code-health.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Go Code Health Skill
+ *
+ * Orchestrates code quality analysis using complexity, dead code, duplicates, patterns, and other tools.
+ */
+export declare const goCodeHealthSkill: import("@compilr-dev/agents").Skill;
+//# sourceMappingURL=go-code-health.d.ts.map

package/dist/skills/go-code-health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"go-code-health.d.ts","sourceRoot":"","sources":["../../src/skills/go-code-health.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,iBAAiB,qCA0M5B,CAAC"}

package/dist/skills/go-code-health.js

@@ -0,0 +1,209 @@
+/**
+ * Go Code Health Skill
+ *
+ * Orchestrates code quality analysis using complexity, dead code, duplicates, patterns, and other tools.
+ */
+import { defineSkill } from "@compilr-dev/agents";
+export const goCodeHealthSkill = defineSkill({
+    name: "go-code-health",
+    description: "Comprehensive Go code quality and health analysis",
+    version: "1.1.0",
+    tags: ["python", "code-health", "quality", "analysis"],
+    prompt: `You are in Go code health analysis mode. Use these tools systematically:
+
+## Health Check Workflow
+
+### Step 1: Complexity Analysis
+Use **get_complexity_go** to find complex code:
+- Cyclomatic complexity > 10 indicates complex logic
+- Cognitive complexity > 15 indicates hard-to-understand code
+- High nesting depth suggests refactoring needed
+- Functions with many parameters need restructuring
+
+### Step 2: Dead Code Detection
+Use **find_dead_code_go** to find unused code:
+- Unused functions (defined but never called)
+- Unused classes (defined but never instantiated)
+- Unused variables (declared but never used)
+- Confidence levels (high/medium/low)
+
+### Step 3: Code Duplication
+Use **find_duplicates_go** to detect duplicated code:
+- Content-based hashing for exact matches
+- Normalized comparison (ignores formatting)
+- Identifies refactoring opportunities
+- Shows duplication percentage
+
+### Step 4: Anti-Patterns and Code Smells
+Use **find_patterns_go** to find issues:
+- Security issues (eval, exec, pickle with untrusted data)
+- Performance issues (star imports, bare except)
+- Maintainability issues (mutable default args, magic numbers)
+- Custom pattern support
+
+### Step 5: Documentation Coverage
+Use **extract_docstrings_go** to check documentation:
+- Functions without docstrings need documentation
+- Missing parameter descriptions
+- Missing return type documentation
+- Missing exception documentation
+
+### Step 6: Import Analysis
+Use **get_imports_go** to review dependencies:
+- High third-party dependency count increases risk
+- Unused imports add clutter
+- Circular import patterns cause issues
+- Prefer stdlib over third-party when possible
+
+### Step 7: Code Structure
+Use **get_file_structure_go** to understand organization:
+- God classes with too many methods
+- Files with too many classes/functions
+- Deep class hierarchies
+- Missing __all__ for public API
+
+## Health Metrics
+
+### Code Complexity
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Cyclomatic | < 5 | 5-10 | > 10 |
+| Cognitive | < 8 | 8-15 | > 15 |
+| Nesting | < 3 | 3-4 | > 4 |
+| Parameters | < 4 | 4-6 | > 6 |
+
+### Dead Code
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Unused functions | 0 | 1-3 | > 3 |
+| Unused classes | 0 | 1-2 | > 2 |
+| Confidence HIGH items | 0 | 0 | > 0 |
+
+### Code Duplication
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Duplication % | < 3% | 3-7% | > 7% |
+| Duplicate blocks | < 3 | 3-5 | > 5 |
+
+### Pattern Issues
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Security issues | 0 | 0 | > 0 |
+| Performance issues | < 3 | 3-5 | > 5 |
+| Maintainability | < 5 | 5-10 | > 10 |
+
+### Documentation
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Public funcs documented | 100% | > 80% | < 80% |
+| Params documented | 100% | > 70% | < 70% |
+| Classes with docstrings | 100% | > 90% | < 90% |
+
+### Dependencies
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Third-party imports | < 10 | 10-20 | > 20 |
+| Local circular deps | 0 | 1-2 | > 2 |
+
+## Quick Health Check (use for rapid assessment)
+
+\`\`\`
+// Step 1: Check complexity hotspots
+get_complexity_go({
+  path: "/path/to/project",
+  recursive: true,
+  threshold: 10,
+  onlyAboveThreshold: true
+})
+
+// Step 2: Find critical patterns
+find_patterns_go({
+  path: "/path/to/project",
+  categories: ["security", "performance"]
+})
+\`\`\`
+
+## Full Health Audit
+
+\`\`\`
+// Step 1: Complexity analysis
+get_complexity_go({ path: "/path/to/project", recursive: true })
+
+// Step 2: Dead code detection
+find_dead_code_go({ path: "/path/to/project" })
+
+// Step 3: Duplication analysis
+find_duplicates_go({ path: "/path/to/project", minLines: 6 })
+
+// Step 4: Pattern analysis
+find_patterns_go({ path: "/path/to/project", categories: ["all"] })
+
+// Step 5: Documentation coverage
+extract_docstrings_go({ path: "/path/to/project" })
+\`\`\`
+
+## Analysis Report Template
+
+\`\`\`markdown
+# Code Health Report
+
+## Summary
+| Metric | Value | Status |
+|--------|-------|--------|
+| Files analyzed | N | - |
+| Avg complexity | X | Good/Warning/Critical |
+| Max complexity | Y | Good/Warning/Critical |
+| Dead code items | N | Good/Warning/Critical |
+| Duplicate blocks | M | Good/Warning/Critical |
+| Duplication % | X% | Good/Warning/Critical |
+| Security issues | S | Good/Warning/Critical |
+| Performance issues | P | Good/Warning/Critical |
+
+## Complexity Hotspots (top 5)
+| Function | File | Cyclomatic | Cognitive | Action |
+|----------|------|------------|-----------|--------|
+| process_order | orders.go:45 | 25 | 32 | Refactor immediately |
+| validate_input | utils.go:120 | 15 | 18 | Consider splitting |
+
+## Dead Code
+| Name | File | Type | Confidence |
+|------|------|------|------------|
+| old_helper | utils.go:89 | function | HIGH |
+| LegacyClass | models.go:12 | class | MEDIUM |
+
+## Code Duplication
+| ID | Lines | Files | Sample |
+|----|-------|-------|--------|
+| DUP-1 | 15 | 3 | \`def validate...\` |
+
+## Pattern Issues
+| Pattern | Severity | Count | Files |
+|---------|----------|-------|-------|
+| eval-usage | ERROR | 2 | api.go, utils.go |
+| bare-except | WARNING | 5 | various |
+| mutable-default | WARNING | 3 | models.go |
+
+## Recommendations (prioritized)
+
+### Critical (fix immediately)
+1. **Security**: Remove eval() usage in api.go:45
+2. **Complexity**: Refactor process_order() - split into smaller functions
+
+### Important (fix soon)
+1. **Dead code**: Remove unused LegacyClass
+2. **Duplication**: Extract common validation logic (DUP-1)
+
+### Suggestions (improve when touching these files)
+1. Add docstrings to undocumented public functions
+2. Fix bare except clauses - catch specific exceptions
+\`\`\`
+
+## When to Use This Skill
+
+- Before code review
+- After major refactoring
+- During tech debt assessment
+- For new team member onboarding
+- Regular health checks (weekly/monthly)
+`,
+});

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

@@ -0,0 +1,7 @@
+/**
+ * Go Code Structure Skill
+ *
+ * Analyzes Go codebase structure, organization, and architecture patterns.
+ */
+export declare const goCodeStructureSkill: import("@compilr-dev/agents").Skill;
+//# sourceMappingURL=go-code-structure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"go-code-structure.d.ts","sourceRoot":"","sources":["../../src/skills/go-code-structure.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,oBAAoB,qCAoJ/B,CAAC"}

package/dist/skills/go-code-structure.js

@@ -0,0 +1,155 @@
+/**
+ * Go Code Structure Skill
+ *
+ * Analyzes Go codebase structure, organization, and architecture patterns.
+ */
+import { defineSkill } from "@compilr-dev/agents";
+export const goCodeStructureSkill = defineSkill({
+    name: "go-code-structure",
+    description: "Analyze Go codebase structure and organization",
+    version: "1.0.0",
+    tags: ["python", "structure", "architecture", "analysis"],
+    prompt: `You are in Go code structure analysis mode. Use these tools systematically:
+
+## Structure Analysis Workflow
+
+### Step 1: File-Level Overview
+Use **get_file_structure_go** to understand each file:
+- Classes and their methods
+- Standalone functions
+- Module-level constants
+- Import organization
+
+### Step 2: Class Hierarchy
+Use **get_class_hierarchy_go** to understand inheritance:
+- Find parent classes (ancestors)
+- Find child classes (descendants)
+- Understand Method Resolution Order (MRO)
+- Identify mixin patterns
+
+### Step 3: Symbol Navigation
+Use **find_symbol_go** to locate definitions:
+- Find where functions are defined
+- Locate class definitions
+- Find constant declarations
+
+### Step 4: Usage Analysis
+Use **find_references_go** to understand usage:
+- How classes/functions are used
+- Import patterns across the codebase
+- Call sites and data flow
+
+## Go Package Structure
+
+### Standard Package Layout
+\`\`\`
+my_package/
+├── __init__.go          # Package exports (__all__)
+├── __main__.go          # Entry point for python -m
+├── core/
+│   ├── __init__.go
+│   └── models.go
+├── utils/
+│   ├── __init__.go
+│   └── helpers.go
+├── cli.go               # CLI entry point
+└── py.typed             # PEP 561 marker
+\`\`\`
+
+### Test Structure
+\`\`\`
+tests/
+├── __init__.go
+├── conftest.go          # pytest fixtures
+├── test_core/
+│   └── test_models.go
+└── test_utils/
+    └── test_helpers.go
+\`\`\`
+
+## Patterns to Look For
+
+### Good Patterns
+- **Layered Architecture**: Clear separation of concerns
+- **Dependency Injection**: Loose coupling via constructor params
+- **Interface Segregation**: Small, focused abstract base classes
+- **Composition over Inheritance**: Prefer has-a over is-a
+
+### Anti-Patterns
+- **God Class**: Class with too many responsibilities (>10 methods, >500 lines)
+- **Circular Dependencies**: Module A imports B, B imports A
+- **Deep Inheritance**: More than 3 levels of inheritance
+- **Spaghetti Code**: No clear structure or organization
+- **Feature Envy**: Methods that use other class's data more than their own
+
+## Structure Metrics
+
+### File Level
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Lines per file | < 300 | 300-500 | > 500 |
+| Classes per file | 1-3 | 4-5 | > 5 |
+| Functions per file | < 15 | 15-25 | > 25 |
+| Imports | < 15 | 15-25 | > 25 |
+
+### Class Level
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Methods per class | < 10 | 10-15 | > 15 |
+| Lines per class | < 200 | 200-400 | > 400 |
+| Inheritance depth | 1-2 | 3 | > 3 |
+| Public methods | < 8 | 8-12 | > 12 |
+
+### Function Level
+| Metric | Good | Acceptable | Needs Work |
+|--------|------|------------|------------|
+| Lines per function | < 20 | 20-40 | > 40 |
+| Parameters | < 4 | 4-6 | > 6 |
+| Return paths | < 3 | 3-5 | > 5 |
+
+## Common Refactoring Suggestions
+
+1. **Extract Class**: Split large class into smaller focused ones
+2. **Extract Function**: Break long functions into smaller ones
+3. **Move Method**: Move method to class where data lives
+4. **Introduce Abstract Base Class**: Create interface for polymorphism
+5. **Replace Inheritance with Composition**: Use delegation instead
+
+## Structure Report Template
+
+\`\`\`markdown
+# Code Structure Report
+
+## Overview
+- Total files: N
+- Total classes: N
+- Total functions: N
+
+## Package Organization
+- Root: my_package/
+- Key modules: core, utils, api
+
+## Class Hierarchy
+1. BaseClass
+   ├── ChildA
+   └── ChildB
+       └── GrandChild
+
+## Hotspots
+1. large_module.go - 600 lines, 8 classes
+2. god_class.go::MegaClass - 25 methods
+
+## Recommendations
+1. Split large_module.go into smaller modules
+2. Extract responsibilities from MegaClass
+\`\`\`
+
+## When to Use This Skill
+
+- Onboarding to a new codebase
+- Before major refactoring
+- Architecture review
+- Documentation generation
+- Understanding legacy code
+`,
+});

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

@@ -0,0 +1,7 @@
+/**
+ * Go Dependency Audit Skill
+ *
+ * Analyzes Go imports, dependencies, and finds circular dependency issues.
+ */
+export declare const goDependencyAuditSkill: import("@compilr-dev/agents").Skill;
+//# sourceMappingURL=go-dependency-audit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"go-dependency-audit.d.ts","sourceRoot":"","sources":["../../src/skills/go-dependency-audit.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,eAAO,MAAM,sBAAsB,qCA+OjC,CAAC"}