@compilr-dev/agents-coding 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @compilr-dev/agents-coding
+ *
+ * Coding-specific tools for @compilr-dev/agents
+ * Git operations, project detection, smart runners, and code search
+ */
+export { gitStatusTool, gitDiffTool, gitLogTool, createGitStatusTool, createGitDiffTool, createGitLogTool, gitCommitTool, gitBranchTool, gitStashTool, createGitCommitTool, createGitBranchTool, createGitStashTool, } from './tools/git/index.js';
+export type { GitStatusInput, GitStatusResult, GitFileStatus, GitDiffInput, GitDiffResult, GitLogInput, GitLogResult, GitCommit, GitCommitInput, GitCommitResult, CommitSafetyWarning, GitBranchAction, GitBranchInput, GitBranchInfo, GitBranchResult, GitStashAction, GitStashInput, GitStashEntry, GitStashResult, } from './tools/git/index.js';
+export { detectProjectTool, findProjectRootTool, createDetectProjectTool, createFindProjectRootTool, } from './tools/project/index.js';
+export type { DetectProjectInput, DetectProjectResult, ProjectType, FindProjectRootInput, FindProjectRootResult, } from './tools/project/index.js';
+export { runTestsTool, runLintTool, runBuildTool, runFormatTool, createRunTestsTool, createRunLintTool, createRunBuildTool, createRunFormatTool, } from './tools/runners/index.js';
+export type { BaseRunnerInput, BaseRunnerResult, RunTestsInput, RunTestsResult, RunLintInput, RunLintResult, RunBuildInput, RunBuildResult, RunFormatInput, RunFormatResult, } from './tools/runners/index.js';
+export { findDefinitionTool, findReferencesTool, findTodosTool, createFindDefinitionTool, createFindReferencesTool, createFindTodosTool, } from './tools/search/index.js';
+export type { DefinitionType, Definition, FindDefinitionInput, FindDefinitionResult, Reference, FindReferencesInput, FindReferencesResult, TodoType, TodoComment, FindTodosInput, FindTodosResult, } from './tools/search/index.js';
+export { codingSkills, gitWorkflowSkill, testDrivenSkill, codeNavigationSkill, prWorkflowSkill, projectOnboardingSkill, codeOptimizationSkill, defineSkill, type Skill, } from './skills/index.js';
+/**
+ * All coding tools for easy registration
+ */
+export declare const codingTools: {
+    readonly gitStatus: import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitStatusInput>;
+    readonly gitDiff: import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitDiffInput>;
+    readonly gitLog: import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitLogInput>;
+    readonly gitCommit: import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitCommitInput>;
+    readonly gitBranch: import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitBranchInput>;
+    readonly gitStash: import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitStashInput>;
+    readonly detectProject: import("@compilr-dev/agents").Tool<import("./tools/project/types.js").DetectProjectInput>;
+    readonly findProjectRoot: import("@compilr-dev/agents").Tool<import("./tools/project/types.js").FindProjectRootInput>;
+    readonly runTests: import("@compilr-dev/agents").Tool<import("./tools/runners/types.js").RunTestsInput>;
+    readonly runLint: import("@compilr-dev/agents").Tool<import("./tools/runners/types.js").RunLintInput>;
+    readonly runBuild: import("@compilr-dev/agents").Tool<import("./tools/runners/types.js").RunBuildInput>;
+    readonly runFormat: import("@compilr-dev/agents").Tool<import("./tools/runners/types.js").RunFormatInput>;
+    readonly findDefinition: import("@compilr-dev/agents").Tool<import("./tools/search/types.js").FindDefinitionInput>;
+    readonly findReferences: import("@compilr-dev/agents").Tool<import("./tools/search/types.js").FindReferencesInput>;
+    readonly findTodos: import("@compilr-dev/agents").Tool<import("./tools/search/types.js").FindTodosInput>;
+};
+/**
+ * Array of all coding tools
+ */
+export declare const allCodingTools: readonly [import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitStatusInput>, import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitDiffInput>, import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitLogInput>, import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitCommitInput>, import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitBranchInput>, import("@compilr-dev/agents").Tool<import("./tools/git/types.js").GitStashInput>, import("@compilr-dev/agents").Tool<import("./tools/project/types.js").DetectProjectInput>, import("@compilr-dev/agents").Tool<import("./tools/project/types.js").FindProjectRootInput>, import("@compilr-dev/agents").Tool<import("./tools/runners/types.js").RunTestsInput>, import("@compilr-dev/agents").Tool<import("./tools/runners/types.js").RunLintInput>, import("@compilr-dev/agents").Tool<import("./tools/runners/types.js").RunBuildInput>, import("@compilr-dev/agents").Tool<import("./tools/runners/types.js").RunFormatInput>, import("@compilr-dev/agents").Tool<import("./tools/search/types.js").FindDefinitionInput>, import("@compilr-dev/agents").Tool<import("./tools/search/types.js").FindReferencesInput>, import("@compilr-dev/agents").Tool<import("./tools/search/types.js").FindTodosInput>];

