rafcode 1.0.0

package/tests/unit/plan-command-amend-flag.test.ts

@@ -0,0 +1,115 @@
+import { createPlanCommand } from '../../src/commands/plan.js';
+
+describe('Plan Command - Amend Flag Position', () => {
+  describe('CLI option parsing', () => {
+    it('should accept --amend flag', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const amendOption = options.find(
+        (opt) => opt.long === '--amend' || opt.short === '-a'
+      );
+      expect(amendOption).toBeDefined();
+    });
+
+    it('should accept -a as shorthand for --amend', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const amendOption = options.find((opt) => opt.short === '-a');
+      expect(amendOption).toBeDefined();
+      expect(amendOption?.long).toBe('--amend');
+    });
+
+    it('should have description explaining what --amend does', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const amendOption = options.find((opt) => opt.long === '--amend');
+      expect(amendOption?.description).toContain('existing project');
+    });
+
+    it('should have --amend as boolean flag (no required argument)', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const amendOption = options.find((opt) => opt.long === '--amend');
+      // Boolean flags don't have required or optional args
+      expect(amendOption?.required).toBeFalsy();
+      expect(amendOption?.optional).toBeFalsy();
+    });
+  });
+
+  describe('positional argument usage', () => {
+    it('should have projectName as optional positional argument', () => {
+      const command = createPlanCommand();
+      // Commander stores arguments in _args array
+      const args = command.registeredArguments;
+
+      expect(args.length).toBeGreaterThanOrEqual(1);
+      expect(args[0].name()).toBe('projectName');
+      expect(args[0].required).toBe(false); // optional
+    });
+
+    it('should allow positional argument with --amend flag', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+      const args = command.registeredArguments;
+
+      // Both positional argument and --amend flag should be present
+      const amendOption = options.find((opt) => opt.long === '--amend');
+      expect(amendOption).toBeDefined();
+      expect(args.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('command syntax variants', () => {
+    // These tests verify that both syntaxes are structurally supported
+    // Note: Actual command execution is tested in integration tests
+
+    it('should support "raf plan myproject --amend" syntax structurally', () => {
+      const command = createPlanCommand();
+
+      // Verify both positional arg and boolean flag exist
+      const args = command.registeredArguments;
+      const options = command.options;
+      const amendOption = options.find((opt) => opt.long === '--amend');
+
+      // Positional argument for project name
+      expect(args[0].name()).toBe('projectName');
+      // Boolean flag (no required argument)
+      expect(amendOption?.required).toBeFalsy();
+    });
+
+    it('should support "raf plan --amend myproject" syntax structurally', () => {
+      const command = createPlanCommand();
+
+      // In Commander.js, --flag <arg> consumes the next argument
+      // With boolean flag, positional args are separate
+      const args = command.registeredArguments;
+      const options = command.options;
+      const amendOption = options.find((opt) => opt.long === '--amend');
+
+      // Boolean flag allows positional arg to be used separately
+      expect(amendOption?.required).toBeFalsy();
+      expect(amendOption?.optional).toBeFalsy();
+      expect(args[0].name()).toBe('projectName');
+    });
+  });
+
+  describe('flag type change verification', () => {
+    it('should not require an argument value for --amend', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+      const amendOption = options.find((opt) => opt.long === '--amend');
+
+      // Verify it's a boolean flag, not a value-taking option
+      // In Commander.js:
+      // - required: true means <value> is required
+      // - optional: true means [value] is optional
+      // - both false means boolean flag
+      expect(amendOption?.required).toBe(false);
+      expect(amendOption?.optional).toBe(false);
+    });
+  });
+});

package/tests/unit/plan-command-amend-input.test.ts

@@ -0,0 +1,156 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+describe('Plan Command - Amend Input.md Handling', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'raf-amend-input-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Input.md append behavior', () => {
+    it('should append new content with separator to existing input.md', () => {
+      const inputPath = path.join(tempDir, 'input.md');
+      const originalContent = 'Original project description.';
+      const newContent = 'Add new feature X.';
+
+      // Simulate existing input.md
+      fs.writeFileSync(inputPath, originalContent);
+
+      // Simulate the append logic from runAmendCommand
+      const separator = '\n\n---\n\n';
+      const updatedInput = originalContent.trim()
+        ? `${originalContent.trimEnd()}${separator}${newContent}`
+        : newContent;
+      fs.writeFileSync(inputPath, updatedInput);
+
+      // Verify result
+      const result = fs.readFileSync(inputPath, 'utf-8');
+      expect(result).toContain(originalContent);
+      expect(result).toContain('---');
+      expect(result).toContain(newContent);
+      expect(result).toBe(`${originalContent}${separator}${newContent}`);
+    });
+
+    it('should handle empty original input.md', () => {
+      const inputPath = path.join(tempDir, 'input.md');
+      const newContent = 'Add new feature X.';
+
+      // Simulate empty input.md
+      fs.writeFileSync(inputPath, '');
+
+      // Simulate the append logic from runAmendCommand
+      const originalContent = fs.readFileSync(inputPath, 'utf-8');
+      const separator = '\n\n---\n\n';
+      const updatedInput = originalContent.trim()
+        ? `${originalContent.trimEnd()}${separator}${newContent}`
+        : newContent;
+      fs.writeFileSync(inputPath, updatedInput);
+
+      // Verify result - no separator when original is empty
+      const result = fs.readFileSync(inputPath, 'utf-8');
+      expect(result).toBe(newContent);
+      expect(result).not.toContain('---');
+    });
+
+    it('should handle non-existent input.md', () => {
+      const inputPath = path.join(tempDir, 'input.md');
+      const newContent = 'Add new feature X.';
+
+      // Simulate the logic from runAmendCommand when input.md doesn't exist
+      const originalContent = fs.existsSync(inputPath)
+        ? fs.readFileSync(inputPath, 'utf-8')
+        : '';
+      const separator = '\n\n---\n\n';
+      const updatedInput = originalContent.trim()
+        ? `${originalContent.trimEnd()}${separator}${newContent}`
+        : newContent;
+      fs.writeFileSync(inputPath, updatedInput);
+
+      // Verify result - no separator when original is empty
+      const result = fs.readFileSync(inputPath, 'utf-8');
+      expect(result).toBe(newContent);
+    });
+
+    it('should handle multiple amend operations correctly', () => {
+      const inputPath = path.join(tempDir, 'input.md');
+      const original = 'First project description.';
+      const secondAmend = 'Add feature A.';
+      const thirdAmend = 'Add feature B.';
+      const separator = '\n\n---\n\n';
+
+      // First: write original content
+      fs.writeFileSync(inputPath, original);
+
+      // Second amend
+      let currentContent = fs.readFileSync(inputPath, 'utf-8');
+      let updatedInput = currentContent.trim()
+        ? `${currentContent.trimEnd()}${separator}${secondAmend}`
+        : secondAmend;
+      fs.writeFileSync(inputPath, updatedInput);
+
+      // Third amend
+      currentContent = fs.readFileSync(inputPath, 'utf-8');
+      updatedInput = currentContent.trim()
+        ? `${currentContent.trimEnd()}${separator}${thirdAmend}`
+        : thirdAmend;
+      fs.writeFileSync(inputPath, updatedInput);
+
+      // Verify result
+      const result = fs.readFileSync(inputPath, 'utf-8');
+      expect(result).toContain(original);
+      expect(result).toContain(secondAmend);
+      expect(result).toContain(thirdAmend);
+
+      // Should have two separators
+      const separatorCount = (result.match(/---/g) || []).length;
+      expect(separatorCount).toBe(2);
+    });
+
+    it('should preserve trailing whitespace correctly in original content', () => {
+      const inputPath = path.join(tempDir, 'input.md');
+      const originalWithWhitespace = 'Original content.\n\n\n';
+      const newContent = 'New content.';
+      const separator = '\n\n---\n\n';
+
+      fs.writeFileSync(inputPath, originalWithWhitespace);
+
+      // Simulate the append logic (trims end of original)
+      const originalContent = fs.readFileSync(inputPath, 'utf-8');
+      const updatedInput = originalContent.trim()
+        ? `${originalContent.trimEnd()}${separator}${newContent}`
+        : newContent;
+      fs.writeFileSync(inputPath, updatedInput);
+
+      // Verify - trailing whitespace should be trimmed
+      const result = fs.readFileSync(inputPath, 'utf-8');
+      expect(result).toBe(`Original content.${separator}${newContent}`);
+    });
+
+    it('should handle content with only whitespace', () => {
+      const inputPath = path.join(tempDir, 'input.md');
+      const whitespaceOnly = '   \n\n  ';
+      const newContent = 'New content.';
+      const separator = '\n\n---\n\n';
+
+      fs.writeFileSync(inputPath, whitespaceOnly);
+
+      // Simulate the append logic
+      const originalContent = fs.readFileSync(inputPath, 'utf-8');
+      const updatedInput = originalContent.trim()
+        ? `${originalContent.trimEnd()}${separator}${newContent}`
+        : newContent;
+      fs.writeFileSync(inputPath, updatedInput);
+
+      // Verify - whitespace-only content treated as empty
+      const result = fs.readFileSync(inputPath, 'utf-8');
+      expect(result).toBe(newContent);
+      expect(result).not.toContain('---');
+    });
+  });
+});

