@compilr-dev/agents-coding 0.0.1

package/dist/tools/git/diff.js

@@ -0,0 +1,221 @@
+/**
+ * Git Diff Tool
+ * Shows changes between commits, working tree, etc.
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { runGitCommand, isGitRepository, isDirectory } from './utils.js';
+/**
+ * Git diff tool
+ */
+export const gitDiffTool = defineTool({
+    name: 'git_diff',
+    description: 'Show changes between commits, commit and working tree, etc. ' +
+        'By default shows unstaged changes. Use staged=true for staged changes. ' +
+        'Can compare specific files or refs.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory path (default: current directory)',
+            },
+            staged: {
+                type: 'boolean',
+                description: 'Show staged changes instead of unstaged (default: false)',
+            },
+            file: {
+                type: 'string',
+                description: 'Specific file to diff',
+            },
+            ref: {
+                type: 'string',
+                description: 'Compare working tree with this commit/branch',
+            },
+            refA: {
+                type: 'string',
+                description: 'First ref for comparison (use with refB)',
+            },
+            refB: {
+                type: 'string',
+                description: 'Second ref for comparison (use with refA)',
+            },
+            context: {
+                type: 'number',
+                description: 'Number of context lines (default: 3)',
+            },
+            statOnly: {
+                type: 'boolean',
+                description: 'Show only statistics, no diff content (default: false)',
+            },
+            nameOnly: {
+                type: 'boolean',
+                description: 'Show only names of changed files (default: false)',
+            },
+        },
+        required: [],
+    },
+    execute: executeGitDiff,
+});
+/**
+ * Execute git diff
+ */
+async function executeGitDiff(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 {
+        // Build git diff command
+        const args = ['diff'];
+        // Context lines
+        if (input.context !== undefined) {
+            args.push(`-U${String(input.context)}`);
+        }
+        // Staged changes
+        if (input.staged) {
+            args.push('--cached');
+        }
+        // Ref comparison
+        if (input.refA && input.refB) {
+            args.push(input.refA, input.refB);
+        }
+        else if (input.ref) {
+            args.push(input.ref);
+        }
+        // Stat only or name only
+        if (input.statOnly) {
+            args.push('--stat');
+        }
+        else if (input.nameOnly) {
+            args.push('--name-only');
+        }
+        // Specific file
+        if (input.file) {
+            args.push('--', input.file);
+        }
+        // Run the diff
+        const result = await runGitCommand(args, { cwd: targetPath });
+        if (!result.success && result.exitCode !== 0 && result.stdout === '') {
+            // git diff returns exit code 1 if there are changes, 0 if no changes
+            // But if stderr has content, it's an error
+            if (result.stderr) {
+                return createErrorResult(`git diff failed: ${result.stderr}`);
+            }
+        }
+        // Get stats separately for structured output
+        const statsArgs = ['diff', '--numstat'];
+        if (input.staged)
+            statsArgs.push('--cached');
+        if (input.refA && input.refB) {
+            statsArgs.push(input.refA, input.refB);
+        }
+        else if (input.ref) {
+            statsArgs.push(input.ref);
+        }
+        if (input.file)
+            statsArgs.push('--', input.file);
+        const statsResult = await runGitCommand(statsArgs, { cwd: targetPath });
+        // Parse stats
+        const files = [];
+        let totalInsertions = 0;
+        let totalDeletions = 0;
+        if (statsResult.success && statsResult.stdout) {
+            const lines = statsResult.stdout.split('\n').filter(Boolean);
+            for (const line of lines) {
+                // Format: <additions>\t<deletions>\t<path>
+                const match = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+                if (match) {
+                    const additions = match[1] === '-' ? 0 : parseInt(match[1], 10);
+                    const deletions = match[2] === '-' ? 0 : parseInt(match[2], 10);
+                    const path = match[3];
+                    files.push({ path, additions, deletions });
+                    totalInsertions += additions;
+                    totalDeletions += deletions;
+                }
+            }
+        }
+        const diffResult = {
+            diff: input.statOnly || input.nameOnly ? '' : result.stdout,
+            files,
+            stats: {
+                filesChanged: files.length,
+                insertions: totalInsertions,
+                deletions: totalDeletions,
+            },
+        };
+        return createSuccessResult(diffResult);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Factory function to create git diff tool with custom options
+ */
+export function createGitDiffTool(options) {
+    return defineTool({
+        name: 'git_diff',
+        description: 'Show changes between commits, commit and working tree, etc. ' +
+            'By default shows unstaged changes. Use staged=true for staged changes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory path (default: current directory)',
+                },
+                staged: {
+                    type: 'boolean',
+                    description: 'Show staged changes instead of unstaged (default: false)',
+                },
+                file: {
+                    type: 'string',
+                    description: 'Specific file to diff',
+                },
+                ref: {
+                    type: 'string',
+                    description: 'Compare working tree with this commit/branch',
+                },
+                refA: {
+                    type: 'string',
+                    description: 'First ref for comparison (use with refB)',
+                },
+                refB: {
+                    type: 'string',
+                    description: 'Second ref for comparison (use with refA)',
+                },
+                context: {
+                    type: 'number',
+                    description: `Number of context lines (default: ${String(options?.defaultContext ?? 3)})`,
+                },
+                statOnly: {
+                    type: 'boolean',
+                    description: 'Show only statistics, no diff content (default: false)',
+                },
+                nameOnly: {
+                    type: 'boolean',
+                    description: 'Show only names of changed files (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 executeGitDiff({
+                ...input,
+                path: targetPath,
+                context: input.context ?? options?.defaultContext,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Git tools
+ */
+export { gitStatusTool, createGitStatusTool } from './status.js';
+export { gitDiffTool, createGitDiffTool } from './diff.js';
+export { gitLogTool, createGitLogTool } from './log.js';
+export { gitCommitTool, createGitCommitTool } from './commit.js';
+export { gitBranchTool, createGitBranchTool } from './branch.js';
+export { gitStashTool, createGitStashTool } from './stash.js';
+export type { GitStatusInput, GitStatusResult, GitFileStatus, GitFileStatusType, GitDiffInput, GitDiffResult, DiffFileStats, GitLogInput, GitLogResult, GitCommit, GitCommitInput, GitCommitResult, CommitSafetyWarning, GitBranchAction, GitBranchInput, GitBranchInfo, GitBranchResult, GitStashAction, GitStashInput, GitStashEntry, GitStashResult, } from './types.js';

package/dist/tools/git/index.js

@@ -0,0 +1,11 @@
+/**
+ * Git tools
+ */
+// Phase 1: Read-only git tools
+export { gitStatusTool, createGitStatusTool } from './status.js';
+export { gitDiffTool, createGitDiffTool } from './diff.js';
+export { gitLogTool, createGitLogTool } from './log.js';
+// Phase 2: Core git tools
+export { gitCommitTool, createGitCommitTool } from './commit.js';
+export { gitBranchTool, createGitBranchTool } from './branch.js';
+export { gitStashTool, createGitStashTool } from './stash.js';

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

@@ -0,0 +1,19 @@
+/**
+ * Git Log Tool
+ * Shows commit history with various filtering options
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { GitLogInput } from './types.js';
+/**
+ * Git log tool
+ */
+export declare const gitLogTool: Tool<GitLogInput>;
+/**
+ * Factory function to create git log tool with custom options
+ */
+export declare function createGitLogTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+    /** Default limit */
+    defaultLimit?: number;
+}): Tool<GitLogInput>;

package/dist/tools/git/log.js

@@ -0,0 +1,235 @@
+/**
+ * Git Log Tool
+ * Shows commit history with various filtering options
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { runGitCommand, isGitRepository, isDirectory } from './utils.js';
+/**
+ * Git log tool
+ */
+export const gitLogTool = defineTool({
+    name: 'git_log',
+    description: 'Show commit history. ' +
+        'Returns structured commit data including hash, author, date, and message. ' +
+        'Supports filtering by author, date range, file path, and message content.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Working directory path (default: current directory)',
+            },
+            limit: {
+                type: 'number',
+                description: 'Number of commits to return (default: 10)',
+            },
+            file: {
+                type: 'string',
+                description: 'Filter commits by file path',
+            },
+            author: {
+                type: 'string',
+                description: 'Filter by author name or email',
+            },
+            since: {
+                type: 'string',
+                description: 'Show commits since date (ISO format or relative like "2 weeks ago")',
+            },
+            until: {
+                type: 'string',
+                description: 'Show commits until date (ISO format or relative)',
+            },
+            oneline: {
+                type: 'boolean',
+                description: 'One-line format (hash + message only, no author/date)',
+            },
+            stat: {
+                type: 'boolean',
+                description: 'Include diff statistics for each commit',
+            },
+            grep: {
+                type: 'string',
+                description: 'Filter by pattern in commit message',
+            },
+            ref: {
+                type: 'string',
+                description: 'Branch or ref to show log for (default: HEAD)',
+            },
+        },
+        required: [],
+    },
+    execute: executeGitLog,
+});
+/**
+ * Execute git log
+ */
+async function executeGitLog(input) {
+    const targetPath = input.path ?? process.cwd();
+    const limit = input.limit ?? 10;
+    // 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 {
+        // Use a custom format for structured parsing
+        // Format: hash%x00shortHash%x00author%x00email%x00date%x00subject%x00body%x00%x01
+        const format = '%H%x00%h%x00%an%x00%ae%x00%aI%x00%s%x00%b%x00%x01';
+        const args = ['log', `--format=${format}`, `-n${String(limit)}`];
+        // Ref/branch
+        if (input.ref) {
+            args.push(input.ref);
+        }
+        // Filters
+        if (input.author) {
+            args.push(`--author=${input.author}`);
+        }
+        if (input.since) {
+            args.push(`--since=${input.since}`);
+        }
+        if (input.until) {
+            args.push(`--until=${input.until}`);
+        }
+        if (input.grep) {
+            args.push(`--grep=${input.grep}`);
+        }
+        // File filter (must be after --)
+        if (input.file) {
+            args.push('--', input.file);
+        }
+        const result = await runGitCommand(args, { cwd: targetPath });
+        if (!result.success) {
+            return createErrorResult(`git log failed: ${result.stderr}`);
+        }
+        // Parse commits
+        const commits = [];
+        if (result.stdout) {
+            // Split by the separator we used (0x01)
+            const entries = result.stdout.split('\x01').filter((e) => e.trim());
+            for (const entry of entries) {
+                const parts = entry.trim().split('\x00');
+                if (parts.length >= 6) {
+                    const commit = {
+                        hash: parts[0],
+                        shortHash: parts[1],
+                        author: parts[2],
+                        email: parts[3],
+                        date: parts[4],
+                        message: parts[5],
+                        body: parts[6]?.trim() || undefined,
+                    };
+                    commits.push(commit);
+                }
+            }
+        }
+        // Get stat info if requested
+        if (input.stat && commits.length > 0) {
+            const statArgs = ['log', '--stat', '--format=%H%x00', `-n${String(limit)}`];
+            if (input.ref)
+                statArgs.push(input.ref);
+            if (input.author)
+                statArgs.push(`--author=${input.author}`);
+            if (input.since)
+                statArgs.push(`--since=${input.since}`);
+            if (input.until)
+                statArgs.push(`--until=${input.until}`);
+            if (input.file)
+                statArgs.push('--', input.file);
+            const statResult = await runGitCommand(statArgs, { cwd: targetPath });
+            if (statResult.success && statResult.stdout) {
+                // Parse stat output and attach to commits
+                const statEntries = statResult.stdout.split('\x00').filter(Boolean);
+                for (let i = 0; i < statEntries.length && i < commits.length; i++) {
+                    // Each entry is hash followed by stat lines
+                    const lines = statEntries[i].trim().split('\n');
+                    const hash = lines[0].trim();
+                    const statLines = lines.slice(1).filter(Boolean);
+                    // Find matching commit
+                    const commit = commits.find((c) => c.hash === hash);
+                    if (commit && statLines.length > 0) {
+                        commit.stat = statLines.join('\n');
+                    }
+                }
+            }
+        }
+        const logResult = {
+            commits,
+        };
+        return createSuccessResult(logResult);
+    }
+    catch (error) {
+        return createErrorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * Factory function to create git log tool with custom options
+ */
+export function createGitLogTool(options) {
+    return defineTool({
+        name: 'git_log',
+        description: 'Show commit history. ' +
+            'Returns structured commit data including hash, author, date, and message.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Working directory path (default: current directory)',
+                },
+                limit: {
+                    type: 'number',
+                    description: `Number of commits to return (default: ${String(options?.defaultLimit ?? 10)})`,
+                },
+                file: {
+                    type: 'string',
+                    description: 'Filter commits by file path',
+                },
+                author: {
+                    type: 'string',
+                    description: 'Filter by author name or email',
+                },
+                since: {
+                    type: 'string',
+                    description: 'Show commits since date (ISO format or relative)',
+                },
+                until: {
+                    type: 'string',
+                    description: 'Show commits until date (ISO format or relative)',
+                },
+                oneline: {
+                    type: 'boolean',
+                    description: 'One-line format (hash + message only)',
+                },
+                stat: {
+                    type: 'boolean',
+                    description: 'Include diff statistics for each commit',
+                },
+                grep: {
+                    type: 'string',
+                    description: 'Filter by pattern in commit message',
+                },
+                ref: {
+                    type: 'string',
+                    description: 'Branch or ref to show log for',
+                },
+            },
+            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 executeGitLog({
+                ...input,
+                path: targetPath,
+                limit: input.limit ?? options?.defaultLimit ?? 10,
+            });
+        },
+    });
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Git Stash Tool
+ * Stash and restore changes
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { GitStashInput } from './types.js';
+/**
+ * Git stash tool
+ */
+export declare const gitStashTool: Tool<GitStashInput>;
+/**
+ * Factory function to create git stash tool with custom options
+ */
+export declare function createGitStashTool(options?: {
+    /** Base directory for relative paths */
+    baseDir?: string;
+}): Tool<GitStashInput>;