rafcode 1.0.0

package/src/ui/name-picker-subprocess.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * Subprocess script for running the name picker.
+ * This isolates @inquirer/prompts from the main process to prevent
+ * stdin corruption that affects subsequent node-pty usage.
+ *
+ * Usage: node name-picker-subprocess.js <json-encoded-names-array> <output-file>
+ * Output: Selected name written to output file
+ */
+
+import { select, input } from '@inquirer/prompts';
+import * as fs from 'node:fs';
+
+const OTHER_OPTION_VALUE = '__OTHER__';
+
+async function main(): Promise<void> {
+  // Get names from command line argument
+  const namesJson = process.argv[2];
+  const outputFile = process.argv[3];
+
+  if (!namesJson || !outputFile) {
+    console.error('Usage: name-picker-subprocess <json-encoded-names-array> <output-file>');
+    process.exit(1);
+  }
+
+  let names: string[];
+  try {
+    names = JSON.parse(namesJson);
+  } catch {
+    console.error('Invalid JSON input');
+    process.exit(1);
+  }
+
+  const result = await pickProjectName(names);
+
+  // Write result to output file
+  fs.writeFileSync(outputFile, result, 'utf-8');
+}
+
+async function pickProjectName(names: string[]): Promise<string> {
+  if (names.length === 0) {
+    return promptForCustomName();
+  }
+
+  const choices = [
+    ...names.map((name) => ({
+      name: name,
+      value: name,
+    })),
+    {
+      name: 'Other (enter custom name)',
+      value: OTHER_OPTION_VALUE,
+    },
+  ];
+
+  const selected = await select({
+    message: 'Select a project name:',
+    choices,
+  });
+
+  if (selected === OTHER_OPTION_VALUE) {
+    return promptForCustomName();
+  }
+
+  return selected;
+}
+
+async function promptForCustomName(): Promise<string> {
+  const customName = await input({
+    message: 'Enter project name:',
+    validate: (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) {
+        return 'Project name cannot be empty';
+      }
+      if (trimmed.length > 50) {
+        return 'Project name must be 50 characters or less';
+      }
+      if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(trimmed)) {
+        return 'Project name can only contain letters, numbers, hyphens, and underscores';
+      }
+      return true;
+    },
+  });
+
+  return customName.trim().toLowerCase();
+}
+
+main().catch((error) => {
+  // Check if user cancelled with Ctrl+C
+  if (error.message?.includes('User force closed') || error.name === 'ExitPromptError') {
+    process.exit(130); // Standard SIGINT exit code
+  }
+  console.error('Error:', error.message);
+  process.exit(1);
+});

package/src/ui/name-picker.ts

