rafcode 1.0.0

package/tests/unit/name-generator.test.ts

@@ -0,0 +1,283 @@
+import { jest } from '@jest/globals';
+
+// Mock execSync before importing the module
+const mockExecSync = jest.fn();
+jest.unstable_mockModule('node:child_process', () => ({
+  execSync: mockExecSync,
+}));
+
+// Import after mocking
+const { generateProjectName, generateProjectNames, sanitizeGeneratedName, escapeShellArg } =
+  await import('../../src/utils/name-generator.js');
+
+describe('Name Generator', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('generateProjectName', () => {
+    it('should return sanitized name from Sonnet response', async () => {
+      mockExecSync.mockReturnValue('user-auth-system\n');
+
+      const result = await generateProjectName('Build a user authentication system');
+
+      expect(result).toBe('user-auth-system');
+      expect(mockExecSync).toHaveBeenCalledTimes(1);
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('claude --model sonnet --print'),
+        expect.any(Object)
+      );
+    });
+
+    it('should sanitize Sonnet response with quotes', async () => {
+      mockExecSync.mockReturnValue('"api-rate-limiter"');
+
+      const result = await generateProjectName('Create an API rate limiting service');
+
+      expect(result).toBe('api-rate-limiter');
+    });
+
+    it('should sanitize Sonnet response with special characters', async () => {
+      mockExecSync.mockReturnValue('Some Project! Name');
+
+      const result = await generateProjectName('Some project description');
+
+      expect(result).toBe('some-project-name');
+    });
+
+    it('should fall back to word extraction when Sonnet fails', async () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Command failed');
+      });
+
+      const result = await generateProjectName('Build a user authentication system with OAuth');
+
+      expect(result).toBe('build-user-authentication');
+    });
+
+    it('should fall back to word extraction when Sonnet returns empty', async () => {
+      mockExecSync.mockReturnValue('');
+
+      const result = await generateProjectName('Implement caching layer for database');
+
+      expect(result).toBe('implement-caching-layer');
+    });
+
+    it('should fall back to word extraction when Sonnet returns single char', async () => {
+      mockExecSync.mockReturnValue('a');
+
+      const result = await generateProjectName('Add new logging functionality');
+
+      expect(result).toBe('add-new-logging');
+    });
+
+    it('should return "project" when description has no meaningful words', async () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Command failed');
+      });
+
+      const result = await generateProjectName('a b c');
+
+      expect(result).toBe('project');
+    });
+
+    it('should truncate long names from Sonnet', async () => {
+      const longName =
+        'this-is-a-very-long-project-name-that-exceeds-the-maximum-allowed-length-for-folder-names';
+      mockExecSync.mockReturnValue(longName);
+
+      const result = await generateProjectName('Some project');
+
+      expect(result.length).toBeLessThanOrEqual(50);
+    });
+
+    it('should handle multiline Sonnet response', async () => {
+      mockExecSync.mockReturnValue('project-name\nSome extra explanation\n');
+
+      const result = await generateProjectName('Some project');
+
+      // Should take first line after trim
+      expect(result).toBe('project-name-some-extra-explanation');
+    });
+
+    it('should convert uppercase to lowercase', async () => {
+      mockExecSync.mockReturnValue('API-Gateway-Service');
+
+      const result = await generateProjectName('Build an API gateway');
+
+      expect(result).toBe('api-gateway-service');
+    });
+  });
+
+  describe('generateProjectNames', () => {
+    it('should return multiple sanitized names from Sonnet response', async () => {
+      mockExecSync.mockReturnValue(
+        'phoenix-rise\nturbo-boost\nbug-squasher\ncatalyst\nmerlin\n'
+      );
+
+      const result = await generateProjectNames('Build a user authentication system');
+
+      expect(result).toEqual([
+        'phoenix-rise',
+        'turbo-boost',
+        'bug-squasher',
+        'catalyst',
+        'merlin',
+      ]);
+      expect(mockExecSync).toHaveBeenCalledTimes(1);
+      expect(mockExecSync).toHaveBeenCalledWith(
+        expect.stringContaining('Generate 5 creative project names'),
+        expect.any(Object)
+      );
+    });
+
+    it('should handle names with numbering prefixes', async () => {
+      mockExecSync.mockReturnValue(
+        '1. phoenix-rise\n2. turbo-boost\n3. bug-squasher\n4. catalyst\n5. merlin\n'
+      );
+
+      const result = await generateProjectNames('Some project');
+
+      expect(result).toEqual([
+        'phoenix-rise',
+        'turbo-boost',
+        'bug-squasher',
+        'catalyst',
+        'merlin',
+      ]);
+    });
+
+    it('should handle names with colon prefixes', async () => {
+      mockExecSync.mockReturnValue(
+        '1: phoenix-rise\n2: turbo-boost\n3: bug-squasher\n'
+      );
+
+      const result = await generateProjectNames('Some project');
+
+      expect(result).toEqual(['phoenix-rise', 'turbo-boost', 'bug-squasher']);
+    });
+
+    it('should remove duplicate names', async () => {
+      mockExecSync.mockReturnValue(
+        'phoenix\nturbo-boost\nphoenix\ncatalyst\nturbo-boost\n'
+      );
+
+      const result = await generateProjectNames('Some project');
+
+      expect(result).toEqual(['phoenix', 'turbo-boost', 'catalyst']);
+    });
+
+    it('should limit to 5 names maximum', async () => {
+      mockExecSync.mockReturnValue(
+        'name-one\nname-two\nname-three\nname-four\nname-five\nname-six\nname-seven\n'
+      );
+
+      const result = await generateProjectNames('Some project');
+
+      expect(result.length).toBe(5);
+    });
+
+    it('should return 3+ names when available', async () => {
+      mockExecSync.mockReturnValue('phoenix\nturbo-boost\ncatalyst\n');
+
+      const result = await generateProjectNames('Some project');
+
+      expect(result.length).toBe(3);
+    });
+
+    it('should fall back to single name when Sonnet fails', async () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Command failed');
+      });
+
+      const result = await generateProjectNames('Build a user authentication system with OAuth');
+
+      expect(result).toEqual(['build-user-authentication']);
+    });
+
+    it('should fall back to single name when too few names returned', async () => {
+      mockExecSync.mockReturnValue('phoenix\nturbo\n');
+
+      const result = await generateProjectNames('Build something awesome');
+
+      // Only 2 names returned, so fallback kicks in
+      expect(result).toEqual(['build-something-awesome']);
+    });
+
+    it('should filter out invalid/short names', async () => {
+      mockExecSync.mockReturnValue('phoenix\na\nturbo-boost\nb\ncatalyst\n');
+
+      const result = await generateProjectNames('Some project');
+
+      expect(result).toEqual(['phoenix', 'turbo-boost', 'catalyst']);
+    });
+
+    it('should sanitize names with special characters', async () => {
+      mockExecSync.mockReturnValue(
+        'Phoenix Rise!\nTurbo-Boost!!!\nBug Squasher\n'
+      );
+
+      const result = await generateProjectNames('Some project');
+
+      expect(result).toEqual(['phoenix-rise', 'turbo-boost', 'bug-squasher']);
+    });
+
+    it('should handle empty response', async () => {
+      mockExecSync.mockReturnValue('');
+
+      const result = await generateProjectNames('Some project');
+
+      expect(result).toEqual(['some-project']);
+    });
+  });
+
+  describe('sanitizeGeneratedName', () => {
+    it('should remove quotes', () => {
+      expect(sanitizeGeneratedName('"hello-world"')).toBe('hello-world');
+      expect(sanitizeGeneratedName("'hello-world'")).toBe('hello-world');
+    });
+
+    it('should remove numbering prefixes', () => {
+      expect(sanitizeGeneratedName('1. hello-world')).toBe('hello-world');
+      expect(sanitizeGeneratedName('1: hello-world')).toBe('hello-world');
+      expect(sanitizeGeneratedName('1) hello-world')).toBe('hello-world');
+    });
+
+    it('should convert to lowercase', () => {
+      expect(sanitizeGeneratedName('Hello-World')).toBe('hello-world');
+    });
+
+    it('should replace special characters with hyphens', () => {
+      expect(sanitizeGeneratedName('hello world!')).toBe('hello-world');
+    });
+
+    it('should return null for too short names', () => {
+      expect(sanitizeGeneratedName('a')).toBeNull();
+      expect(sanitizeGeneratedName('')).toBeNull();
+    });
+
+    it('should truncate long names', () => {
+      const longName = 'a'.repeat(100);
+      const result = sanitizeGeneratedName(longName);
+      expect(result?.length).toBeLessThanOrEqual(50);
+    });
+  });
+
+  describe('escapeShellArg', () => {
+    it('should escape double quotes', () => {
+      expect(escapeShellArg('hello "world"')).toBe('hello \\"world\\"');
+    });
+
+    it('should escape backslashes', () => {
+      expect(escapeShellArg('hello\\world')).toBe('hello\\\\world');
+    });
+
+    it('should escape dollar signs', () => {
+      expect(escapeShellArg('$HOME')).toBe('\\$HOME');
+    });
+
+    it('should escape backticks', () => {
+      expect(escapeShellArg('`whoami`')).toBe('\\`whoami\\`');
+    });
+  });
+});

