rafcode 1.0.0

package/tests/unit/failure-history.test.ts

@@ -0,0 +1,143 @@
+import { formatRetryHistoryForConsole } from '../../src/commands/do.js';
+
+/**
+ * Tests for retry history formatting.
+ *
+ * NOTE: Retry history is now shown in console output instead of being written
+ * to outcome files. This test suite verifies the console output formatting.
+ */
+describe('Retry History Formatting', () => {
+  describe('formatRetryHistoryForConsole', () => {
+    it('should return empty string when no failures occurred', () => {
+      const result = formatRetryHistoryForConsole('001', 'my-task', [], 1, true);
+      expect(result).toBe('');
+    });
+
+    it('should format single failure followed by success', () => {
+      const failureHistory = [{ attempt: 1, reason: 'Task timed out' }];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 2, true);
+
+      expect(result).toContain('Task 001 (my-task):');
+      expect(result).toContain('Attempt 1: Failed - Task timed out');
+      expect(result).toContain('Attempt 2: Succeeded');
+    });
+
+    it('should format multiple failures followed by success', () => {
+      const failureHistory = [
+        { attempt: 1, reason: 'Context overflow - task too large' },
+        { attempt: 2, reason: 'API rate limit exceeded' },
+      ];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 3, true);
+
+      expect(result).toContain('Task 001 (my-task):');
+      expect(result).toContain('Attempt 1: Failed - Context overflow - task too large');
+      expect(result).toContain('Attempt 2: Failed - API rate limit exceeded');
+      expect(result).toContain('Attempt 3: Succeeded');
+    });
+
+    it('should format failures without success when task ultimately failed', () => {
+      const failureHistory = [
+        { attempt: 1, reason: 'Task timed out' },
+        { attempt: 2, reason: 'Task timed out' },
+        { attempt: 3, reason: 'Context overflow' },
+      ];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 3, false);
+
+      expect(result).toContain('Task 001 (my-task):');
+      expect(result).toContain('Attempt 1: Failed - Task timed out');
+      expect(result).toContain('Attempt 2: Failed - Task timed out');
+      expect(result).toContain('Attempt 3: Failed - Context overflow');
+      expect(result).not.toContain('Succeeded');
+    });
+
+    it('should preserve failure reasons exactly as provided', () => {
+      const failureHistory = [
+        { attempt: 1, reason: 'No completion marker found in output or outcome file' },
+      ];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 2, true);
+
+      expect(result).toContain('Attempt 1: Failed - No completion marker found in output or outcome file');
+    });
+
+    it('should handle task name same as task id', () => {
+      const failureHistory = [{ attempt: 1, reason: 'Test failure' }];
+      const result = formatRetryHistoryForConsole('001', '001', failureHistory, 2, true);
+
+      // When taskName equals taskId, should just show taskId without parentheses
+      expect(result).toContain('Task 001:');
+      expect(result).not.toContain('Task 001 (001):');
+    });
+
+    it('should have proper indentation structure', () => {
+      const failureHistory = [
+        { attempt: 1, reason: 'First failure' },
+        { attempt: 2, reason: 'Second failure' },
+      ];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 3, true);
+      const lines = result.split('\n');
+
+      // First line should be task header with minimal indentation
+      expect(lines[0]).toMatch(/^\s{2}Task/);
+      // Following lines should have more indentation for attempts
+      expect(lines[1]).toMatch(/^\s{4}Attempt 1/);
+      expect(lines[2]).toMatch(/^\s{4}Attempt 2/);
+      expect(lines[3]).toMatch(/^\s{4}Attempt 3/);
+    });
+
+    it('should handle single failure with immediate success on retry', () => {
+      const failureHistory = [{ attempt: 1, reason: 'Rate limit exceeded' }];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 2, true);
+
+      const lines = result.split('\n');
+      expect(lines).toHaveLength(3);
+      expect(lines[0]).toContain('Task 001 (my-task):');
+      expect(lines[1]).toContain('Attempt 1: Failed - Rate limit exceeded');
+      expect(lines[2]).toContain('Attempt 2: Succeeded');
+    });
+
+    it('should handle maximum retries (3 failures)', () => {
+      const failureHistory = [
+        { attempt: 1, reason: 'API error' },
+        { attempt: 2, reason: 'API error' },
+        { attempt: 3, reason: 'API error' },
+      ];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 3, false);
+
+      const lines = result.split('\n');
+      expect(lines).toHaveLength(4);
+      expect(lines[0]).toContain('Task 001 (my-task):');
+      expect(lines[1]).toContain('Attempt 1: Failed - API error');
+      expect(lines[2]).toContain('Attempt 2: Failed - API error');
+      expect(lines[3]).toContain('Attempt 3: Failed - API error');
+    });
+  });
+
+  describe('integration scenarios', () => {
+    it('should work for clean success (no failures)', () => {
+      // On first attempt success, no retry history
+      const result = formatRetryHistoryForConsole('001', 'my-task', [], 1, true);
+      expect(result).toBe('');
+    });
+
+    it('should work for retry after timeout then success', () => {
+      const failureHistory = [{ attempt: 1, reason: 'Task timed out' }];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 2, true);
+
+      expect(result).toContain('Attempt 1');
+      expect(result).toContain('Task timed out');
+      expect(result).toContain('Attempt 2');
+      expect(result).toContain('Succeeded');
+    });
+
+    it('should work for ultimate failure after all retries', () => {
+      const failureHistory = [
+        { attempt: 1, reason: 'Context overflow - task too large' },
+      ];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 1, false);
+
+      expect(result).toContain('Attempt 1');
+      expect(result).toContain('Context overflow');
+      expect(result).not.toContain('Succeeded');
+    });
+  });
+});