@@ -0,0 +1,198 @@
+import { fileURLToPath } from 'node:url';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as pty from 'node-pty';
+
+// For testing: allow direct import of @inquirer/prompts functions
+let directSelect: typeof import('@inquirer/prompts').select | null = null;
+let directInput: typeof import('@inquirer/prompts').input | null = null;
+
+const OTHER_OPTION_VALUE = '__OTHER__';
+
+/**
+ * Enable direct mode for testing (bypasses subprocess).
+ * This should only be called in test setup.
+ */
+export async function enableDirectMode(): Promise<void> {
+  const inquirer = await import('@inquirer/prompts');
+  directSelect = inquirer.select;
+  directInput = inquirer.input;
+}
+
+/**
+ * Disable direct mode (use subprocess).
+ */
+export function disableDirectMode(): void {
+  directSelect = null;
+  directInput = null;
+}
+
+/**
+ * Display an interactive name picker with arrow-key navigation.
+ * Runs in a PTY subprocess to completely isolate @inquirer/prompts
+ * stdin manipulation from the main process.
+ *
+ * @param names - Array of generated name suggestions (3-5 names)
+ * @returns The selected or custom project name
+ */
+export async function pickProjectName(names: string[]): Promise<string> {
+  // Use direct mode if enabled (for testing)
+  if (directSelect) {
+    return pickProjectNameDirect(names);
+  }
+
+  // Get path to the subprocess script
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = path.dirname(currentFile);
+
+  // Use the compiled js file
+  const subprocessScript = path.join(currentDir, 'name-picker-subprocess.js');
+
+  // Create temp file for result
+  const tempFile = path.join(os.tmpdir(), `raf-name-picker-${process.pid}.txt`);
+
+  return new Promise((resolve, reject) => {
+    // Spawn subprocess in its own PTY (completely isolates stdin)
+    const ptyProcess = pty.spawn('node', [subprocessScript, JSON.stringify(names), tempFile], {
+      name: 'xterm-256color',
+      cols: process.stdout.columns ?? 80,
+      rows: process.stdout.rows ?? 24,
+      cwd: process.cwd(),
+      env: process.env as Record<string, string>,
+    });
+
+    // Set raw mode on our stdin to pass through keypresses
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+
+    // Forward input from our stdin to the PTY
+    const onData = (data: Buffer): void => {
+      ptyProcess.write(data.toString());
+    };
+    process.stdin.on('data', onData);
+
+    // Forward output from PTY to our stdout
+    ptyProcess.onData((data) => {
+      process.stdout.write(data);
+    });
+
+    ptyProcess.onExit(({ exitCode }) => {
+      // Cleanup stdin
+      process.stdin.off('data', onData);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      process.stdin.pause();
+
+      if (exitCode === 130) {
+        // SIGINT - user cancelled
+        process.exit(130);
+      }
+
+      if (exitCode !== 0) {
+        // Clean up temp file
+        try {
+          if (fs.existsSync(tempFile)) {
+            fs.unlinkSync(tempFile);
+          }
+        } catch {
+          // Ignore
+        }
+        reject(new Error(`Name picker subprocess failed with code ${exitCode}`));
+        return;
+      }
+
+      // Read the result from temp file
+      try {
+        if (!fs.existsSync(tempFile)) {
+          reject(new Error('Name picker did not write a selection'));
+          return;
+        }
+
+        const selectedName = fs.readFileSync(tempFile, 'utf-8').trim();
+
+        // Clean up temp file
+        try {
+          fs.unlinkSync(tempFile);
+        } catch {
+          // Ignore
+        }
+
+        if (!selectedName) {
+          reject(new Error('Name picker returned empty selection'));
+          return;
+        }
+
+        resolve(selectedName);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+
+/**
+ * Direct implementation for testing (uses @inquirer/prompts in-process).
+ */
+async function pickProjectNameDirect(names: string[]): Promise<string> {
+  if (!directSelect || !directInput) {
+    throw new Error('Direct mode not enabled');
+  }
+
+  if (names.length === 0) {
+    return promptForCustomNameDirect();
+  }
+
+  const choices = [
+    ...names.map((name) => ({
+      name: name,
+      value: name,
+    })),
+    {
+      name: 'Other (enter custom name)',
+      value: OTHER_OPTION_VALUE,
+    },
+  ];
+
+  const selected = await directSelect({
+    message: 'Select a project name:',
+    choices,
+  });
+
+  if (selected === OTHER_OPTION_VALUE) {
+    return promptForCustomNameDirect();
+  }
+
+  return selected;
+}
+
+/**
+ * Prompt user to enter a custom project name (direct mode).
+ */
+async function promptForCustomNameDirect(): Promise<string> {
+  if (!directInput) {
+    throw new Error('Direct mode not enabled');
+  }
+
+  const customName = await directInput({
+    message: 'Enter project name:',
+    validate: (value) => {
+      const trimmed = value.trim();
+      if (!trimmed) {
+        return 'Project name cannot be empty';
+      }
+      if (trimmed.length > 50) {
+        return 'Project name must be 50 characters or less';
+      }
+      if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(trimmed)) {
+        return 'Project name can only contain letters, numbers, hyphens, and underscores';
+      }
+      return true;
+    },
+  });
+
+  return customName.trim().toLowerCase();
+}

package/src/ui/project-picker.ts

@@ -0,0 +1,80 @@
+import { select } from '@inquirer/prompts';
+import { discoverProjects, deriveProjectState, getDerivedStats } from '../core/state-derivation.js';
+import { extractProjectNumber, formatProjectNumber } from '../utils/paths.js';
+
+/**
+ * Information about a pending project for display in the picker.
+ */
+export interface PendingProjectInfo {
+  folder: string;
+  number: number;
+  name: string;
+  path: string;
+  completedTasks: number;
+  totalTasks: number;
+}
+
+/**
+ * Get all projects that have pending tasks (not fully completed).
+ * Returns projects sorted by number (oldest first).
+ */
+export function getPendingProjects(rafDir: string): PendingProjectInfo[] {
+  const allProjects = discoverProjects(rafDir);
+  const pendingProjects: PendingProjectInfo[] = [];
+
+  for (const project of allProjects) {
+    const state = deriveProjectState(project.path);
+    const stats = getDerivedStats(state);
+
+    // Include projects that are not fully completed (have pending or failed tasks)
+    if (stats.pending > 0 || stats.failed > 0) {
+      const projectNumber = extractProjectNumber(project.path);
+      const formattedNumber = projectNumber ?? formatProjectNumber(project.number);
+
+      pendingProjects.push({
+        folder: `${formattedNumber}-${project.name}`,
+        number: project.number,
+        name: project.name,
+        path: project.path,
+        completedTasks: stats.completed,
+        totalTasks: stats.total,
+      });
+    }
+  }
+
+  // Sort by number (already sorted by discoverProjects, but ensure it)
+  return pendingProjects.sort((a, b) => a.number - b.number);
+}
+
+/**
+ * Format a project for display in the picker.
+ * Example: "001 fix-auth-bug (2/5 tasks)"
+ */
+export function formatProjectChoice(project: PendingProjectInfo): string {
+  const projectNumber = extractProjectNumber(project.path) ?? formatProjectNumber(project.number);
+  return `${projectNumber} ${project.name} (${project.completedTasks}/${project.totalTasks} tasks)`;
+}
+
+/**
+ * Display an interactive project picker for pending projects.
+ * Returns the selected project folder name or null if no projects or cancelled.
+ */
+export async function pickPendingProject(rafDir: string): Promise<string | null> {
+  const pendingProjects = getPendingProjects(rafDir);
+
+  if (pendingProjects.length === 0) {
+    return null;
+  }
+
+  const choices = pendingProjects.map((project) => ({
+    name: formatProjectChoice(project),
+    value: project.folder,
+  }));
+
+  const selected = await select({
+    message: 'Select a project to execute:',
+    choices,
+  });
+
+  return selected;
+}

package/src/utils/config.ts

@@ -0,0 +1,69 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { RafConfig, DEFAULT_RAF_CONFIG } from '../types/config.js';
+
+const CONFIG_FILENAME = 'raf.config.json';
+
+/**
+ * Get the path to Claude CLI settings file.
+ */
+export function getClaudeSettingsPath(): string {
+  return path.join(os.homedir(), '.claude', 'settings.json');
+}
+
+export function loadConfig(rafDir: string): RafConfig {
+  const configPath = path.join(rafDir, CONFIG_FILENAME);
+
+  if (!fs.existsSync(configPath)) {
+    return { ...DEFAULT_RAF_CONFIG };
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const userConfig = JSON.parse(content) as Partial<RafConfig>;
+    return { ...DEFAULT_RAF_CONFIG, ...userConfig };
+  } catch {
+    return { ...DEFAULT_RAF_CONFIG };
+  }
+}
+
+export function saveConfig(rafDir: string, config: RafConfig): void {
+  const configPath = path.join(rafDir, CONFIG_FILENAME);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+export function getEditor(): string {
+  return process.env['EDITOR'] ?? process.env['VISUAL'] ?? 'vi';
+}
+
+/**
+ * Get the Claude model name from Claude CLI settings.
+ * Returns the model name or null if not found.
+ * @param settingsPath Optional path to settings file (for testing)
+ */
+export function getClaudeModel(settingsPath?: string): string | null {
+  const filePath = settingsPath ?? getClaudeSettingsPath();
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const settings = JSON.parse(content) as { model?: string };
+    return settings.model ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get runtime configuration for task execution.
+ * Returns default values which can be overridden by command line options.
+ */
+export function getConfig(): { timeout: number; maxRetries: number; autoCommit: boolean } {
+  return {
+    timeout: DEFAULT_RAF_CONFIG.defaultTimeout,
+    maxRetries: DEFAULT_RAF_CONFIG.defaultMaxRetries,
+    autoCommit: DEFAULT_RAF_CONFIG.autoCommit,
+  };
+}

package/src/utils/logger.ts

@@ -0,0 +1,81 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+interface LoggerOptions {
+  verbose?: boolean;
+  debug?: boolean;
+}
+
+class Logger {
+  private verbose = false;
+  private debugMode = false;
+
+  configure(options: LoggerOptions): void {
+    this.verbose = options.verbose ?? false;
+    this.debugMode = options.debug ?? false;
+  }
+
+  /**
+   * @deprecated No longer used - kept for backwards compatibility
+   */
+  setContext(_prefix: string): void {
+    // No-op: context prefix feature removed in favor of minimal output style
+  }
+
+  /**
+   * @deprecated No longer used - kept for backwards compatibility
+   */
+  clearContext(): void {
+    // No-op: context prefix feature removed in favor of minimal output style
+  }
+
+  private formatMessage(message: string): string {
+    return message;
+  }
+
+  debug(message: string, ...args: unknown[]): void {
+    if (this.debugMode) {
+      console.log(`[DEBUG] ${message}`, ...args);
+    }
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    console.log(this.formatMessage(message), ...args);
+  }
+
+  verbose_log(message: string, ...args: unknown[]): void {
+    if (this.verbose || this.debugMode) {
+      console.log(this.formatMessage(message), ...args);
+    }
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    console.warn(`⚠️  ${this.formatMessage(message)}`, ...args);
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    console.error(`✗ ${this.formatMessage(message)}`, ...args);
+  }
+
+  print(message: string, ...args: unknown[]): void {
+    console.log(message, ...args);
+  }
+
+  success(message: string, ...args: unknown[]): void {
+    console.log(`✓ ${this.formatMessage(message)}`, ...args);
+  }
+
+  task(status: string, name: string): void {
+    console.log(`${status} ${name}`);
+  }
+
+  newline(): void {
+    console.log();
+  }
+
+  dim(message: string, ...args: unknown[]): void {
+    // ANSI escape code for dim text
+    console.log(`\x1b[2m${this.formatMessage(message)}\x1b[0m`, ...args);
+  }
+}
+
+export const logger = new Logger();