@compilr-dev/agents-coding 0.2.1 → 1.0.0

package/dist/skills/index.d.ts

@@ -1,49 +0,0 @@
-/**
- * Coding-specific Skills for @compilr-dev/agents-coding
- *
- * These skills are designed to work with the coding tools and provide
- * specialized guidance for common development workflows.
- */
-import { type Skill } from '@compilr-dev/agents';
-/**
- * Git workflow skill - Safe git operations with proper verification
- */
-export declare const gitWorkflowSkill: Skill;
-/**
- * Test-driven development skill
- */
-export declare const testDrivenSkill: Skill;
-/**
- * Code navigation skill
- */
-export declare const codeNavigationSkill: Skill;
-/**
- * Pull request workflow skill
- */
-export declare const prWorkflowSkill: Skill;
-/**
- * Project onboarding skill
- */
-export declare const projectOnboardingSkill: Skill;
-/**
- * Code optimization skill
- */
-export declare const codeOptimizationSkill: Skill;
-/**
- * Build skill - Implement a backlog item end-to-end
- * Moved from @compilr-dev/agents because it uses run_tests, run_lint
- */
-export declare const buildSkill: Skill;
-/**
- * Scaffold skill - Create project foundation based on tech stack
- * Moved from @compilr-dev/agents because it uses detect_project
- */
-export declare const scaffoldSkill: Skill;
-/**
- * All coding skills
- */
-export declare const codingSkills: Skill[];
-/**
- * Export individual skills for selective use
- */
-export { defineSkill, type Skill } from '@compilr-dev/agents';

package/dist/skills/index.js