package/tests/unit/git-stash.test.ts

@@ -0,0 +1,138 @@
+import { jest } from '@jest/globals';
+
+// Mock execSync before importing the module
+const mockExecSync = jest.fn();
+jest.unstable_mockModule('node:child_process', () => ({
+  execSync: mockExecSync,
+}));
+
+// Mock logger to prevent console output
+jest.unstable_mockModule('../../src/utils/logger.js', () => ({
+  logger: {
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+// Import after mocking
+const { stashChanges, isGitRepo, hasUncommittedChanges } = await import('../../src/core/git.js');
+
+describe('stashChanges', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should return false when not in a git repository', () => {
+    mockExecSync.mockImplementation(() => {
+      throw new Error('not a git repository');
+    });
+
+    const result = stashChanges('test-stash');
+    expect(result).toBe(false);
+  });
+
+  it('should return false when there are no uncommitted changes', () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('status --porcelain')) {
+        return ''; // No changes
+      }
+      return '';
+    });
+
+    const result = stashChanges('test-stash');
+    expect(result).toBe(false);
+  });
+
+  it('should stash changes with descriptive name', () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('status --porcelain')) {
+        return 'M  src/file.ts\n';
+      }
+      if (cmdStr.includes('stash push')) {
+        return '';
+      }
+      return '';
+    });
+
+    const result = stashChanges('raf-001-task-3-failed');
+    expect(result).toBe(true);
+    expect(mockExecSync).toHaveBeenCalledWith(
+      'git stash push -m "raf-001-task-3-failed"',
+      expect.any(Object)
+    );
+  });
+
+  it('should escape quotes in stash name', () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('status --porcelain')) {
+        return 'M  src/file.ts\n';
+      }
+      if (cmdStr.includes('stash push')) {
+        return '';
+      }
+      return '';
+    });
+
+    const result = stashChanges('test "with" quotes');
+    expect(result).toBe(true);
+    expect(mockExecSync).toHaveBeenCalledWith(
+      'git stash push -m "test \\"with\\" quotes"',
+      expect.any(Object)
+    );
+  });
+
+  it('should return false if stash command fails', () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('status --porcelain')) {
+        return 'M  src/file.ts\n';
+      }
+      if (cmdStr.includes('stash push')) {
+        throw new Error('stash failed');
+      }
+      return '';
+    });
+
+    const result = stashChanges('test-stash');
+    expect(result).toBe(false);
+  });
+
+  it('should use correct stash name format for RAF failures', () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('status --porcelain')) {
+        return 'M  src/file.ts\nA  src/new.ts\n';
+      }
+      if (cmdStr.includes('stash push')) {
+        return '';
+      }
+      return '';
+    });
+
+    const result = stashChanges('raf-002-task-5-failed');
+    expect(result).toBe(true);
+    expect(mockExecSync).toHaveBeenCalledWith(
+      'git stash push -m "raf-002-task-5-failed"',
+      expect.any(Object)
+    );
+  });
+});

