codeep 1.0.0

package/dist/utils/git.js

@@ -0,0 +1,399 @@
+import { execSync, spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+/**
+ * Check if current directory is a git repository
+ */
+export function isGitRepository(cwd = process.cwd()) {
+    try {
+        const gitDir = join(cwd, '.git');
+        if (existsSync(gitDir))
+            return true;
+        // Check if we're inside a git repo (not necessarily at root)
+        execSync('git rev-parse --git-dir', { cwd, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get current git status
+ */
+export function getGitStatus(cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return { isRepo: false };
+    }
+    try {
+        // Get current branch
+        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd,
+            encoding: 'utf-8'
+        }).trim();
+        // Check for changes
+        const status = execSync('git status --porcelain', {
+            cwd,
+            encoding: 'utf-8'
+        });
+        const hasChanges = status.trim().length > 0;
+        // Check ahead/behind
+        let ahead = 0;
+        let behind = 0;
+        try {
+            const counts = execSync('git rev-list --left-right --count @{u}...HEAD', {
+                cwd,
+                encoding: 'utf-8'
+            }).trim();
+            const [behindStr, aheadStr] = counts.split('\t');
+            behind = parseInt(behindStr) || 0;
+            ahead = parseInt(aheadStr) || 0;
+        }
+        catch {
+            // No upstream branch
+        }
+        return {
+            isRepo: true,
+            branch,
+            hasChanges,
+            ahead,
+            behind,
+        };
+    }
+    catch (error) {
+        return {
+            isRepo: true,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Get git diff (staged or unstaged)
+ */
+export function getGitDiff(staged = false, cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return {
+            success: false,
+            diff: '',
+            error: 'Not a git repository',
+        };
+    }
+    try {
+        const command = staged ? 'git diff --cached' : 'git diff';
+        const diff = execSync(command, {
+            cwd,
+            encoding: 'utf-8',
+            maxBuffer: 10 * 1024 * 1024, // 10MB buffer for large diffs
+        });
+        if (!diff.trim()) {
+            return {
+                success: true,
+                diff: '',
+                error: staged ? 'No staged changes' : 'No unstaged changes',
+            };
+        }
+        return {
+            success: true,
+            diff: diff.trim(),
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            diff: '',
+            error: error instanceof Error ? error.message : 'Failed to get diff',
+        };
+    }
+}
+/**
+ * Get list of changed files
+ */
+export function getChangedFiles(cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return [];
+    }
+    try {
+        const output = execSync('git status --porcelain', {
+            cwd,
+            encoding: 'utf-8'
+        });
+        return output
+            .trim()
+            .split('\n')
+            .filter(line => line.trim())
+            .map(line => {
+            // Format: "XY filename" where XY are status codes
+            return line.substring(3).trim();
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Generate commit message suggestion based on diff
+ */
+export function suggestCommitMessage(diff) {
+    // Simple heuristics for commit message suggestions
+    const lines = diff.split('\n');
+    const additions = lines.filter(l => l.startsWith('+')).length;
+    const deletions = lines.filter(l => l.startsWith('-')).length;
+    // Look for common patterns
+    if (diff.includes('new file mode')) {
+        return 'feat: add new files';
+    }
+    if (diff.includes('deleted file mode')) {
+        return 'chore: remove files';
+    }
+    if (diff.includes('package.json') || diff.includes('package-lock.json')) {
+        return 'chore: update dependencies';
+    }
+    if (diff.includes('README') || diff.includes('.md')) {
+        return 'docs: update documentation';
+    }
+    if (diff.includes('test') || diff.includes('spec')) {
+        return 'test: update tests';
+    }
+    // Generic based on size
+    if (additions > deletions * 2) {
+        return 'feat: add functionality';
+    }
+    if (deletions > additions * 2) {
+        return 'refactor: remove code';
+    }
+    return 'chore: update code';
+}
+/**
+ * Create a commit with the given message
+ */
+export function createCommit(message, cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return {
+            success: false,
+            error: 'Not a git repository',
+        };
+    }
+    try {
+        // Check if there are staged changes
+        const staged = execSync('git diff --cached --name-only', {
+            cwd,
+            encoding: 'utf-8'
+        }).trim();
+        if (!staged) {
+            return {
+                success: false,
+                error: 'No staged changes to commit',
+            };
+        }
+        // Create commit using spawnSync to prevent command injection
+        const result = spawnSync('git', ['commit', '-m', message], {
+            cwd,
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        if (result.status !== 0) {
+            throw new Error(result.stderr || 'Commit failed');
+        }
+        // Get commit hash
+        const hash = execSync('git rev-parse --short HEAD', {
+            cwd,
+            encoding: 'utf-8'
+        }).trim();
+        return {
+            success: true,
+            hash,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Commit failed',
+        };
+    }
+}
+/**
+ * Stage all changes
+ */
+export function stageAll(cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return false;
+    }
+    try {
+        execSync('git add -A', { cwd, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Format git diff for display
+ */
+export function formatDiffForDisplay(diff, maxLines = 50) {
+    const lines = diff.split('\n');
+    if (lines.length <= maxLines) {
+        return diff;
+    }
+    const truncated = lines.slice(0, maxLines).join('\n');
+    const remaining = lines.length - maxLines;
+    return `${truncated}\n\n... (${remaining} more lines, showing first ${maxLines})`;
+}
+/**
+ * Create a new branch
+ */
+export function createBranch(branchName, cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return { success: false, error: 'Not a git repository' };
+    }
+    try {
+        // Check if branch already exists
+        const branches = execSync('git branch --list', { cwd, encoding: 'utf-8' });
+        if (branches.includes(branchName)) {
+            return { success: false, error: `Branch '${branchName}' already exists` };
+        }
+        execSync(`git checkout -b ${branchName}`, { cwd, stdio: 'ignore' });
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to create branch',
+        };
+    }
+}
+/**
+ * Switch to a branch
+ */
+export function switchBranch(branchName, cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return { success: false, error: 'Not a git repository' };
+    }
+    try {
+        execSync(`git checkout ${branchName}`, { cwd, stdio: 'ignore' });
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to switch branch',
+        };
+    }
+}
+/**
+ * Generate a commit message based on agent actions
+ */
+export function generateCommitMessage(prompt, actions) {
+    // Analyze actions to determine commit type
+    const hasWrites = actions.some(a => a.type === 'write');
+    const hasEdits = actions.some(a => a.type === 'edit');
+    const hasDeletes = actions.some(a => a.type === 'delete');
+    const hasCommands = actions.some(a => a.type === 'command');
+    // Determine prefix
+    let prefix = 'chore';
+    // Check prompt for common patterns
+    const promptLower = prompt.toLowerCase();
+    if (promptLower.includes('fix') || promptLower.includes('bug')) {
+        prefix = 'fix';
+    }
+    else if (promptLower.includes('add') || promptLower.includes('create') || promptLower.includes('implement')) {
+        prefix = 'feat';
+    }
+    else if (promptLower.includes('refactor') || promptLower.includes('clean')) {
+        prefix = 'refactor';
+    }
+    else if (promptLower.includes('test')) {
+        prefix = 'test';
+    }
+    else if (promptLower.includes('doc') || promptLower.includes('readme')) {
+        prefix = 'docs';
+    }
+    else if (hasWrites && !hasEdits) {
+        prefix = 'feat';
+    }
+    else if (hasDeletes && !hasWrites) {
+        prefix = 'refactor';
+    }
+    // Generate message body from prompt
+    let body = prompt
+        .replace(/^(please\s+)?/i, '')
+        .replace(/[.!?]+$/, '')
+        .trim();
+    // Truncate if too long
+    if (body.length > 50) {
+        body = body.substring(0, 47) + '...';
+    }
+    // Make first letter lowercase
+    body = body.charAt(0).toLowerCase() + body.slice(1);
+    return `${prefix}: ${body}`;
+}
+/**
+ * Auto-commit agent changes
+ */
+export function autoCommitAgentChanges(prompt, actions, cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return { success: false, error: 'Not a git repository' };
+    }
+    // Check if there are any file changes
+    const fileActions = actions.filter(a => a.type === 'write' || a.type === 'edit' || a.type === 'delete' || a.type === 'mkdir');
+    if (fileActions.length === 0) {
+        return { success: false, error: 'No file changes to commit' };
+    }
+    // Check for actual git changes
+    const status = getGitStatus(cwd);
+    if (!status.hasChanges) {
+        return { success: false, error: 'No changes detected by git' };
+    }
+    // Stage all changes
+    if (!stageAll(cwd)) {
+        return { success: false, error: 'Failed to stage changes' };
+    }
+    // Generate commit message
+    const message = generateCommitMessage(prompt, actions);
+    // Create commit
+    return createCommit(message, cwd);
+}
+/**
+ * Generate branch name from prompt
+ */
+export function generateBranchName(prompt) {
+    // Clean up prompt
+    let name = prompt
+        .toLowerCase()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .substring(0, 40);
+    // Add prefix
+    const prefix = 'agent';
+    const timestamp = Date.now().toString(36).slice(-4);
+    return `${prefix}/${name}-${timestamp}`;
+}
+/**
+ * Create branch and commit agent changes
+ */
+export function createBranchAndCommit(prompt, actions, cwd = process.cwd()) {
+    if (!isGitRepository(cwd)) {
+        return { success: false, error: 'Not a git repository' };
+    }
+    // Generate branch name
+    const branchName = generateBranchName(prompt);
+    // Create branch
+    const branchResult = createBranch(branchName, cwd);
+    if (!branchResult.success) {
+        return { success: false, error: branchResult.error };
+    }
+    // Commit changes
+    const commitResult = autoCommitAgentChanges(prompt, actions, cwd);
+    if (!commitResult.success) {
+        return {
+            success: false,
+            branch: branchName,
+            error: commitResult.error
+        };
+    }
+    return {
+        success: true,
+        branch: branchName,
+        hash: commitResult.hash,
+    };
+}

package/dist/utils/git.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/git.test.js

@@ -0,0 +1,193 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execSync } from 'child_process';
+import { mkdirSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { isGitRepository, getGitStatus, getGitDiff, getChangedFiles, suggestCommitMessage, createCommit, stageAll, formatDiffForDisplay, } from './git';
+// Create a temp directory for git tests
+const TEST_DIR = join(tmpdir(), 'codeep-git-test-' + Date.now());
+const NON_GIT_DIR = join(tmpdir(), 'codeep-non-git-test-' + Date.now());
+describe('git utilities', () => {
+    beforeEach(() => {
+        // Create test directories
+        mkdirSync(TEST_DIR, { recursive: true });
+        mkdirSync(NON_GIT_DIR, { recursive: true });
+        // Initialize git repo in TEST_DIR
+        execSync('git init', { cwd: TEST_DIR, stdio: 'ignore' });
+        execSync('git config user.email "test@test.com"', { cwd: TEST_DIR, stdio: 'ignore' });
+        execSync('git config user.name "Test User"', { cwd: TEST_DIR, stdio: 'ignore' });
+    });
+    afterEach(() => {
+        // Cleanup
+        try {
+            rmSync(TEST_DIR, { recursive: true, force: true });
+            rmSync(NON_GIT_DIR, { recursive: true, force: true });
+        }
+        catch { }
+    });
+    describe('isGitRepository', () => {
+        it('should return true for git repository', () => {
+            expect(isGitRepository(TEST_DIR)).toBe(true);
+        });
+        it('should return false for non-git directory', () => {
+            expect(isGitRepository(NON_GIT_DIR)).toBe(false);
+        });
+        it('should return false for non-existent directory', () => {
+            expect(isGitRepository('/non/existent/path')).toBe(false);
+        });
+    });
+    describe('getGitStatus', () => {
+        it('should return isRepo: false for non-git directory', () => {
+            const status = getGitStatus(NON_GIT_DIR);
+            expect(status.isRepo).toBe(false);
+        });
+        it('should return correct status for git repo', () => {
+            // Create initial commit so we have a branch
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
+            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
+            const status = getGitStatus(TEST_DIR);
+            expect(status.isRepo).toBe(true);
+            expect(status.branch).toBeDefined();
+            expect(status.hasChanges).toBe(false);
+        });
+        it('should detect changes', () => {
+            // Create initial commit
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
+            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
+            // Make a change
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello world');
+            const status = getGitStatus(TEST_DIR);
+            expect(status.hasChanges).toBe(true);
+        });
+    });
+    describe('getGitDiff', () => {
+        it('should return error for non-git directory', () => {
+            const result = getGitDiff(false, NON_GIT_DIR);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Not a git repository');
+        });
+        it('should return empty diff when no changes', () => {
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
+            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
+            const result = getGitDiff(false, TEST_DIR);
+            expect(result.success).toBe(true);
+            expect(result.diff).toBe('');
+        });
+        it('should return diff for unstaged changes', () => {
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
+            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello world');
+            const result = getGitDiff(false, TEST_DIR);
+            expect(result.success).toBe(true);
+            expect(result.diff).toContain('hello world');
+        });
+        it('should return diff for staged changes', () => {
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
+            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+            execSync('git commit -m "initial"', { cwd: TEST_DIR, stdio: 'ignore' });
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello world');
+            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+            const result = getGitDiff(true, TEST_DIR);
+            expect(result.success).toBe(true);
+            expect(result.diff).toContain('hello world');
+        });
+    });
+    describe('getChangedFiles', () => {
+        it('should return empty array for non-git directory', () => {
+            expect(getChangedFiles(NON_GIT_DIR)).toEqual([]);
+        });
+        it('should return changed files', () => {
+            writeFileSync(join(TEST_DIR, 'file1.txt'), 'content1');
+            writeFileSync(join(TEST_DIR, 'file2.txt'), 'content2');
+            const files = getChangedFiles(TEST_DIR);
+            expect(files).toContain('file1.txt');
+            expect(files).toContain('file2.txt');
+        });
+    });
+    describe('suggestCommitMessage', () => {
+        it('should suggest feat for new files', () => {
+            const diff = 'new file mode 100644\n+++ b/newfile.ts';
+            expect(suggestCommitMessage(diff)).toBe('feat: add new files');
+        });
+        it('should suggest chore for deleted files', () => {
+            const diff = 'deleted file mode 100644\n--- a/oldfile.ts';
+            expect(suggestCommitMessage(diff)).toBe('chore: remove files');
+        });
+        it('should suggest chore for package.json changes', () => {
+            const diff = '+++ b/package.json\n+  "new-dep": "1.0.0"';
+            expect(suggestCommitMessage(diff)).toBe('chore: update dependencies');
+        });
+        it('should suggest docs for README changes', () => {
+            const diff = '+++ b/README.md\n+ New documentation';
+            expect(suggestCommitMessage(diff)).toBe('docs: update documentation');
+        });
+        it('should suggest test for test file changes', () => {
+            const diff = '+++ b/utils.test.ts\n+ test case';
+            expect(suggestCommitMessage(diff)).toBe('test: update tests');
+        });
+    });
+    describe('createCommit', () => {
+        it('should return error for non-git directory', () => {
+            const result = createCommit('test message', NON_GIT_DIR);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Not a git repository');
+        });
+        it('should return error when no staged changes', () => {
+            const result = createCommit('test message', TEST_DIR);
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('No staged changes to commit');
+        });
+        it('should create commit successfully', () => {
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
+            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+            const result = createCommit('test commit message', TEST_DIR);
+            expect(result.success).toBe(true);
+            expect(result.hash).toBeDefined();
+            expect(result.hash.length).toBeGreaterThan(0);
+        });
+        it('should handle special characters in commit message safely', () => {
+            writeFileSync(join(TEST_DIR, 'test.txt'), 'hello');
+            execSync('git add .', { cwd: TEST_DIR, stdio: 'ignore' });
+            // Test with potentially dangerous characters that could cause shell injection
+            const dangerousMessage = 'test `whoami` $(echo dangerous) ; rm -rf /';
+            const result = createCommit(dangerousMessage, TEST_DIR);
+            expect(result.success).toBe(true);
+            // Verify the commit message was stored correctly (not executed)
+            const log = execSync('git log -1 --format=%s', { cwd: TEST_DIR, encoding: 'utf-8' });
+            expect(log.trim()).toBe(dangerousMessage);
+        });
+    });
+    describe('stageAll', () => {
+        it('should return false for non-git directory', () => {
+            expect(stageAll(NON_GIT_DIR)).toBe(false);
+        });
+        it('should stage all files', () => {
+            writeFileSync(join(TEST_DIR, 'file1.txt'), 'content1');
+            writeFileSync(join(TEST_DIR, 'file2.txt'), 'content2');
+            expect(stageAll(TEST_DIR)).toBe(true);
+            // Verify files are staged
+            const staged = execSync('git diff --cached --name-only', { cwd: TEST_DIR, encoding: 'utf-8' });
+            expect(staged).toContain('file1.txt');
+            expect(staged).toContain('file2.txt');
+        });
+    });
+    describe('formatDiffForDisplay', () => {
+        it('should return full diff if under limit', () => {
+            const diff = 'line1\nline2\nline3';
+            expect(formatDiffForDisplay(diff, 10)).toBe(diff);
+        });
+        it('should truncate long diffs', () => {
+            const lines = Array.from({ length: 100 }, (_, i) => `line${i}`);
+            const diff = lines.join('\n');
+            const result = formatDiffForDisplay(diff, 10);
+            expect(result).toContain('line0');
+            expect(result).toContain('line9');
+            expect(result).not.toContain('line99');
+            expect(result).toContain('90 more lines');
+        });
+    });
+});

package/dist/utils/history.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Agent action history for undo/rollback functionality
+ */
+export interface ActionRecord {
+    id: string;
+    timestamp: number;
+    type: 'write' | 'edit' | 'delete' | 'mkdir' | 'command';
+    path?: string;
+    previousContent?: string;
+    previousExisted?: boolean;
+    wasDirectory?: boolean;
+    deletedContent?: string;
+    command?: string;
+    args?: string[];
+    undone?: boolean;
+}
+export interface ActionSession {
+    id: string;
+    startTime: number;
+    endTime?: number;
+    prompt: string;
+    actions: ActionRecord[];
+    projectRoot: string;
+}
+/**
+ * Start a new action session
+ */
+export declare function startSession(prompt: string, projectRoot: string): string;
+/**
+ * End current session and save to disk
+ */
+export declare function endSession(): void;
+/**
+ * Record a file write action (before it happens)
+ */
+export declare function recordWrite(path: string): ActionRecord | null;
+/**
+ * Record a file edit action (before it happens)
+ */
+export declare function recordEdit(path: string): ActionRecord | null;
+/**
+ * Record a file/directory delete action (before it happens)
+ */
+export declare function recordDelete(path: string): ActionRecord | null;
+/**
+ * Record a mkdir action
+ */
+export declare function recordMkdir(path: string): ActionRecord | null;
+/**
+ * Record a command execution (can't be undone, but tracked)
+ */
+export declare function recordCommand(command: string, args: string[]): ActionRecord | null;
+/**
+ * Get current session
+ */
+export declare function getCurrentSession(): ActionSession | null;
+/**
+ * Undo the last action in current session
+ */
+export declare function undoLastAction(): {
+    success: boolean;
+    message: string;
+};
+/**
+ * Undo a specific action
+ */
+export declare function undoAction(action: ActionRecord): {
+    success: boolean;
+    message: string;
+};
+/**
+ * Undo all actions in current session
+ */
+export declare function undoAllActions(): {
+    success: boolean;
+    results: string[];
+};
+/**
+ * Get list of recent sessions
+ */
+export declare function getRecentSessions(limit?: number): ActionSession[];
+/**
+ * Get a specific session by ID
+ */
+export declare function getSession(sessionId: string): ActionSession | null;
+/**
+ * Format session for display
+ */
+export declare function formatSession(session: ActionSession): string;
+/**
+ * Clear all history
+ */
+export declare function clearHistory(): void;