@compilr-dev/agents-coding 0.0.1

package/dist/tools/git/stash.js

@@ -0,0 +1,294 @@
+/**
+ * Git Stash Tool
+ * Stash and restore changes
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { runGitCommand, isGitRepository, isDirectory } from './utils.js';
+/**
+ * Git stash tool
+ */
+export const gitStashTool = defineTool({
+    name: 'git_stash',
+    description: 'Manage git stashes. Actions: push (save changes), pop (apply and remove), ' +
+        'apply (apply without removing), list (show all stashes), drop (remove stash), ' +
+        'clear (remove all stashes), show (display stash contents).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory path (default: current directory)',
+            },
+            action: {
+                type: 'string',
+                enum: ['push', 'pop', 'apply', 'list', 'drop', 'clear', 'show'],
+                description: 'Action to perform',
+            },
+            message: {
+                type: 'string',
+                description: 'Stash message (for push action)',
+            },
+            includeUntracked: {
+                type: 'boolean',
+                description: 'Include untracked files (for push action)',
+            },
+            index: {
+                type: 'number',
+                description: 'Stash index (for pop/apply/drop/show, default: 0)',
+            },
+        },
+        required: ['action'],
+    },
+    execute: executeGitStash,
+});
+/**
+ * Execute git stash
+ */
+async function executeGitStash(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 'push':
+                return await stashPush(targetPath, input.message, input.includeUntracked ?? false);
+            case 'pop':
+                return await stashPop(targetPath, input.index ?? 0);
+            case 'apply':
+                return await stashApply(targetPath, input.index ?? 0);
+            case 'list':
+                return await stashList(targetPath);
+            case 'drop':
+                return await stashDrop(targetPath, input.index ?? 0);
+            case 'clear':
+                return await stashClear(targetPath);
+            case 'show':
+                return await stashShow(targetPath, input.index ?? 0);
+            default:
+                return createErrorResult(`Unknown action: ${String(input.action)}`);
+        }
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Push changes to stash
+ */
+async function stashPush(repoPath, message, includeUntracked = false) {
+    const args = ['stash', 'push'];
+    if (message) {
+        args.push('-m', message);
+    }
+    if (includeUntracked) {
+        args.push('-u');
+    }
+    const result = await runGitCommand(args, { cwd: repoPath });
+    if (!result.success) {
+        return createErrorResult(`Failed to stash changes: ${result.stderr}`);
+    }
+    // Check if anything was stashed
+    if (result.stdout.includes('No local changes to save')) {
+        return createErrorResult('No local changes to stash');
+    }
+    const stashResult = {
+        message: message ? `Stashed changes: ${message}` : 'Stashed changes',
+    };
+    return createSuccessResult(stashResult);
+}
+/**
+ * Pop stash (apply and remove)
+ */
+async function stashPop(repoPath, index) {
+    const stashRef = `stash@{${String(index)}}`;
+    const result = await runGitCommand(['stash', 'pop', stashRef], { cwd: repoPath });
+    if (!result.success) {
+        if (result.stderr.includes('No stash entries found')) {
+            return createErrorResult('No stash entries found');
+        }
+        if (result.stderr.includes('does not exist')) {
+            return createErrorResult(`Stash ${stashRef} does not exist`);
+        }
+        return createErrorResult(`Failed to pop stash: ${result.stderr}`);
+    }
+    const stashResult = {
+        message: `Applied and removed ${stashRef}`,
+    };
+    return createSuccessResult(stashResult);
+}
+/**
+ * Apply stash without removing
+ */
+async function stashApply(repoPath, index) {
+    const stashRef = `stash@{${String(index)}}`;
+    const result = await runGitCommand(['stash', 'apply', stashRef], { cwd: repoPath });
+    if (!result.success) {
+        if (result.stderr.includes('No stash entries found')) {
+            return createErrorResult('No stash entries found');
+        }
+        if (result.stderr.includes('does not exist')) {
+            return createErrorResult(`Stash ${stashRef} does not exist`);
+        }
+        return createErrorResult(`Failed to apply stash: ${result.stderr}`);
+    }
+    const stashResult = {
+        message: `Applied ${stashRef} (stash still exists)`,
+    };
+    return createSuccessResult(stashResult);
+}
+/**
+ * List all stashes
+ */
+async function stashList(repoPath) {
+    const result = await runGitCommand(['stash', 'list'], { cwd: repoPath });
+    if (!result.success) {
+        return createErrorResult(`Failed to list stashes: ${result.stderr}`);
+    }
+    const stashes = [];
+    if (result.stdout) {
+        // Parse stash list output
+        // Format: stash@{0}: On branch: message
+        const lines = result.stdout.split('\n').filter(Boolean);
+        for (const line of lines) {
+            const match = line.match(/^(stash@\{(\d+)\}): (?:On|WIP on) ([^:]+): (.+)$/);
+            if (match) {
+                stashes.push({
+                    ref: match[1],
+                    index: parseInt(match[2], 10),
+                    branch: match[3],
+                    message: match[4],
+                });
+            }
+            else {
+                // Fallback for different formats
+                const simpleMatch = line.match(/^(stash@\{(\d+)\}): (.+)$/);
+                if (simpleMatch) {
+                    stashes.push({
+                        ref: simpleMatch[1],
+                        index: parseInt(simpleMatch[2], 10),
+                        branch: 'unknown',
+                        message: simpleMatch[3],
+                    });
+                }
+            }
+        }
+    }
+    const stashResult = {
+        stashes,
+        message: `Found ${String(stashes.length)} stash(es)`,
+    };
+    return createSuccessResult(stashResult);
+}
+/**
+ * Drop a stash
+ */
+async function stashDrop(repoPath, index) {
+    const stashRef = `stash@{${String(index)}}`;
+    const result = await runGitCommand(['stash', 'drop', stashRef], { cwd: repoPath });
+    if (!result.success) {
+        if (result.stderr.includes('No stash entries found')) {
+            return createErrorResult('No stash entries found');
+        }
+        if (result.stderr.includes('does not exist')) {
+            return createErrorResult(`Stash ${stashRef} does not exist`);
+        }
+        return createErrorResult(`Failed to drop stash: ${result.stderr}`);
+    }
+    const stashResult = {
+        message: `Dropped ${stashRef}`,
+    };
+    return createSuccessResult(stashResult);
+}
+/**
+ * Clear all stashes
+ */
+async function stashClear(repoPath) {
+    // First check if there are any stashes
+    const listResult = await runGitCommand(['stash', 'list'], { cwd: repoPath });
+    if (!listResult.stdout) {
+        return createErrorResult('No stash entries to clear');
+    }
+    const result = await runGitCommand(['stash', 'clear'], { cwd: repoPath });
+    if (!result.success) {
+        return createErrorResult(`Failed to clear stashes: ${result.stderr}`);
+    }
+    const stashResult = {
+        message: 'Cleared all stashes',
+    };
+    return createSuccessResult(stashResult);
+}
+/**
+ * Show stash contents
+ */
+async function stashShow(repoPath, index) {
+    const stashRef = `stash@{${String(index)}}`;
+    // Get stat summary
+    const statResult = await runGitCommand(['stash', 'show', stashRef], { cwd: repoPath });
+    if (!statResult.success) {
+        if (statResult.stderr.includes('No stash entries found')) {
+            return createErrorResult('No stash entries found');
+        }
+        if (statResult.stderr.includes('does not exist')) {
+            return createErrorResult(`Stash ${stashRef} does not exist`);
+        }
+        return createErrorResult(`Failed to show stash: ${statResult.stderr}`);
+    }
+    // Get diff
+    const diffResult = await runGitCommand(['stash', 'show', '-p', stashRef], { cwd: repoPath });
+    const stashResult = {
+        diff: diffResult.success ? diffResult.stdout : undefined,
+        message: statResult.stdout,
+    };
+    return createSuccessResult(stashResult);
+}
+/**
+ * Factory function to create git stash tool with custom options
+ */
+export function createGitStashTool(options) {
+    return defineTool({
+        name: 'git_stash',
+        description: 'Manage git stashes. Actions: push, pop, apply, list, drop, clear, show.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory path (default: current directory)',
+                },
+                action: {
+                    type: 'string',
+                    enum: ['push', 'pop', 'apply', 'list', 'drop', 'clear', 'show'],
+                    description: 'Action to perform',
+                },
+                message: {
+                    type: 'string',
+                    description: 'Stash message (for push)',
+                },
+                includeUntracked: {
+                    type: 'boolean',
+                    description: 'Include untracked files (for push)',
+                },
+                index: {
+                    type: 'number',
+                    description: 'Stash index (default: 0)',
+                },
+            },
+            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 executeGitStash({ ...input, path: targetPath });
+        },
+    });
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Git Status Tool
+ * Shows the working tree status with structured output
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { GitStatusInput } from './types.js';
+/**
+ * Git status tool
+ */
+export declare const gitStatusTool: Tool<GitStatusInput>;
+/**
+ * Factory function to create git status tool with custom options
+ */
+export declare function createGitStatusTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Default include untracked setting */
+    defaultIncludeUntracked?: boolean;
+}): Tool<GitStatusInput>;