package/tests/unit/plan-command-auto-flag.test.ts

@@ -0,0 +1,112 @@
+import { createPlanCommand } from '../../src/commands/plan.js';
+
+describe('Plan Command - Auto Flag', () => {
+  describe('CLI option parsing', () => {
+    it('should accept --auto flag', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const autoOption = options.find(
+        (opt) => opt.long === '--auto' || opt.short === '-y'
+      );
+      expect(autoOption).toBeDefined();
+    });
+
+    it('should accept -y as shorthand for --auto', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const autoOption = options.find((opt) => opt.short === '-y');
+      expect(autoOption).toBeDefined();
+      expect(autoOption?.long).toBe('--auto');
+    });
+
+    it('should have description explaining what --auto does', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const autoOption = options.find((opt) => opt.long === '--auto');
+      expect(autoOption?.description).toContain('permission');
+    });
+
+    it('should have --auto as boolean flag (no required argument)', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const autoOption = options.find((opt) => opt.long === '--auto');
+      // Boolean flags don't have required or optional args
+      expect(autoOption?.required).toBeFalsy();
+      expect(autoOption?.optional).toBeFalsy();
+    });
+  });
+
+  describe('command options coexistence', () => {
+    it('should allow --auto with --amend', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const autoOption = options.find((opt) => opt.long === '--auto');
+      const amendOption = options.find((opt) => opt.long === '--amend');
+
+      expect(autoOption).toBeDefined();
+      expect(amendOption).toBeDefined();
+    });
+
+    it('should allow --auto with --model', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const autoOption = options.find((opt) => opt.long === '--auto');
+      const modelOption = options.find((opt) => opt.long === '--model');
+
+      expect(autoOption).toBeDefined();
+      expect(modelOption).toBeDefined();
+    });
+
+    it('should allow --auto with --sonnet', () => {
+      const command = createPlanCommand();
+      const options = command.options;
+
+      const autoOption = options.find((opt) => opt.long === '--auto');
+      const sonnetOption = options.find((opt) => opt.long === '--sonnet');
+
+      expect(autoOption).toBeDefined();
+      expect(sonnetOption).toBeDefined();
+    });
+  });
+
+  describe('auto-name selection behavior', () => {
+    it('should have behavior where first name is auto-selected in auto mode', () => {
+      // This test documents the expected behavior:
+      // When autoMode is true and no projectName is provided,
+      // the first name from generateProjectNames() should be used
+      // without calling pickProjectName()
+
+      // The actual behavior is tested implicitly by the implementation:
+      // - generateProjectNames() returns ['first-name', 'second-name', 'third-name']
+      // - In auto mode: finalProjectName = suggestedNames[0] // 'first-name'
+      // - In normal mode: finalProjectName = await pickProjectName(suggestedNames)
+
+      // This test validates the command structure supports this flow
+      const command = createPlanCommand();
+      const autoOption = command.options.find((opt) => opt.long === '--auto');
+
+      expect(autoOption).toBeDefined();
+      expect(autoOption?.short).toBe('-y');
+      // The argument is optional (user can omit project name for auto-selection)
+      const args = command.registeredArguments;
+      expect(args).toHaveLength(1);
+      expect(args[0].required).toBe(false);
+    });
+
+    it('should support projectName argument as optional', () => {
+      const command = createPlanCommand();
+
+      // The first argument is the optional projectName
+      const args = command.registeredArguments;
+      expect(args).toHaveLength(1);
+      expect(args[0].name()).toBe('projectName');
+      expect(args[0].required).toBe(false);
+    });
+  });
+});