package/tests/unit/git.test.ts

@@ -0,0 +1,80 @@
+import { parseGitStatus } from '../../src/core/git.js';
+
+describe('git utilities', () => {
+  describe('parseGitStatus', () => {
+    it('should return empty array for empty output', () => {
+      expect(parseGitStatus('')).toEqual([]);
+      expect(parseGitStatus('   ')).toEqual([]);
+    });
+
+    it('should parse modified files (staged)', () => {
+      const output = 'M  src/file.ts';
+      expect(parseGitStatus(output)).toEqual(['src/file.ts']);
+    });
+
+    it('should parse modified files (unstaged)', () => {
+      // Git porcelain format: XY PATH (X=index, Y=worktree, space, then path)
+      // For unstaged modification: ' M filename' (space, M, space, filename)
+      const output = ' M src/file.ts';
+      expect(parseGitStatus(output)).toEqual(['src/file.ts']);
+    });
+
+    it('should parse modified files (both staged and unstaged)', () => {
+      const output = 'MM src/file.ts';
+      expect(parseGitStatus(output)).toEqual(['src/file.ts']);
+    });
+
+    it('should parse added files', () => {
+      const output = 'A  src/new-file.ts';
+      expect(parseGitStatus(output)).toEqual(['src/new-file.ts']);
+    });
+
+    it('should parse deleted files', () => {
+      const output = 'D  src/old-file.ts';
+      expect(parseGitStatus(output)).toEqual(['src/old-file.ts']);
+    });
+
+    it('should parse untracked files', () => {
+      const output = '?? src/untracked.ts';
+      expect(parseGitStatus(output)).toEqual(['src/untracked.ts']);
+    });
+
+    it('should parse renamed files (extracting new name)', () => {
+      const output = 'R  old-name.ts -> new-name.ts';
+      expect(parseGitStatus(output)).toEqual(['new-name.ts']);
+    });
+
+    it('should parse copied files (extracting new name)', () => {
+      const output = 'C  original.ts -> copy.ts';
+      expect(parseGitStatus(output)).toEqual(['copy.ts']);
+    });
+
+    it('should parse multiple files', () => {
+      const output = `M  src/modified.ts
+A  src/added.ts
+D  src/deleted.ts
+?? src/untracked.ts`;
+      expect(parseGitStatus(output)).toEqual([
+        'src/modified.ts',
+        'src/added.ts',
+        'src/deleted.ts',
+        'src/untracked.ts',
+      ]);
+    });
+
+    it('should handle quoted paths with special characters', () => {
+      const output = '"src/file with spaces.ts"';
+      // This is incomplete input but tests quote handling
+      // Real git status has format: XY "path"
+      const output2 = 'M  "src/file with spaces.ts"';
+      expect(parseGitStatus(output2)).toEqual(['src/file with spaces.ts']);
+    });
+
+    it('should skip malformed lines', () => {
+      const output = `M  valid.ts
+ab
+M  another.ts`;
+      expect(parseGitStatus(output)).toEqual(['valid.ts', 'another.ts']);
+    });
+  });
+});

package/tests/unit/logger.test.ts

