@compilr-dev/agents-coding 0.0.1

package/dist/tools/git/branch.js

@@ -0,0 +1,264 @@
+/**
+ * Git Branch Tool
+ * List, create, delete, switch, and rename branches
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { runGitCommand, isGitRepository, isDirectory } from './utils.js';
+/**
+ * Git branch tool
+ */
+export const gitBranchTool = defineTool({
+    name: 'git_branch',
+    description: 'Manage git branches. Actions: list (show all branches), create (new branch), ' +
+        'delete (remove branch), switch (checkout branch), rename (change branch name).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory path (default: current directory)',
+            },
+            action: {
+                type: 'string',
+                enum: ['list', 'create', 'delete', 'switch', 'rename'],
+                description: 'Action to perform',
+            },
+            name: {
+                type: 'string',
+                description: 'Branch name (for create/delete/switch/rename)',
+            },
+            newName: {
+                type: 'string',
+                description: 'New branch name (for rename action)',
+            },
+            remotes: {
+                type: 'boolean',
+                description: 'Include remote branches in list',
+            },
+            force: {
+                type: 'boolean',
+                description: 'Force delete even if not merged',
+            },
+            startPoint: {
+                type: 'string',
+                description: 'Start point for new branch (commit/branch)',
+            },
+        },
+        required: ['action'],
+    },
+    execute: executeGitBranch,
+});
+/**
+ * Execute git branch
+ */
+async function executeGitBranch(input) {
+    const targetPath = input.path ?? process.cwd();
+    // Check if path exists
+    if (!(await isDirectory(targetPath))) {
+        return createErrorResult(`Directory not found: ${targetPath}`);
+    }
+    // Check if it's a git repository
+    if (!(await isGitRepository(targetPath))) {
+        return createErrorResult(`Not a git repository: ${targetPath}`);
+    }
+    try {
+        switch (input.action) {
+            case 'list':
+                return await listBranches(targetPath, input.remotes ?? false);
+            case 'create':
+                if (!input.name) {
+                    return createErrorResult('Branch name is required for create action');
+                }
+                return await createBranch(targetPath, input.name, input.startPoint);
+            case 'delete':
+                if (!input.name) {
+                    return createErrorResult('Branch name is required for delete action');
+                }
+                return await deleteBranch(targetPath, input.name, input.force ?? false);
+            case 'switch':
+                if (!input.name) {
+                    return createErrorResult('Branch name is required for switch action');
+                }
+                return await switchBranch(targetPath, input.name);
+            case 'rename':
+                if (!input.name || !input.newName) {
+                    return createErrorResult('Both name and newName are required for rename action');
+                }
+                return await renameBranch(targetPath, input.name, input.newName);
+            default:
+                return createErrorResult(`Unknown action: ${String(input.action)}`);
+        }
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * List branches
+ */
+async function listBranches(repoPath, includeRemotes) {
+    // Get current branch
+    const currentResult = await runGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], {
+        cwd: repoPath,
+    });
+    const currentBranch = currentResult.success ? currentResult.stdout : '';
+    // List branches with format
+    const args = ['branch', '--format=%(refname:short)\t%(upstream:short)\t%(objectname:short)'];
+    if (includeRemotes) {
+        args.push('-a');
+    }
+    const result = await runGitCommand(args, { cwd: repoPath });
+    if (!result.success) {
+        return createErrorResult(`Failed to list branches: ${result.stderr}`);
+    }
+    const branches = [];
+    for (const line of result.stdout.split('\n').filter(Boolean)) {
+        const [name, tracking, lastCommit] = line.split('\t');
+        const isRemote = name.startsWith('remotes/') || name.includes('/');
+        branches.push({
+            name: isRemote ? name.replace(/^remotes\//, '') : name,
+            isRemote,
+            isCurrent: name === currentBranch,
+            tracking: tracking || undefined,
+            lastCommit: lastCommit || undefined,
+        });
+    }
+    const branchResult = {
+        current: currentBranch,
+        branches,
+        message: `Found ${String(branches.length)} branch(es)`,
+    };
+    return createSuccessResult(branchResult);
+}
+/**
+ * Create a new branch
+ */
+async function createBranch(repoPath, name, startPoint) {
+    const args = ['branch', name];
+    if (startPoint) {
+        args.push(startPoint);
+    }
+    const result = await runGitCommand(args, { cwd: repoPath });
+    if (!result.success) {
+        return createErrorResult(`Failed to create branch: ${result.stderr}`);
+    }
+    const branchResult = {
+        message: `Created branch '${name}'${startPoint ? ` from '${startPoint}'` : ''}`,
+    };
+    return createSuccessResult(branchResult);
+}
+/**
+ * Delete a branch
+ */
+async function deleteBranch(repoPath, name, force) {
+    // Check if trying to delete current branch
+    const currentResult = await runGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], {
+        cwd: repoPath,
+    });
+    if (currentResult.success && currentResult.stdout === name) {
+        return createErrorResult(`Cannot delete the currently checked out branch '${name}'`);
+    }
+    const args = ['branch', force ? '-D' : '-d', name];
+    const result = await runGitCommand(args, { cwd: repoPath });
+    if (!result.success) {
+        if (result.stderr.includes('not fully merged')) {
+            return createErrorResult(`Branch '${name}' is not fully merged. Use force=true to delete anyway.`);
+        }
+        return createErrorResult(`Failed to delete branch: ${result.stderr}`);
+    }
+    const branchResult = {
+        message: `Deleted branch '${name}'`,
+    };
+    return createSuccessResult(branchResult);
+}
+/**
+ * Switch to a branch
+ */
+async function switchBranch(repoPath, name) {
+    // First try 'git switch' (Git 2.23+), fall back to 'git checkout'
+    let result = await runGitCommand(['switch', name], { cwd: repoPath });
+    if (!result.success && result.stderr.includes('not a git command')) {
+        // Fall back to checkout for older Git versions
+        result = await runGitCommand(['checkout', name], { cwd: repoPath });
+    }
+    if (!result.success) {
+        // Check if branch exists
+        const checkResult = await runGitCommand(['rev-parse', '--verify', name], { cwd: repoPath });
+        if (!checkResult.success) {
+            return createErrorResult(`Branch '${name}' does not exist`);
+        }
+        return createErrorResult(`Failed to switch branch: ${result.stderr}`);
+    }
+    const branchResult = {
+        current: name,
+        message: `Switched to branch '${name}'`,
+    };
+    return createSuccessResult(branchResult);
+}
+/**
+ * Rename a branch
+ */
+async function renameBranch(repoPath, oldName, newName) {
+    const args = ['branch', '-m', oldName, newName];
+    const result = await runGitCommand(args, { cwd: repoPath });
+    if (!result.success) {
+        return createErrorResult(`Failed to rename branch: ${result.stderr}`);
+    }
+    const branchResult = {
+        message: `Renamed branch '${oldName}' to '${newName}'`,
+    };
+    return createSuccessResult(branchResult);
+}
+/**
+ * Factory function to create git branch tool with custom options
+ */
+export function createGitBranchTool(options) {
+    return defineTool({
+        name: 'git_branch',
+        description: 'Manage git branches. Actions: list, create, delete, switch, rename.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory path (default: current directory)',
+                },
+                action: {
+                    type: 'string',
+                    enum: ['list', 'create', 'delete', 'switch', 'rename'],
+                    description: 'Action to perform',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Branch name',
+                },
+                newName: {
+                    type: 'string',
+                    description: 'New branch name (for rename)',
+                },
+                remotes: {
+                    type: 'boolean',
+                    description: 'Include remote branches in list',
+                },
+                force: {
+                    type: 'boolean',
+                    description: 'Force delete even if not merged',
+                },
+                startPoint: {
+                    type: 'string',
+                    description: 'Start point for new branch',
+                },
+            },
+            required: ['action'],
+        },
+        execute: async (input) => {
+            let targetPath = input.path ?? '.';
+            // Resolve relative paths
+            if (options?.baseDir && !targetPath.startsWith('/')) {
+                const nodePath = await import('node:path');
+                targetPath = nodePath.join(options.baseDir, targetPath);
+            }
+            return executeGitBranch({ ...input, path: targetPath });
+        },
+    });
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Git Commit Tool
+ * Creates commits with safety features to prevent accidental commits of secrets
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { GitCommitInput } from './types.js';
+/**
+ * Git commit tool
+ */
+export declare const gitCommitTool: Tool<GitCommitInput>;
+/**
+ * Factory function to create git commit tool with custom options
+ */
+export declare function createGitCommitTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Additional secret patterns to check */
+    additionalSecretPatterns?: RegExp[];
+    /** Disable secret checking */
+    disableSecretCheck?: boolean;
+    /** Custom large file threshold in bytes */
+    largeFileThreshold?: number;
+}): Tool<GitCommitInput>;

