rafcode 1.0.0

package/src/utils/status-line.ts

@@ -0,0 +1,45 @@
+/**
+ * Status line utility for displaying in-place updates during task execution.
+ * Uses carriage return to update the line without scrolling.
+ */
+
+export interface StatusLine {
+  update: (text: string) => void;
+  clear: () => void;
+}
+
+/**
+ * Creates a status line that can be updated in-place.
+ * The status line is cleared before any new content is written.
+ */
+export function createStatusLine(): StatusLine {
+  let lastLength = 0;
+  let isActive = false;
+
+  return {
+    update(text: string): void {
+      // Only write to TTY
+      if (!process.stdout.isTTY) {
+        return;
+      }
+
+      isActive = true;
+      // Clear the previous line content and write new content
+      const clearStr = ' '.repeat(lastLength);
+      process.stdout.write(`\r${clearStr}\r${text}`);
+      lastLength = text.length;
+    },
+
+    clear(): void {
+      if (!process.stdout.isTTY || !isActive) {
+        return;
+      }
+
+      // Clear the line and reset cursor
+      const clearStr = ' '.repeat(lastLength);
+      process.stdout.write(`\r${clearStr}\r`);
+      lastLength = 0;
+      isActive = false;
+    },
+  };
+}

package/src/utils/terminal-symbols.ts

@@ -0,0 +1,124 @@
+/**
+ * Terminal symbols and formatting helpers for beautiful terminal output.
+ * All functions are pure and testable - no side effects.
+ */
+
+import { formatElapsedTime } from './timer.js';
+
+/**
+ * Visual symbols for terminal output using dots/symbols style.
+ */
+export const SYMBOLS = {
+  running: '●',
+  completed: '✓',
+  failed: '✗',
+  pending: '○',
+  blocked: '⊘',
+  project: '▶',
+} as const;
+
+export type TaskStatus = 'running' | 'completed' | 'failed' | 'pending' | 'blocked';
+
+/**
+ * Truncates a string to the specified length, adding ellipsis if needed.
+ */
+function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) {
+    return str;
+  }
+  return str.slice(0, maxLength - 1) + '…';
+}
+
+/**
+ * Formats a single task progress line.
+ * @param current - Current task number (1-indexed)
+ * @param total - Total number of tasks
+ * @param status - Task status
+ * @param name - Task name
+ * @param elapsedMs - Optional elapsed time in milliseconds
+ * @returns Formatted string like "● auth-login 1:23" or "✓ auth-login 1/5"
+ */
+export function formatTaskProgress(
+  current: number,
+  total: number,
+  status: TaskStatus,
+  name: string,
+  elapsedMs?: number
+): string {
+  const symbol = SYMBOLS[status];
+  const displayName = truncate(name || 'task', 40);
+
+  // Show elapsed time for running tasks, completed tasks, and failed tasks
+  if (elapsedMs !== undefined) {
+    const timeStr = formatElapsedTime(elapsedMs);
+    return `${symbol} ${displayName} ${timeStr}`;
+  }
+
+  return `${symbol} ${displayName} ${current}/${total}`;
+}
+
+/**
+ * Formats a project header line.
+ * @param name - Project name
+ * @param taskCount - Number of tasks in the project
+ * @returns Formatted string like "▶ my-project (5 tasks)"
+ */
+export function formatProjectHeader(name: string, taskCount: number): string {
+  const displayName = truncate(name || 'project', 50);
+  const taskWord = taskCount === 1 ? 'task' : 'tasks';
+  return `${SYMBOLS.project} ${displayName} (${taskCount} ${taskWord})`;
+}
+
+/**
+ * Formats a summary line showing completion status.
+ * @param completed - Number of completed tasks
+ * @param failed - Number of failed tasks
+ * @param pending - Number of pending tasks
+ * @param elapsedMs - Optional total elapsed time in milliseconds
+ * @param blocked - Number of blocked tasks (default 0)
+ * @returns Formatted string like "✓ 5/5 completed in 12:34" or "✗ 3/5 (2 failed, 1 blocked)"
+ */
+export function formatSummary(
+  completed: number,
+  failed: number,
+  pending: number,
+  elapsedMs?: number,
+  blocked: number = 0
+): string {
+  const total = completed + failed + pending + blocked;
+
+  if (total === 0) {
+    return `${SYMBOLS.pending} no tasks`;
+  }
+
+  const hasFailures = failed > 0;
+  const hasBlocked = blocked > 0;
+  const symbol = hasFailures || hasBlocked ? SYMBOLS.failed : SYMBOLS.completed;
+
+  if (hasFailures || hasBlocked) {
+    const parts: string[] = [];
+    if (hasFailures) {
+      parts.push(failed === 1 ? '1 failed' : `${failed} failed`);
+    }
+    if (hasBlocked) {
+      parts.push(blocked === 1 ? '1 blocked' : `${blocked} blocked`);
+    }
+    return `${symbol} ${completed}/${total} (${parts.join(', ')})`;
+  }
+
+  const timeStr = elapsedMs !== undefined ? ` in ${formatElapsedTime(elapsedMs)}` : '';
+  return `${symbol} ${completed}/${total} completed${timeStr}`;
+}
+
+/**
+ * Formats a compact progress bar showing task status as a sequence of symbols.
+ * @param tasks - Array of task statuses
+ * @returns Formatted string like "✓✓●○○"
+ */
+export function formatProgressBar(tasks: TaskStatus[]): string {
+  if (tasks.length === 0) {
+    return '';
+  }
+
+  return tasks.map((status) => SYMBOLS[status]).join('');
+}

