rafcode 1.0.0 → 1.1.0

package/src/ui/name-picker.ts

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as pty from 'node-pty';
+import type { IDisposable } from 'node-pty';
 
 // For testing: allow direct import of @inquirer/prompts functions
 let directSelect: typeof import('@inquirer/prompts').select | null = null;
@@ -74,12 +75,33 @@ export async function pickProjectName(names: string[]): Promise<string> {
     };
     process.stdin.on('data', onData);
 
+    // Store disposables for proper cleanup
+    const disposables: IDisposable[] = [];
+
+    // Helper to clean up PTY resources
+    const cleanupPty = (): void => {
+      // Dispose all event listeners to prevent FD leaks
+      for (const disposable of disposables) {
+        try {
+          disposable.dispose();
+        } catch {
+          // Ignore disposal errors
+        }
+      }
+      // Ensure PTY is fully cleaned up
+      try {
+        ptyProcess.kill();
+      } catch {
+        // Ignore - process may already be dead
+      }
+    };
+
     // Forward output from PTY to our stdout
-    ptyProcess.onData((data) => {
+    disposables.push(ptyProcess.onData((data) => {
       process.stdout.write(data);
-    });
+    }));
 
-    ptyProcess.onExit(({ exitCode }) => {
+    disposables.push(ptyProcess.onExit(({ exitCode }) => {
       // Cleanup stdin
       process.stdin.off('data', onData);
       if (process.stdin.isTTY) {
@@ -87,6 +109,9 @@ export async function pickProjectName(names: string[]): Promise<string> {
       }
       process.stdin.pause();
 
+      // Clean up PTY resources
+      cleanupPty();
+
       if (exitCode === 130) {
         // SIGINT - user cancelled
         process.exit(130);
@@ -130,7 +155,7 @@ export async function pickProjectName(names: string[]): Promise<string> {
       } catch (error) {
         reject(error);
       }
-    });
+    }));
   });
 }
 

package/tests/manual/test-pty-cleanup.ts

@@ -0,0 +1,86 @@
+import * as pty from 'node-pty';
+import type { IDisposable } from 'node-pty';
+import { execSync } from 'node:child_process';
+
+function getPtyCount(): number {
+  // Count open file descriptors for this process
+  try {
+    const result = execSync(`lsof -p ${process.pid} 2>/dev/null | grep -c "/dev/pty\\|/dev/ttys" || echo 0`, { encoding: 'utf-8' });
+    return parseInt(result.trim(), 10);
+  } catch {
+    return 0;
+  }
+}
+
+async function spawnAndCleanup(withCleanup: boolean): Promise<void> {
+  return new Promise((resolve) => {
+    const ptyProcess = pty.spawn('echo', ['hello'], {
+      name: 'xterm-256color',
+      cols: 80,
+      rows: 24,
+    });
+
+    const disposables: IDisposable[] = [];
+
+    disposables.push(ptyProcess.onData(() => {
+      // ignore data
+    }));
+
+    disposables.push(ptyProcess.onExit(() => {
+      if (withCleanup) {
+        // Proper cleanup
+        for (const d of disposables) {
+          try { d.dispose(); } catch {}
+        }
+        try { ptyProcess.kill(); } catch {}
+      }
+      resolve();
+    }));
+  });
+}
+
+async function main() {
+  const iterations = 20;
+
+  console.log('Testing PTY cleanup...\n');
+
+  // Test WITHOUT cleanup
+  console.log('=== Without proper cleanup ===');
+  const beforeNoCleanup = getPtyCount();
+  console.log(`PTY FDs before: ${beforeNoCleanup}`);
+
+  for (let i = 0; i < iterations; i++) {
+    await spawnAndCleanup(false);
+  }
+
+  // Give time for any cleanup
+  await new Promise(r => setTimeout(r, 500));
+  const afterNoCleanup = getPtyCount();
+  console.log(`PTY FDs after ${iterations} spawns: ${afterNoCleanup}`);
+  console.log(`Leaked: ${afterNoCleanup - beforeNoCleanup}\n`);
+
+  // Test WITH cleanup
+  console.log('=== With proper cleanup ===');
+  const beforeCleanup = getPtyCount();
+  console.log(`PTY FDs before: ${beforeCleanup}`);
+
+  for (let i = 0; i < iterations; i++) {
+    await spawnAndCleanup(true);
+  }
+
+  // Give time for any cleanup
+  await new Promise(r => setTimeout(r, 500));
+  const afterCleanup = getPtyCount();
+  console.log(`PTY FDs after ${iterations} spawns: ${afterCleanup}`);
+  console.log(`Leaked: ${afterCleanup - beforeCleanup}\n`);
+
+  // Summary
+  console.log('=== Summary ===');
+  if (afterCleanup - beforeCleanup === 0) {
+    console.log('✓ Proper cleanup prevents PTY leaks');
+  } else {
+    console.log('✗ Still leaking PTYs even with cleanup');
+  }
+}
+
+main().catch(console.error);

package/tests/unit/commit-planning-artifacts.test.ts