@@ -1,532 +0,0 @@
-/**
- * Coding-specific Skills for @compilr-dev/agents-coding
- *
- * These skills are designed to work with the coding tools and provide
- * specialized guidance for common development workflows.
- */
-import { defineSkill } from '@compilr-dev/agents';
-/**
- * Git workflow skill - Safe git operations with proper verification
- */
-export const gitWorkflowSkill = defineSkill({
-    name: 'git-workflow',
-    description: 'Best practices for git operations with safety checks',
-    prompt: `You are now in git workflow mode. Follow these practices:
-
-## Before Any Destructive Operation
-1. **Always check status first**: Use gitStatus to see current state
-2. **Review changes**: Use gitDiff to understand what will be affected
-3. **Verify branch**: Confirm you're on the correct branch
-
-## Safe Commit Workflow
-1. Check status: gitStatus to see staged/unstaged files
-2. Review diff: gitDiff to verify changes are intentional
-3. Stage selectively: Only commit related changes together
-4. Write clear message: Describe WHY, not just WHAT
-
-## Branch Operations
-1. Never delete the current branch
-2. Check for uncommitted changes before switching
-3. Use descriptive branch names: feat/, fix/, chore/
-
-## Danger Zones - ALWAYS VERIFY
-- git reset --hard: Will lose uncommitted changes
-- git checkout -- <file>: Will discard local changes
-- git clean: Will delete untracked files
-- Force push: Can overwrite remote history
-
-## Recovery
-- Use gitStash before risky operations
-- Check gitLog to find previous states
-- Stashed changes can be recovered with stash pop/apply
-
-When in doubt, stash your changes first.`,
-    tags: ['git', 'workflow', 'safety'],
-    version: '1.0.0',
-});
-/**
- * Test-driven development skill
- */
-export const testDrivenSkill = defineSkill({
-    name: 'test-driven',
-    description: 'Test-driven development workflow with smart runners',
-    prompt: `You are now in test-driven development mode. Follow the TDD cycle:
-
-## Red-Green-Refactor Cycle
-1. **Red**: Write a failing test first
-2. **Green**: Write minimal code to pass the test
-3. **Refactor**: Clean up while keeping tests green
-
-## Using the Tools
-1. **runTests**: Run tests frequently, after every small change
-2. **runLint**: Check for code style issues before committing
-3. **runBuild**: Verify the build passes before pushing
-4. **runFormat**: Auto-format code to maintain consistency
-
-## Workflow
-\`\`\`
-1. Write test → runTests (should fail)
-2. Implement feature → runTests (should pass)
-3. Refactor → runTests (should still pass)
-4. Clean up → runLint + runFormat
-5. Final check → runBuild
-6. Commit
-\`\`\`
-
-## Best Practices
-- Test one thing per test case
-- Use descriptive test names that explain the expected behavior
-- Test edge cases and error conditions
-- Keep tests fast - mock external dependencies
-- Run the full test suite before pushing
-
-## When Tests Fail
-1. Read the error message carefully
-2. Check if the test itself is correct
-3. Isolate the failure to specific code
-4. Fix incrementally and re-run
-
-Never commit with failing tests.`,
-    tags: ['testing', 'tdd', 'workflow'],
-    version: '1.0.0',
-});
-/**
- * Code navigation skill
- */
-export const codeNavigationSkill = defineSkill({
-    name: 'code-navigation',
-    description: 'Effectively navigate and understand codebases',
-    prompt: `You are now in code navigation mode. Use these strategies:
-
-## Finding Code
-1. **findDefinition**: Locate where a symbol is defined
-   - Functions, classes, interfaces, types, constants
-   - Supports: TypeScript, JavaScript, Python, Rust, Go, Java, Kotlin
-
-2. **findReferences**: Find all usages of a symbol
-   - Use excludeDefinitions: true to see only usages
-   - Helps understand impact of changes
-
-3. **findTodos**: Locate technical debt and work items
-   - Types: TODO, FIXME, HACK, XXX, NOTE, BUG, WARN
-   - Use includeAuthor: true to see who added them
-
-## Understanding a New Codebase
-1. Start with detectProject to understand the tech stack
-2. Find entry points (main, index, app files)
-3. Trace the flow from entry point using findReferences
-4. Look at TODOs to understand known issues
-
-## Before Making Changes
-1. Find the symbol definition
-2. Find all references to understand impact
-3. Check for TODOs/FIXMEs in related code
-4. Understand the patterns used nearby
-
-## Search Strategies
-- Start broad, then narrow with fileType filter
-- Use excludeDefinitions to focus on usages
-- Check multiple related symbols
-- Look at import statements to understand dependencies
-
-## Common Patterns
-- "Where is X defined?" → findDefinition
-- "What uses X?" → findReferences with excludeDefinitions
-- "What needs work?" → findTodos
-- "What's the tech stack?" → detectProject`,
-    tags: ['navigation', 'search', 'understanding'],
-    version: '1.0.0',
-});
-/**
- * Pull request workflow skill
- */
-export const prWorkflowSkill = defineSkill({
-    name: 'pr-workflow',
-    description: 'Pull request creation and review workflow',
-    prompt: `You are now in pull request workflow mode.
-
-## Creating a PR
-1. **Prepare the branch**
-   - gitStatus: Ensure all changes are committed
-   - gitLog: Review commits that will be in the PR
-   - gitDiff main...HEAD: See full diff against base
-
-2. **Pre-flight checks**
-   - runTests: All tests must pass
-   - runLint: No lint errors
-   - runBuild: Build must succeed
-   - findTodos: No critical TODOs in changed code
-
-3. **Write the PR description**
-   - Summary: What does this PR do?
-   - Why: What problem does it solve?
-   - How: Brief technical approach
-   - Testing: How was it tested?
-   - Screenshots: If UI changes
-
-## Reviewing a PR
-1. **Understand context**
-   - Read the PR description
-   - Check linked issues
-   - gitLog to see commit history
-
-2. **Review the code**
-   - gitDiff to see all changes
-   - findDefinition for unfamiliar symbols
-   - findReferences to check impact
-
-3. **Check quality**
-   - runTests: Do tests pass?
-   - runLint: Any new lint issues?
-   - findTodos: Any new TODOs without context?
-
-4. **Provide feedback**
-   - Be specific with line references
-   - Suggest alternatives, not just problems
-   - Distinguish blocking vs. non-blocking comments
-
-## Before Merging
-- [ ] All CI checks pass
-- [ ] No unresolved comments
-- [ ] Documentation updated if needed
-- [ ] Changelog updated if needed`,
-    tags: ['git', 'pr', 'review', 'workflow'],
-    version: '1.0.0',
-});
-/**
- * Project onboarding skill
- */
-export const projectOnboardingSkill = defineSkill({
-    name: 'project-onboarding',
-    description: 'Quickly understand and navigate a new project',
-    prompt: `You are now in project onboarding mode. Use this systematic approach:
-
-## Step 1: Project Overview
-1. **detectProject**: Identify technology stack
-   - Project type (Node, Python, Rust, Go, etc.)
-   - Package manager
-   - Test framework
-   - Linter and formatter
-
-2. **findProjectRoot**: Locate project boundaries
-   - Find the root directory
-   - Identify monorepo structure if present
-
-## Step 2: Architecture
-1. Look for README, ARCHITECTURE, or CLAUDE.md files
-2. Check directory structure for patterns
-3. Identify entry points (main, index, app)
-4. Find configuration files
-
-## Step 3: Key Components
-1. **findDefinition** on main exports
-2. **findReferences** to understand dependencies
-3. Check for interfaces/types that define contracts
-
-## Step 4: Development Workflow
-1. Check package.json scripts or Makefile
-2. Identify how to:
-   - Run locally (dev server)
-   - Run tests
-   - Build for production
-   - Lint and format
-
-## Step 5: Code Quality
-1. **findTodos** to see known issues
-2. Check for TODOs with your name/team
-3. Look at recent git log for activity areas
-
-## Quick Reference Questions
-| Question | Tool |
-|----------|------|
-| What tech stack? | detectProject |
-| Where's the root? | findProjectRoot |
-| Where is X defined? | findDefinition |
-| What uses X? | findReferences |
-| What needs work? | findTodos |
-| What changed? | gitLog, gitDiff |
-
-## Red Flags to Note
-- Many FIXME/HACK comments
-- Outdated dependencies
-- Missing tests
-- No documentation`,
-    tags: ['onboarding', 'navigation', 'understanding'],
-    version: '1.0.0',
-});
-/**
- * Code optimization skill
- */
-export const codeOptimizationSkill = defineSkill({
-    name: 'code-optimization',
-    description: 'Performance optimization workflow',
-    prompt: `You are now in code optimization mode.
-
-## Before Optimizing
-1. **Measure first**: Never optimize without benchmarks
-2. **Profile**: Identify actual bottlenecks
-3. **Set targets**: Define acceptable performance
-
-## Finding Optimization Targets
-1. **findTodos**: Search for 'TODO.*perf' or 'TODO.*optim'
-2. **findReferences**: Check how often a function is called
-3. **Look for patterns**:
-   - Loops with database calls
-   - Repeated calculations
-   - Large object copies
-   - Synchronous I/O
-
-## Safe Optimization Process
-1. Write performance test/benchmark
-2. Measure current performance
-3. Make ONE change at a time
-4. Measure again - verify improvement
-5. runTests - ensure no regressions
-6. Document the optimization
-
-## Common Optimizations
-- **Caching**: Memoize expensive calculations
-- **Batching**: Combine multiple operations
-- **Lazy loading**: Defer until needed
-- **Pagination**: Don't load everything at once
-- **Indexing**: Ensure database queries are indexed
-
-## After Optimizing
-1. runTests: No functionality broken
-2. runBuild: Build still works
-3. Document: Add comments explaining why
-4. Monitor: Verify improvement in production
-
-## Avoid
-- Premature optimization
-- Optimizing without measuring
-- Sacrificing readability for micro-optimizations
-- Assuming - always measure`,
-    tags: ['performance', 'optimization', 'workflow'],
-    version: '1.0.0',
-});
-/**
- * Build skill - Implement a backlog item end-to-end
- * Moved from @compilr-dev/agents because it uses run_tests, run_lint
- */
-export const buildSkill = defineSkill({
-    name: 'build',
-    description: 'Implement a backlog item end-to-end',
-    tags: ['implementation', 'coding'],
-    prompt: `You are in BUILD MODE. Implement the specified backlog item.
-
-## CRITICAL: PROJECT DIRECTORY
-
-**All files MUST be created/modified in: {{projectPath}}**
-
-Use ABSOLUTE paths for ALL file operations. Example:
-- write_file({ path: "{{projectPath}}/src/feature.ts", ... })
-- edit({ path: "{{projectPath}}/src/index.ts", ... })
-
-NEVER use relative paths. NEVER use process.cwd().
-
-## ITEM TO IMPLEMENT
-- **ID:** {{item_id}}
-- **Title:** {{item_title}}
-- **Type:** {{item_type}}
-- **Priority:** {{item_priority}}
-- **Description:** {{item_description}}
-
-## BEFORE STARTING
-
-1. Show the item details to the user in a clear format
-2. Use ask_user_simple to confirm: "Proceed with implementation?"
-   - Options: "Yes, let's build it", "No, pick a different item", "Cancel"
-3. If there are dependency warnings, mention them and ask if user wants to proceed anyway
-
-## CONTEXT TO READ
-
-Before implementing, read these files for context:
-- **PRD.md** (if exists): Project vision and requirements
-- **CLAUDE.md**: Coding standards and conventions
-- **Existing code**: Understand patterns already in use
-
-## IMPLEMENTATION WORKFLOW
-
-### Phase 1: Plan
-1. Use todo_write to create implementation checklist:
-   - Break down the item into concrete tasks
-   - Identify files to create or modify
-   - Note any edge cases to handle
-2. Update backlog status to 🚧 using backlog_write
-
-### Phase 2: Implement
-1. Write code following project conventions from CLAUDE.md
-2. Add tests if the project has a test framework
-3. Keep changes focused on the backlog item scope
-4. Use todo_write to track progress through tasks
-
-### Phase 3: Verify
-1. Run tests with run_tests tool
-2. Run lint with run_lint tool
-3. If tests or lint fail:
-   - Analyze the error message
-   - Fix the issue
-   - Re-run verification
-   - Repeat up to 3 times
-4. If still failing after 3 attempts:
-   - Report the issue to user
-   - Keep status as 🚧
-   - Ask for guidance
-
-### Phase 4: Complete
-1. Update backlog status to ✅ using backlog_write
-2. Create git commit with message format:
-   - feat({{item_id}}): {{item_title}} - for features
-   - fix({{item_id}}): {{item_title}} - for bugs
-   - chore({{item_id}}): {{item_title}} - for chores
-3. Update backlog with the commit SHA
-4. Clear todos with todo_write
-5. Summarize what was implemented
-
-## RULES
-
-- Follow coding standards from CLAUDE.md strictly
-- Keep commits atomic - one backlog item per commit
-- Ask user via ask_user_simple if you hit blockers
-- Don't over-engineer - implement exactly what the item describes
-- Don't add features beyond what was requested
-- Use todo_write throughout to show progress
-- Always run tests before marking complete`,
-    version: '1.0.0',
-});
-/**
- * Scaffold skill - Create project foundation based on tech stack
- * Moved from @compilr-dev/agents because it uses detect_project
- */
-export const scaffoldSkill = defineSkill({
-    name: 'scaffold',
-    description: 'Create project foundation based on tech stack',
-    tags: ['setup', 'foundation', 'scaffolding'],
-    prompt: `You are creating the PROJECT SCAFFOLD (foundation).
-
-## CRITICAL: PROJECT DIRECTORY
-
-**All files MUST be created in: {{projectPath}}**
-
-Use ABSOLUTE paths for ALL file operations. Example:
-- write_file({ path: "{{projectPath}}/package.json", ... })
-- write_file({ path: "{{projectPath}}/src/index.ts", ... })
-
-NEVER use relative paths. NEVER use process.cwd().
-
-## PURPOSE
-
-Create the base project structure that features will be built on top of.
-This is the skeleton that makes feature implementation possible.
-
-## CONTEXT TO READ
-
-Use project_document_get to read project documents from the database:
-- PRD document for project vision and requirements
-- Architecture documents if they exist
-
-## BEFORE STARTING
-
-1. Summarize the detected/specified tech stack
-2. Use ask_user_simple to confirm: "Create project scaffold with this stack?"
-   - Options: "Yes, create it", "No, let me specify", "Cancel"
-3. If user wants to specify, ask about tech stack preferences
-
-## SCAFFOLD BY PROJECT TYPE
-
-### Web Application (React/Vue/Svelte)
-
-Create:
-- \`src/\` folder structure:
-  - \`src/components/\` - Reusable components
-  - \`src/pages/\` or \`src/routes/\` - Page components
-  - \`src/lib/\` or \`src/utils/\` - Utility functions
-  - \`src/styles/\` - Global styles
-- \`package.json\` with dependencies
-- Build config (\`vite.config.ts\`, \`next.config.js\`, etc.)
-- \`index.html\` entry point (if applicable)
-- Basic App component with routing setup
-- CSS/Tailwind configuration
-- \`.gitignore\`
-- \`README.md\` with setup instructions
-
-### API / Backend (Node/Python/Go)
-
-Create:
-- \`src/\` folder structure:
-  - \`src/routes/\` or \`src/api/\` - API endpoints
-  - \`src/services/\` - Business logic
-  - \`src/models/\` - Data models
-  - \`src/utils/\` - Utilities
-- \`package.json\` / \`requirements.txt\` / \`go.mod\`
-- Entry point (\`src/index.ts\`, \`main.py\`, \`main.go\`)
-- Basic server setup (Express, FastAPI, Gin, etc.)
-- Health check endpoint (\`GET /health\`)
-- Environment config (\`.env.example\`)
-- \`.gitignore\`
-- \`README.md\` with setup instructions
-
-### CLI Tool (Node/Python/Rust)
-
-Create:
-- \`src/\` folder structure:
-  - \`src/commands/\` - Command handlers
-  - \`src/utils/\` - Utilities
-- \`package.json\` with \`bin\` entry / \`setup.py\` / \`Cargo.toml\`
-- Entry point with argument parsing
-- Basic command structure (help, version)
-- \`.gitignore\`
-- \`README.md\` with usage instructions
-
-### Full-Stack Application
-
-Create both frontend and backend structures:
-- \`frontend/\` or \`client/\` - Web app scaffold
-- \`backend/\` or \`server/\` - API scaffold
-- Root \`package.json\` with workspace config (if monorepo)
-- \`docker-compose.yml\` (optional)
-- \`.gitignore\`
-- \`README.md\` with setup instructions
-
-## POST-SCAFFOLD STEPS
-
-1. Install dependencies:
-   - \`npm install\` / \`pip install -r requirements.txt\` / etc.
-2. Run build to verify:
-   - \`npm run build\` / equivalent
-3. Run lint to verify:
-   - \`npm run lint\` / equivalent
-4. Create initial git commit:
-   - \`chore: initial project scaffold\`
-5. Update backlog:
-   - Mark scaffold CHORE as ✅ (if exists)
-
-## RULES
-
-- Follow conventions from CLAUDE.md
-- Use modern, widely-adopted patterns
-- Keep it minimal - only what's needed to start
-- Don't add features - just structure
-- Ensure the project builds and lints clean
-- Add helpful comments in config files
-- Include TypeScript/type hints where applicable`,
-    version: '1.0.0',
-});
-/**
- * All coding skills
- */
-export const codingSkills = [
-    gitWorkflowSkill,
-    testDrivenSkill,
-    codeNavigationSkill,
-    prWorkflowSkill,
-    projectOnboardingSkill,
-    codeOptimizationSkill,
-    buildSkill,
-    scaffoldSkill,
-];
-/**
- * Export individual skills for selective use
- */
-export { defineSkill } from '@compilr-dev/agents';

package/dist/tools/git/branch.d.ts

@@ -1,17 +0,0 @@
-/**
- * Git Branch Tool
- * List, create, delete, switch, and rename branches
- */
-import type { Tool } from '@compilr-dev/agents';
-import type { GitBranchInput } from './types.js';
-/**
- * Git branch tool
- */
-export declare const gitBranchTool: Tool<GitBranchInput>;
-/**
- * Factory function to create git branch tool with custom options
- */
-export declare function createGitBranchTool(options?: {
-    /** Base directory for relative paths */
-    baseDir?: string;
-}): Tool<GitBranchInput>;