@@ -0,0 +1,132 @@
+import { jest } from '@jest/globals';
+import { logger } from '../../src/utils/logger.js';
+
+describe('Logger', () => {
+  let consoleLogSpy: ReturnType<typeof jest.spyOn>;
+  let consoleWarnSpy: ReturnType<typeof jest.spyOn>;
+  let consoleErrorSpy: ReturnType<typeof jest.spyOn>;
+
+  beforeEach(() => {
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    logger.clearContext();
+    logger.configure({ verbose: false, debug: false });
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleWarnSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+    logger.clearContext();
+  });
+
+  describe('print', () => {
+    it('should output text exactly as passed', () => {
+      logger.print('Hello World');
+      expect(consoleLogSpy).toHaveBeenCalledWith('Hello World');
+    });
+
+    it('should pass additional arguments through', () => {
+      logger.print('Value: %d', 42);
+      expect(consoleLogSpy).toHaveBeenCalledWith('Value: %d', 42);
+    });
+
+    it('should not add any prefix', () => {
+      logger.print('raw text');
+      expect(consoleLogSpy).toHaveBeenCalledWith('raw text');
+    });
+  });
+
+  describe('info', () => {
+    it('should output message without prefix', () => {
+      logger.info('Starting task');
+      expect(consoleLogSpy).toHaveBeenCalledWith('Starting task');
+    });
+  });
+
+  describe('success', () => {
+    it('should output with ✓ prefix', () => {
+      logger.success('Task completed');
+      expect(consoleLogSpy).toHaveBeenCalledWith('✓ Task completed');
+    });
+  });
+
+  describe('warn', () => {
+    it('should output with ⚠️ prefix', () => {
+      logger.warn('Something needs attention');
+      expect(consoleWarnSpy).toHaveBeenCalledWith('⚠️  Something needs attention');
+    });
+  });
+
+  describe('error', () => {
+    it('should output with ✗ prefix', () => {
+      logger.error('Something went wrong');
+      expect(consoleErrorSpy).toHaveBeenCalledWith('✗ Something went wrong');
+    });
+  });
+
+  describe('context methods (deprecated)', () => {
+    it('setContext should be a no-op', () => {
+      logger.setContext('[Task 2/5: fix-login]');
+      logger.info('Starting task');
+      // Context should NOT be applied - it's a no-op
+      expect(consoleLogSpy).toHaveBeenCalledWith('Starting task');
+    });
+
+    it('clearContext should be a no-op', () => {
+      logger.setContext('[Task 1/1: test]');
+      logger.clearContext();
+      logger.info('No prefix here');
+      expect(consoleLogSpy).toHaveBeenCalledWith('No prefix here');
+    });
+  });
+
+  describe('verbose_log', () => {
+    it('should log when verbose mode is enabled', () => {
+      logger.configure({ verbose: true });
+      logger.verbose_log('Verbose message');
+      expect(consoleLogSpy).toHaveBeenCalledWith('Verbose message');
+    });
+
+    it('should not log when verbose mode is disabled', () => {
+      logger.configure({ verbose: false });
+      logger.verbose_log('Verbose message');
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+
+    it('should log when debug mode is enabled', () => {
+      logger.configure({ debug: true });
+      logger.verbose_log('Verbose message');
+      expect(consoleLogSpy).toHaveBeenCalledWith('Verbose message');
+    });
+  });
+
+  describe('debug', () => {
+    it('should log with [DEBUG] prefix when debug mode is enabled', () => {
+      logger.configure({ debug: true });
+      logger.debug('Debug message');
+      expect(consoleLogSpy).toHaveBeenCalledWith('[DEBUG] Debug message');
+    });
+
+    it('should not log when debug mode is disabled', () => {
+      logger.configure({ debug: false });
+      logger.debug('Debug message');
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('task', () => {
+    it('should output status and name', () => {
+      logger.task('●', 'running-task');
+      expect(consoleLogSpy).toHaveBeenCalledWith('● running-task');
+    });
+  });
+
+  describe('newline', () => {
+    it('should output an empty line', () => {
+      logger.newline();
+      expect(consoleLogSpy).toHaveBeenCalledWith();
+    });
+  });
+});