package/dist/index.js

@@ -0,0 +1,75 @@
+/**
+ * @compilr-dev/agents-coding
+ *
+ * Coding-specific tools for @compilr-dev/agents
+ * Git operations, project detection, smart runners, and code search
+ */
+// Git tools (Phase 1 + Phase 2)
+export { 
+// Phase 1: Read-only
+gitStatusTool, gitDiffTool, gitLogTool, createGitStatusTool, createGitDiffTool, createGitLogTool, 
+// Phase 2: Core git
+gitCommitTool, gitBranchTool, gitStashTool, createGitCommitTool, createGitBranchTool, createGitStashTool, } from './tools/git/index.js';
+// Project detection tools
+export { detectProjectTool, findProjectRootTool, createDetectProjectTool, createFindProjectRootTool, } from './tools/project/index.js';
+// Smart Runner tools (Phase 3)
+export { runTestsTool, runLintTool, runBuildTool, runFormatTool, createRunTestsTool, createRunLintTool, createRunBuildTool, createRunFormatTool, } from './tools/runners/index.js';
+// Code Search tools (Phase 4)
+export { findDefinitionTool, findReferencesTool, findTodosTool, createFindDefinitionTool, createFindReferencesTool, createFindTodosTool, } from './tools/search/index.js';
+// Skills (Phase 5)
+export { codingSkills, gitWorkflowSkill, testDrivenSkill, codeNavigationSkill, prWorkflowSkill, projectOnboardingSkill, codeOptimizationSkill, defineSkill, } from './skills/index.js';
+// Re-export all tools as a collection
+import { gitStatusTool, gitDiffTool, gitLogTool, gitCommitTool, gitBranchTool, gitStashTool, } from './tools/git/index.js';
+import { detectProjectTool, findProjectRootTool } from './tools/project/index.js';
+import { runTestsTool, runLintTool, runBuildTool, runFormatTool } from './tools/runners/index.js';
+import { findDefinitionTool, findReferencesTool, findTodosTool } from './tools/search/index.js';
+/**
+ * All coding tools for easy registration
+ */
+export const codingTools = {
+    // Phase 1: Read-only git
+    gitStatus: gitStatusTool,
+    gitDiff: gitDiffTool,
+    gitLog: gitLogTool,
+    // Phase 2: Core git
+    gitCommit: gitCommitTool,
+    gitBranch: gitBranchTool,
+    gitStash: gitStashTool,
+    // Project detection
+    detectProject: detectProjectTool,
+    findProjectRoot: findProjectRootTool,
+    // Phase 3: Smart runners
+    runTests: runTestsTool,
+    runLint: runLintTool,
+    runBuild: runBuildTool,
+    runFormat: runFormatTool,
+    // Phase 4: Code search
+    findDefinition: findDefinitionTool,
+    findReferences: findReferencesTool,
+    findTodos: findTodosTool,
+};
+/**
+ * Array of all coding tools
+ */
+export const allCodingTools = [
+    // Phase 1
+    gitStatusTool,
+    gitDiffTool,
+    gitLogTool,
+    // Phase 2
+    gitCommitTool,
+    gitBranchTool,
+    gitStashTool,
+    // Project detection
+    detectProjectTool,
+    findProjectRootTool,
+    // Phase 3
+    runTestsTool,
+    runLintTool,
+    runBuildTool,
+    runFormatTool,
+    // Phase 4
+    findDefinitionTool,
+    findReferencesTool,
+    findTodosTool,
+];

package/dist/skills/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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;
+/**
+ * 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

@@ -0,0 +1,322 @@
+/**
+ * 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',
+});
+/**
+ * All coding skills
+ */
+export const codingSkills = [
+    gitWorkflowSkill,
+    testDrivenSkill,
+    codeNavigationSkill,
+    prWorkflowSkill,
+    projectOnboardingSkill,
+    codeOptimizationSkill,
+];
+/**
+ * Export individual skills for selective use
+ */
+export { defineSkill } from '@compilr-dev/agents';

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

@@ -0,0 +1,17 @@
+/**
+ * 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>;