@@ -0,0 +1,232 @@
+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
+const mockLogger = {
+  debug: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+};
+jest.unstable_mockModule('../../src/utils/logger.js', () => ({
+  logger: mockLogger,
+}));
+
+// Import after mocking
+const { commitPlanningArtifacts } = await import('../../src/core/git.js');
+
+describe('commitPlanningArtifacts', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should commit input.md and decisions.md with correct message format', async () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('git add')) {
+        return '';
+      }
+      if (cmdStr.includes('git diff --cached')) {
+        return 'RAF/017-decision-vault/input.md\nRAF/017-decision-vault/decisions.md\n';
+      }
+      if (cmdStr.includes('git commit')) {
+        return '';
+      }
+      return '';
+    });
+
+    await commitPlanningArtifacts('/Users/test/RAF/017-decision-vault');
+
+    // Verify git add was called with both files
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringContaining('git add'),
+      expect.any(Object)
+    );
+    const addCall = mockExecSync.mock.calls.find(
+      (call) => (call[0] as string).includes('git add')
+    );
+    expect(addCall?.[0]).toContain('input.md');
+    expect(addCall?.[0]).toContain('decisions.md');
+
+    // Verify commit message format
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringMatching(/git commit -m "RAF\[017\] Plan: decision-vault"/),
+      expect.any(Object)
+    );
+  });
+
+  it('should handle base36 project numbers', async () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('git add') || cmdStr.includes('git commit')) {
+        return '';
+      }
+      if (cmdStr.includes('git diff --cached')) {
+        return 'RAF/a01-feature/input.md\n';
+      }
+      return '';
+    });
+
+    await commitPlanningArtifacts('/Users/test/RAF/a01-my-feature');
+
+    expect(mockExecSync).toHaveBeenCalledWith(
+      expect.stringMatching(/git commit -m "RAF\[a01\] Plan: my-feature"/),
+      expect.any(Object)
+    );
+  });
+
+  it('should warn and return when not in git repository', async () => {
+    mockExecSync.mockImplementation(() => {
+      throw new Error('not a git repository');
+    });
+
+    await commitPlanningArtifacts('/Users/test/RAF/017-decision-vault');
+
+    expect(mockLogger.warn).toHaveBeenCalledWith(
+      'Not in a git repository, skipping planning artifacts commit'
+    );
+  });
+
+  it('should warn when project number cannot be extracted', async () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      return '';
+    });
+
+    await commitPlanningArtifacts('/Users/test/RAF/invalid-project');
+
+    expect(mockLogger.warn).toHaveBeenCalledWith(
+      'Could not extract project number or name from path, skipping commit'
+    );
+  });
+
+  it('should handle "nothing to commit" gracefully', async () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('git add')) {
+        return '';
+      }
+      if (cmdStr.includes('git diff --cached')) {
+        return ''; // No staged changes
+      }
+      return '';
+    });
+
+    await commitPlanningArtifacts('/Users/test/RAF/017-decision-vault');
+
+    // Should log debug message and not throw
+    expect(mockLogger.debug).toHaveBeenCalledWith(
+      'No changes to planning artifacts to commit'
+    );
+    expect(mockLogger.warn).not.toHaveBeenCalled();
+  });
+
+  it('should handle commit error with "nothing to commit" message', async () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('git add')) {
+        return '';
+      }
+      if (cmdStr.includes('git diff --cached')) {
+        return 'RAF/017-decision-vault/input.md\n';
+      }
+      if (cmdStr.includes('git commit')) {
+        throw new Error('nothing to commit, working tree clean');
+      }
+      return '';
+    });
+
+    await commitPlanningArtifacts('/Users/test/RAF/017-decision-vault');
+
+    // Should log debug message for "nothing to commit"
+    expect(mockLogger.debug).toHaveBeenCalledWith(
+      'Planning artifacts already committed or no changes'
+    );
+    expect(mockLogger.warn).not.toHaveBeenCalled();
+  });
+
+  it('should warn on other git errors without throwing', async () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('git add')) {
+        return '';
+      }
+      if (cmdStr.includes('git diff --cached')) {
+        return 'RAF/017-decision-vault/input.md\n';
+      }
+      if (cmdStr.includes('git commit')) {
+        throw new Error('commit failed for unknown reason');
+      }
+      return '';
+    });
+
+    // Should not throw
+    await expect(
+      commitPlanningArtifacts('/Users/test/RAF/017-decision-vault')
+    ).resolves.toBeUndefined();
+
+    // Should log warning
+    expect(mockLogger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('Failed to commit planning artifacts')
+    );
+  });
+
+  it('should only stage input.md and decisions.md', async () => {
+    mockExecSync.mockImplementation((cmd: unknown) => {
+      const cmdStr = cmd as string;
+      if (cmdStr.includes('rev-parse')) {
+        return 'true\n';
+      }
+      if (cmdStr.includes('git add')) {
+        return '';
+      }
+      if (cmdStr.includes('git diff --cached')) {
+        return 'RAF/017-decision-vault/input.md\n';
+      }
+      if (cmdStr.includes('git commit')) {
+        return '';
+      }
+      return '';
+    });
+
+    await commitPlanningArtifacts('/Users/test/RAF/017-decision-vault');
+
+    // Verify git add was called with explicit file paths
+    const addCall = mockExecSync.mock.calls.find(
+      (call) => (call[0] as string).includes('git add')
+    );
+    expect(addCall).toBeDefined();
+    const addCmd = addCall?.[0] as string;
+
+    // Should contain explicit file paths
+    expect(addCmd).toContain('/Users/test/RAF/017-decision-vault/input.md');
+    expect(addCmd).toContain('/Users/test/RAF/017-decision-vault/decisions.md');
+
+    // Should NOT use wildcards or add all
+    expect(addCmd).not.toContain('-A');
+    expect(addCmd).not.toContain('--all');
+    expect(addCmd).not.toContain('*');
+  });
+});