package/src/utils/timer.ts

@@ -0,0 +1,64 @@
+/**
+ * Format elapsed time in human-readable format.
+ * - Under 1 minute: "Xs"
+ * - Under 1 hour: "Xm Ys"
+ * - 1 hour or more: "Xh Ym"
+ */
+export function formatElapsedTime(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  } else {
+    return `${seconds}s`;
+  }
+}
+
+export interface TaskTimer {
+  start: () => void;
+  stop: () => number;
+  getElapsed: () => number;
+}
+
+/**
+ * Creates a task timer that tracks elapsed time and can display a status line.
+ */
+export function createTaskTimer(onTick?: (elapsed: number) => void): TaskTimer {
+  let startTime: number | null = null;
+  let intervalId: ReturnType<typeof setInterval> | null = null;
+
+  return {
+    start(): void {
+      startTime = Date.now();
+      if (onTick) {
+        // Immediately show initial state
+        onTick(0);
+        // Then update every second
+        intervalId = setInterval(() => {
+          if (startTime !== null) {
+            onTick(Date.now() - startTime);
+          }
+        }, 1000);
+      }
+    },
+
+    stop(): number {
+      if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      const elapsed = startTime !== null ? Date.now() - startTime : 0;
+      startTime = null;
+      return elapsed;
+    },
+
+    getElapsed(): number {
+      return startTime !== null ? Date.now() - startTime : 0;
+    },
+  };
+}

package/src/utils/validation.ts

@@ -0,0 +1,132 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+import { logger } from './logger.js';
+
+export interface ValidationResult {
+  valid: boolean;
+  warnings: string[];
+  errors: string[];
+}
+
+export function validateEnvironment(): ValidationResult {
+  const result: ValidationResult = {
+    valid: true,
+    warnings: [],
+    errors: [],
+  };
+
+  // Check Claude CLI is installed
+  try {
+    execSync('which claude', { encoding: 'utf-8', stdio: 'pipe' });
+  } catch {
+    result.valid = false;
+    result.errors.push('Claude CLI not found. Please install it first.');
+  }
+
+  // Check for git repo (warning only)
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { encoding: 'utf-8', stdio: 'pipe' });
+  } catch {
+    result.warnings.push('Not in a git repository. Auto-commit will be disabled.');
+  }
+
+  // Check for CLAUDE.md (warning only)
+  if (!fs.existsSync('CLAUDE.md')) {
+    result.warnings.push('No CLAUDE.md found in current directory.');
+  }
+
+  return result;
+}
+
+export function validateProjectName(name: string): boolean {
+  // Allow alphanumeric, hyphens, underscores
+  const validPattern = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+  return validPattern.test(name) && name.length <= 50;
+}
+
+export function sanitizeProjectName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .substring(0, 50);
+}
+
+export function validateProjectExists(rafDir: string, projectName: string): string | null {
+  const entries = fs.readdirSync(rafDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      // Match numeric pattern like "001-project-name" (or legacy 01-project-name)
+      const numericMatch = entry.name.match(/^\d{2,3}-(.+)$/);
+      if (numericMatch && numericMatch[1] === projectName) {
+        return path.join(rafDir, entry.name);
+      }
+
+      // Match base36 pattern like "a00-project-name"
+      const base36Match = entry.name.match(/^[a-z][0-9a-z]{2}-(.+)$/i);
+      if (base36Match && base36Match[1] === projectName) {
+        return path.join(rafDir, entry.name);
+      }
+    }
+  }
+
+  return null;
+}
+
+export function validatePlansExist(projectPath: string): boolean {
+  const plansDir = path.join(projectPath, 'plans');
+  if (!fs.existsSync(plansDir)) {
+    return false;
+  }
+
+  const plans = fs.readdirSync(plansDir).filter(f => f.endsWith('.md'));
+  return plans.length > 0;
+}
+
+export function reportValidation(result: ValidationResult): void {
+  for (const warning of result.warnings) {
+    logger.warn(warning);
+  }
+
+  for (const error of result.errors) {
+    logger.error(error);
+  }
+}
+
+const VALID_MODELS = ['sonnet', 'haiku', 'opus'] as const;
+
+export type ValidModelName = (typeof VALID_MODELS)[number];
+
+export function validateModelName(model: string): ValidModelName | null {
+  const normalized = model.toLowerCase();
+  if (VALID_MODELS.includes(normalized as ValidModelName)) {
+    return normalized as ValidModelName;
+  }
+  return null;
+}
+
+export function resolveModelOption(model?: string, sonnet?: boolean): ValidModelName {
+  // Check for conflicting flags
+  if (model && sonnet) {
+    throw new Error('Cannot specify both --model and --sonnet flags');
+  }
+
+  // --sonnet shorthand
+  if (sonnet) {
+    return 'sonnet';
+  }
+
+  // --model flag
+  if (model) {
+    const validated = validateModelName(model);
+    if (!validated) {
+      throw new Error(`Invalid model name: "${model}". Valid options: ${VALID_MODELS.join(', ')}`);
+    }
+    return validated;
+  }
+
+  // Default to opus
+  return 'opus';
+}

package/src/utils/version.ts

@@ -0,0 +1,12 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+export function getVersion(): string {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  // From dist/utils/version.js to package.json is ../../package.json
+  const packagePath = join(__dirname, '..', '..', 'package.json');
+  const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+  return packageJson.version;
+}