package/tests/unit/name-picker.test.ts

@@ -0,0 +1,179 @@
+import { jest } from '@jest/globals';
+
+// Mock @inquirer/prompts before importing the module
+const mockSelect = jest.fn();
+const mockInput = jest.fn();
+jest.unstable_mockModule('@inquirer/prompts', () => ({
+  select: mockSelect,
+  input: mockInput,
+}));
+
+// Import after mocking
+const { pickProjectName, enableDirectMode, disableDirectMode } = await import(
+  '../../src/ui/name-picker.js'
+);
+
+describe('Name Picker', () => {
+  beforeAll(async () => {
+    // Enable direct mode for testing (bypasses subprocess)
+    await enableDirectMode();
+  });
+
+  afterAll(() => {
+    disableDirectMode();
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('pickProjectName', () => {
+    it('should display generated names as choices', async () => {
+      mockSelect.mockResolvedValue('phoenix-rise');
+
+      const result = await pickProjectName(['phoenix-rise', 'turbo-boost', 'catalyst']);
+
+      expect(result).toBe('phoenix-rise');
+      expect(mockSelect).toHaveBeenCalledTimes(1);
+      expect(mockSelect).toHaveBeenCalledWith({
+        message: 'Select a project name:',
+        choices: [
+          { name: 'phoenix-rise', value: 'phoenix-rise' },
+          { name: 'turbo-boost', value: 'turbo-boost' },
+          { name: 'catalyst', value: 'catalyst' },
+          { name: 'Other (enter custom name)', value: '__OTHER__' },
+        ],
+      });
+    });
+
+    it('should return selected name from list', async () => {
+      mockSelect.mockResolvedValue('turbo-boost');
+
+      const result = await pickProjectName(['phoenix', 'turbo-boost', 'merlin']);
+
+      expect(result).toBe('turbo-boost');
+    });
+
+    it('should prompt for custom name when "Other" is selected', async () => {
+      mockSelect.mockResolvedValue('__OTHER__');
+      mockInput.mockResolvedValue('custom-project');
+
+      const result = await pickProjectName(['phoenix', 'turbo']);
+
+      expect(result).toBe('custom-project');
+      expect(mockInput).toHaveBeenCalledTimes(1);
+      expect(mockInput).toHaveBeenCalledWith({
+        message: 'Enter project name:',
+        validate: expect.any(Function),
+      });
+    });
+
+    it('should prompt for custom name immediately when names array is empty', async () => {
+      mockInput.mockResolvedValue('my-project');
+
+      const result = await pickProjectName([]);
+
+      expect(result).toBe('my-project');
+      expect(mockSelect).not.toHaveBeenCalled();
+      expect(mockInput).toHaveBeenCalledTimes(1);
+    });
+
+    it('should convert custom name to lowercase', async () => {
+      mockSelect.mockResolvedValue('__OTHER__');
+      mockInput.mockResolvedValue('MyProject');
+
+      const result = await pickProjectName(['phoenix']);
+
+      expect(result).toBe('myproject');
+    });
+
+    it('should trim custom name', async () => {
+      mockSelect.mockResolvedValue('__OTHER__');
+      mockInput.mockResolvedValue('  my-project  ');
+
+      const result = await pickProjectName(['phoenix']);
+
+      expect(result).toBe('my-project');
+    });
+
+    describe('custom name validation', () => {
+      let validateFn: (value: string) => boolean | string;
+
+      beforeEach(async () => {
+        mockSelect.mockResolvedValue('__OTHER__');
+        mockInput.mockImplementation(async (config) => {
+          validateFn = config.validate;
+          return 'valid-name';
+        });
+
+        await pickProjectName(['phoenix']);
+      });
+
+      it('should reject empty names', () => {
+        expect(validateFn('')).toBe('Project name cannot be empty');
+        expect(validateFn('   ')).toBe('Project name cannot be empty');
+      });
+
+      it('should reject names longer than 50 characters', () => {
+        const longName = 'a'.repeat(51);
+        expect(validateFn(longName)).toBe('Project name must be 50 characters or less');
+      });
+
+      it('should accept valid names', () => {
+        expect(validateFn('valid-name')).toBe(true);
+        expect(validateFn('my_project')).toBe(true);
+        expect(validateFn('project123')).toBe(true);
+      });
+
+      it('should reject names with special characters', () => {
+        expect(validateFn('hello world')).toBe(
+          'Project name can only contain letters, numbers, hyphens, and underscores'
+        );
+        expect(validateFn('project!')).toBe(
+          'Project name can only contain letters, numbers, hyphens, and underscores'
+        );
+      });
+
+      it('should reject names starting with hyphen', () => {
+        expect(validateFn('-project')).toBe(
+          'Project name can only contain letters, numbers, hyphens, and underscores'
+        );
+      });
+    });
+
+    it('should handle 5 generated names', async () => {
+      const names = ['name-one', 'name-two', 'name-three', 'name-four', 'name-five'];
+      mockSelect.mockResolvedValue('name-three');
+
+      const result = await pickProjectName(names);
+
+      expect(result).toBe('name-three');
+      expect(mockSelect).toHaveBeenCalledWith({
+        message: 'Select a project name:',
+        choices: [
+          { name: 'name-one', value: 'name-one' },
+          { name: 'name-two', value: 'name-two' },
+          { name: 'name-three', value: 'name-three' },
+          { name: 'name-four', value: 'name-four' },
+          { name: 'name-five', value: 'name-five' },
+          { name: 'Other (enter custom name)', value: '__OTHER__' },
+        ],
+      });
+    });
+
+    it('should handle single generated name', async () => {
+      mockSelect.mockResolvedValue('only-option');
+
+      const result = await pickProjectName(['only-option']);
+
+      expect(result).toBe('only-option');
+      expect(mockSelect).toHaveBeenCalledWith({
+        message: 'Select a project name:',
+        choices: [
+          { name: 'only-option', value: 'only-option' },
+          { name: 'Other (enter custom name)', value: '__OTHER__' },
+        ],
+      });
+    });
+  });
+});

package/tests/unit/outcome-content.test.ts

@@ -0,0 +1,166 @@
+import { formatRetryHistoryForConsole } from '../../src/commands/do.js';
+
+/**
+ * Tests for outcome content generation and retry history formatting.
+ * Verifies:
+ * - Successful outcomes do NOT contain ## Details or ## Failure History
+ * - Failed outcomes DO contain ## Details (for debugging)
+ * - Retry history is correctly formatted for console output
+ */
+describe('Outcome Content Format', () => {
+  /**
+   * Helper that generates a successful outcome content matching the template in do.ts.
+   * NOTE: Successful outcomes no longer include ## Details section.
+   */
+  function generateSuccessOutcome(taskId: string): string {
+    return `## Status: SUCCESS
+
+# Task ${taskId} - Completed
+
+Task completed. No detailed report provided.
+
+<promise>COMPLETE</promise>
+`;
+  }
+
+  /**
+   * Helper that generates a failed outcome content matching the template in do.ts.
+   * NOTE: Failed outcomes still include ## Details section for debugging.
+   */
+  function generateFailedOutcome(
+    taskId: string,
+    attempts: number = 1,
+    elapsed: string = '1m 30s',
+    stashName?: string
+  ): string {
+    return `## Status: FAILED
+
+# Task ${taskId} - Failed
+
+## Failure Reason
+Task failed for some reason.
+
+<promise>FAILED</promise>
+
+## Details
+- Attempts: ${attempts}
+- Elapsed time: ${elapsed}
+- Failed at: ${new Date().toISOString()}
+${stashName ? `- Stash: ${stashName}` : ''}
+`;
+  }
+
+  describe('successful outcomes', () => {
+    it('should not contain ## Details section', () => {
+      const outcome = generateSuccessOutcome('001');
+
+      expect(outcome).not.toContain('## Details');
+      expect(outcome).not.toContain('Attempts:');
+      expect(outcome).not.toContain('Elapsed time:');
+      expect(outcome).not.toContain('Completed at:');
+    });
+
+    it('should not contain ## Failure History section', () => {
+      const outcome = generateSuccessOutcome('001');
+
+      expect(outcome).not.toContain('## Failure History');
+    });
+
+    it('should contain the completion marker', () => {
+      const outcome = generateSuccessOutcome('001');
+
+      expect(outcome).toContain('<promise>COMPLETE</promise>');
+    });
+
+    it('should contain basic structure', () => {
+      const outcome = generateSuccessOutcome('002');
+
+      expect(outcome).toContain('## Status: SUCCESS');
+      expect(outcome).toContain('# Task 002 - Completed');
+    });
+  });
+
+  describe('failed outcomes', () => {
+    it('should contain ## Details section for debugging', () => {
+      const outcome = generateFailedOutcome('001', 3, '5m 10s');
+
+      expect(outcome).toContain('## Details');
+      expect(outcome).toContain('Attempts: 3');
+      expect(outcome).toContain('Elapsed time: 5m 10s');
+      expect(outcome).toContain('Failed at:');
+    });
+
+    it('should not contain ## Failure History section', () => {
+      const outcome = generateFailedOutcome('001');
+
+      expect(outcome).not.toContain('## Failure History');
+    });
+
+    it('should contain the failure marker', () => {
+      const outcome = generateFailedOutcome('001');
+
+      expect(outcome).toContain('<promise>FAILED</promise>');
+    });
+
+    it('should include stash name when provided', () => {
+      const outcome = generateFailedOutcome('001', 2, '3m', 'raf-001-task-001-failed');
+
+      expect(outcome).toContain('Stash: raf-001-task-001-failed');
+    });
+  });
+});
+
+describe('Retry History Console Output', () => {
+  describe('formatRetryHistoryForConsole', () => {
+    it('should return empty string when no failures', () => {
+      const result = formatRetryHistoryForConsole('001', 'my-task', [], 1, true);
+      expect(result).toBe('');
+    });
+
+    it('should format single failure with eventual success', () => {
+      const failureHistory = [{ attempt: 1, reason: 'Connection timeout' }];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 2, true);
+
+      expect(result).toContain('Task 001 (my-task):');
+      expect(result).toContain('Attempt 1: Failed - Connection timeout');
+      expect(result).toContain('Attempt 2: Succeeded');
+    });
+
+    it('should format multiple failures with eventual success', () => {
+      const failureHistory = [
+        { attempt: 1, reason: 'Connection timeout' },
+        { attempt: 2, reason: 'API error' },
+      ];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 3, true);
+
+      expect(result).toContain('Task 001 (my-task):');
+      expect(result).toContain('Attempt 1: Failed - Connection timeout');
+      expect(result).toContain('Attempt 2: Failed - API error');
+      expect(result).toContain('Attempt 3: Succeeded');
+    });
+
+    it('should format failures without success (final failure)', () => {
+      const failureHistory = [
+        { attempt: 1, reason: 'Connection timeout' },
+        { attempt: 2, reason: 'API error' },
+        { attempt: 3, reason: 'Max retries exceeded' },
+      ];
+      const result = formatRetryHistoryForConsole('001', 'my-task', failureHistory, 3, false);
+
+      expect(result).toContain('Task 001 (my-task):');
+      expect(result).toContain('Attempt 1: Failed - Connection timeout');
+      expect(result).toContain('Attempt 2: Failed - API error');
+      expect(result).toContain('Attempt 3: Failed - Max retries exceeded');
+      expect(result).not.toContain('Succeeded');
+    });
+
+    it('should handle task name same as task id', () => {
+      const failureHistory = [{ attempt: 1, reason: 'Error' }];
+      const result = formatRetryHistoryForConsole('001', '001', failureHistory, 2, true);
+
+      // When taskName equals taskId, should just show taskId
+      expect(result).toContain('Task 001:');
+      expect(result).not.toContain('Task 001 (001):');
+    });
+  });
+});