package/dist/tools/git/status.js

@@ -0,0 +1,160 @@
+/**
+ * Git Status Tool
+ * Shows the working tree status with structured output
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { runGitCommand, isGitRepository, isDirectory, parsePorcelainStatus, parseBranchInfo, xyToStatusType, } from './utils.js';
+/**
+ * Git status tool
+ */
+export const gitStatusTool = defineTool({
+    name: 'git_status',
+    description: 'Get the current git working tree status. ' +
+        'Returns branch name, tracking info, staged changes, unstaged changes, and untracked files. ' +
+        'Use to understand what changes exist before committing.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory path (default: current directory)',
+            },
+            includeUntracked: {
+                type: 'boolean',
+                description: 'Include untracked files (default: true)',
+            },
+            short: {
+                type: 'boolean',
+                description: 'Return short format status string as well (default: false)',
+            },
+        },
+        required: [],
+    },
+    execute: executeGitStatus,
+});
+/**
+ * Execute git status
+ */
+async function executeGitStatus(input) {
+    const targetPath = input.path ?? process.cwd();
+    const includeUntracked = input.includeUntracked ?? true;
+    const short = input.short ?? false;
+    // 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 {
+        // Run git status with porcelain v2 format for structured output
+        const args = ['status', '--porcelain=v2', '--branch'];
+        if (includeUntracked) {
+            args.push('-uall');
+        }
+        else {
+            args.push('-uno');
+        }
+        const result = await runGitCommand(args, { cwd: targetPath });
+        if (!result.success) {
+            return createErrorResult(`git status failed: ${result.stderr}`);
+        }
+        // Parse branch info
+        const branchInfo = parseBranchInfo(result.stdout);
+        // Parse file entries
+        const entries = parsePorcelainStatus(result.stdout);
+        // Categorize entries
+        const staged = [];
+        const modified = [];
+        const untracked = [];
+        for (const entry of entries) {
+            if (entry.type === 'untracked') {
+                untracked.push(entry.path);
+            }
+            else if (entry.staged && entry.xy[0] !== '.') {
+                // Staged changes (first char of XY)
+                staged.push({
+                    path: entry.path,
+                    status: xyToStatusType(entry.xy, true),
+                    oldPath: entry.oldPath,
+                });
+            }
+            // Unstaged changes (second char of XY)
+            if (entry.xy[1] !== '.' && entry.xy[1] !== '?') {
+                modified.push({
+                    path: entry.path,
+                    status: xyToStatusType(entry.xy, false),
+                });
+            }
+        }
+        // Get short status if requested
+        let shortStatus;
+        if (short) {
+            const shortResult = await runGitCommand(['status', '-sb'], { cwd: targetPath });
+            if (shortResult.success) {
+                shortStatus = shortResult.stdout;
+            }
+        }
+        const statusResult = {
+            branch: branchInfo.branch,
+            tracking: branchInfo.upstream
+                ? {
+                    remote: branchInfo.upstream,
+                    ahead: branchInfo.ahead,
+                    behind: branchInfo.behind,
+                }
+                : undefined,
+            staged,
+            modified,
+            untracked,
+            isClean: staged.length === 0 && modified.length === 0 && untracked.length === 0,
+            shortStatus,
+        };
+        return createSuccessResult(statusResult);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Factory function to create git status tool with custom options
+ */
+export function createGitStatusTool(options) {
+    return defineTool({
+        name: 'git_status',
+        description: 'Get the current git working tree status. ' +
+            'Returns branch name, tracking info, staged changes, unstaged changes, and untracked files.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory path (default: current directory)',
+                },
+                includeUntracked: {
+                    type: 'boolean',
+                    description: `Include untracked files (default: ${String(options?.defaultIncludeUntracked ?? true)})`,
+                },
+                short: {
+                    type: 'boolean',
+                    description: 'Return short format status string as well (default: false)',
+                },
+            },
+            required: [],
+        },
+        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 executeGitStatus({
+                ...input,
+                path: targetPath,
+                includeUntracked: input.includeUntracked ?? options?.defaultIncludeUntracked ?? true,
+            });
+        },
+    });
+}