package/dist/tools/git/commit.js

@@ -0,0 +1,280 @@
+/**
+ * Git Commit Tool
+ * Creates commits with safety features to prevent accidental commits of secrets
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { runGitCommand, isGitRepository, isDirectory } from './utils.js';
+/**
+ * Patterns that indicate potential secrets
+ */
+const SECRET_PATTERNS = [
+    // Environment files
+    /^\.env$/,
+    /^\.env\..+$/,
+    /\.env\.local$/,
+    // Credential files
+    /credentials\.json$/,
+    /\.credentials$/,
+    /secrets\.json$/,
+    /secrets\.ya?ml$/,
+    // Key files
+    /\.pem$/,
+    /\.key$/,
+    /id_rsa$/,
+    /id_ed25519$/,
+    /\.p12$/,
+    /\.pfx$/,
+    // Cloud provider files
+    /\.aws\/credentials$/,
+    /gcloud.*\.json$/,
+    /service[-_]?account.*\.json$/,
+    // Token files
+    /\.npmrc$/,
+    /\.pypirc$/,
+    /\.netrc$/,
+];
+/**
+ * Large file threshold (1MB)
+ */
+const LARGE_FILE_THRESHOLD = 1024 * 1024;
+/**
+ * Git commit tool
+ */
+export const gitCommitTool = defineTool({
+    name: 'git_commit',
+    description: 'Create a git commit. Includes safety checks for secrets and large files. ' +
+        'Can optionally stage files before committing. ' +
+        'Use with caution: amend and noVerify options can be dangerous.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory path (default: current directory)',
+            },
+            message: {
+                type: 'string',
+                description: 'Commit message (required)',
+            },
+            files: {
+                type: 'array',
+                items: { type: 'string' },
+                description: 'Specific files to stage before commit',
+            },
+            addModified: {
+                type: 'boolean',
+                description: 'Stage all modified/deleted tracked files (git add -u)',
+            },
+            addAll: {
+                type: 'boolean',
+                description: 'Stage all files including untracked (git add -A)',
+            },
+            allowEmpty: {
+                type: 'boolean',
+                description: 'Allow creating an empty commit',
+            },
+            amend: {
+                type: 'boolean',
+                description: 'Amend the previous commit (dangerous!)',
+            },
+            noVerify: {
+                type: 'boolean',
+                description: 'Skip pre-commit hooks (dangerous!)',
+            },
+        },
+        required: ['message'],
+    },
+    execute: executeGitCommit,
+});
+/**
+ * Execute git commit
+ */
+async function executeGitCommit(input) {
+    const targetPath = input.path ?? process.cwd();
+    // Validate message
+    if (!input.message || input.message.trim().length === 0) {
+        return createErrorResult('Commit message is required');
+    }
+    // Check if path exists
+    if (!(await isDirectory(targetPath))) {
+        return createErrorResult(`Directory not found: ${targetPath}`);
+    }
+    // Check if it's a git repository
+    if (!(await isGitRepository(targetPath))) {
+        return createErrorResult(`Not a git repository: ${targetPath}`);
+    }
+    try {
+        // Stage files if requested
+        if (input.files && input.files.length > 0) {
+            const addResult = await runGitCommand(['add', '--', ...input.files], { cwd: targetPath });
+            if (!addResult.success) {
+                return createErrorResult(`Failed to stage files: ${addResult.stderr}`);
+            }
+        }
+        else if (input.addAll) {
+            const addResult = await runGitCommand(['add', '-A'], { cwd: targetPath });
+            if (!addResult.success) {
+                return createErrorResult(`Failed to stage files: ${addResult.stderr}`);
+            }
+        }
+        else if (input.addModified) {
+            const addResult = await runGitCommand(['add', '-u'], { cwd: targetPath });
+            if (!addResult.success) {
+                return createErrorResult(`Failed to stage files: ${addResult.stderr}`);
+            }
+        }
+        // Check what's staged
+        const stagedResult = await runGitCommand(['diff', '--cached', '--name-only'], {
+            cwd: targetPath,
+        });
+        const stagedFiles = stagedResult.stdout.split('\n').filter(Boolean);
+        // Safety checks
+        const warnings = await checkStagedFiles(targetPath, stagedFiles);
+        if (warnings.length > 0) {
+            const secretWarnings = warnings.filter((w) => w.type === 'secrets');
+            if (secretWarnings.length > 0) {
+                return createErrorResult(`Refusing to commit potential secrets:\n${secretWarnings.map((w) => `  - ${w.file}: ${w.message}`).join('\n')}\n\nUnstage these files or add them to .gitignore.`);
+            }
+            // Log other warnings but don't block
+            const otherWarnings = warnings.filter((w) => w.type !== 'secrets');
+            if (otherWarnings.length > 0) {
+                // These are warnings, not errors - we'll include them in success result
+            }
+        }
+        // Check if there's anything to commit
+        if (stagedFiles.length === 0 && !input.allowEmpty) {
+            return createErrorResult('Nothing to commit. Stage files first or use addAll/addModified options.');
+        }
+        // Build commit command
+        const commitArgs = ['commit', '-m', input.message];
+        if (input.allowEmpty) {
+            commitArgs.push('--allow-empty');
+        }
+        if (input.amend) {
+            commitArgs.push('--amend');
+        }
+        if (input.noVerify) {
+            commitArgs.push('--no-verify');
+        }
+        // Execute commit
+        const commitResult = await runGitCommand(commitArgs, { cwd: targetPath });
+        if (!commitResult.success) {
+            return createErrorResult(`Commit failed: ${commitResult.stderr}`);
+        }
+        // Get commit info
+        const hashResult = await runGitCommand(['rev-parse', 'HEAD'], { cwd: targetPath });
+        const shortHashResult = await runGitCommand(['rev-parse', '--short', 'HEAD'], {
+            cwd: targetPath,
+        });
+        const branchResult = await runGitCommand(['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: targetPath,
+        });
+        // Parse stats from commit output
+        const statsMatch = commitResult.stdout.match(/(\d+) files? changed(?:, (\d+) insertions?\(\+\))?(?:, (\d+) deletions?\(-\))?/);
+        const filesCommitted = statsMatch ? parseInt(statsMatch[1], 10) : stagedFiles.length;
+        const insertions = statsMatch && statsMatch[2] ? parseInt(statsMatch[2], 10) : 0;
+        const deletions = statsMatch && statsMatch[3] ? parseInt(statsMatch[3], 10) : 0;
+        const result = {
+            hash: hashResult.stdout,
+            shortHash: shortHashResult.stdout,
+            branch: branchResult.stdout,
+            filesCommitted,
+            insertions,
+            deletions,
+            message: input.message,
+        };
+        return createSuccessResult(result);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Check staged files for potential issues
+ */
+async function checkStagedFiles(repoPath, files) {
+    const warnings = [];
+    for (const file of files) {
+        // Check for secret patterns
+        for (const pattern of SECRET_PATTERNS) {
+            if (pattern.test(file)) {
+                warnings.push({
+                    type: 'secrets',
+                    file,
+                    message: `File matches secret pattern: ${pattern.toString()}`,
+                });
+                break;
+            }
+        }
+        // Check file size (only for files, not deletions)
+        const sizeResult = await runGitCommand(['cat-file', '-s', `:${file}`], { cwd: repoPath });
+        if (sizeResult.success) {
+            const size = parseInt(sizeResult.stdout, 10);
+            if (size > LARGE_FILE_THRESHOLD) {
+                warnings.push({
+                    type: 'large_file',
+                    file,
+                    message: `File is ${String(Math.round(size / 1024))}KB (threshold: ${String(Math.round(LARGE_FILE_THRESHOLD / 1024))}KB)`,
+                });
+            }
+        }
+    }
+    return warnings;
+}
+/**
+ * Factory function to create git commit tool with custom options
+ */
+export function createGitCommitTool(options) {
+    return defineTool({
+        name: 'git_commit',
+        description: 'Create a git commit. Includes safety checks for secrets and large files.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory path (default: current directory)',
+                },
+                message: {
+                    type: 'string',
+                    description: 'Commit message (required)',
+                },
+                files: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific files to stage before commit',
+                },
+                addModified: {
+                    type: 'boolean',
+                    description: 'Stage all modified/deleted tracked files',
+                },
+                addAll: {
+                    type: 'boolean',
+                    description: 'Stage all files including untracked',
+                },
+                allowEmpty: {
+                    type: 'boolean',
+                    description: 'Allow creating an empty commit',
+                },
+                amend: {
+                    type: 'boolean',
+                    description: 'Amend the previous commit',
+                },
+                noVerify: {
+                    type: 'boolean',
+                    description: 'Skip pre-commit hooks',
+                },
+            },
+            required: ['message'],
+        },
+        execute: async (input) => {
+            let targetPath = input.path ?? '.';
+            // Resolve relative paths
+            if (options?.baseDir && !targetPath.startsWith('/')) {
+                const nodePath = await import('node:path');
+                targetPath = nodePath.join(options.baseDir, targetPath);
+            }
+            return executeGitCommit({ ...input, path: targetPath });
+        },
+    });
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Git Diff Tool
+ * Shows changes between commits, working tree, etc.
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { GitDiffInput } from './types.js';
+/**
+ * Git diff tool
+ */
+export declare const gitDiffTool: Tool<GitDiffInput>;
+/**
+ * Factory function to create git diff tool with custom options
+ */
+export declare function createGitDiffTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Default context lines */
+    defaultContext?: number;
+}): Tool<GitDiffInput>;