speci 0.1.0

package/lib/commands/status.ts

@@ -0,0 +1,209 @@
+/**
+ * Status Command Implementation
+ *
+ * Displays current loop state, task statistics, and execution information.
+ * Read-only command for quick project progress snapshots.
+ */
+
+import { loadConfig } from '../config.js';
+import { getState, getTaskStats } from '../state.js';
+import { getLockInfo } from '../utils/lock.js';
+import { renderBanner } from '../ui/banner.js';
+import { colorize } from '../ui/colors.js';
+import { getGlyph } from '../ui/glyphs.js';
+import { drawBox } from '../ui/box.js';
+
+/**
+ * Status command options
+ */
+export interface StatusOptions {
+  json?: boolean;
+  verbose?: boolean;
+}
+
+/**
+ * Status data structure
+ */
+interface StatusData {
+  state: string;
+  stats: {
+    total: number;
+    completed: number;
+    pending: number;
+    inReview: number;
+    blocked: number;
+  };
+  lock: {
+    isLocked: boolean;
+    pid: number | null;
+    startTime: string | null;
+    elapsed: string | null;
+  };
+  lastActivity?: string;
+  error?: string;
+}
+
+/**
+ * Status command handler
+ * @param options - Command options
+ */
+export async function status(options: StatusOptions = {}): Promise<void> {
+  const startTime = Date.now();
+
+  // 1. Load configuration
+  const config = await loadConfig();
+
+  // 2. Gather data concurrently
+  const [state, rawStats, lockInfo] = await Promise.all([
+    getState(config),
+    getTaskStats(config),
+    getLockInfo(config),
+  ]);
+
+  // 3. Build status data
+  const statusData: StatusData = {
+    state: state,
+    stats: {
+      total: rawStats.total,
+      completed: rawStats.completed,
+      pending: rawStats.remaining,
+      inReview: rawStats.inReview,
+      blocked: rawStats.blocked,
+    },
+    lock: {
+      isLocked: lockInfo.locked,
+      pid: lockInfo.pid,
+      startTime: lockInfo.started ? formatTimestamp(lockInfo.started) : null,
+      elapsed: lockInfo.elapsed,
+    },
+  };
+
+  // 4. Output based on format
+  if (options.json) {
+    console.log(JSON.stringify(statusData, null, 2));
+  } else {
+    renderBanner({ showVersion: false });
+    renderStatusDisplay(statusData);
+  }
+
+  // 5. Performance check
+  const elapsed = Date.now() - startTime;
+  if (options.verbose) {
+    console.log(colorize(`Status command completed in ${elapsed}ms`, 'dim'));
+  }
+}
+
+/**
+ * Render styled status display
+ * @param data - Status data to display
+ */
+function renderStatusDisplay(data: StatusData): void {
+  // State header with semantic color
+  const stateColor = getStateColor(data.state);
+  const stateIcon = getStateIcon(data.state);
+
+  console.log();
+  console.log(
+    colorize(`${stateIcon} Current State: ${data.state}`, stateColor)
+  );
+  console.log();
+
+  // Task statistics box
+  const statsContent = [
+    `${getGlyph('success')} Completed:   ${data.stats.completed}/${data.stats.total}`,
+    `${getGlyph('arrow')} Pending:     ${data.stats.pending}`,
+    `${getGlyph('bullet')} In Review:   ${data.stats.inReview}`,
+    `${getGlyph('error')} Blocked:     ${data.stats.blocked}`,
+  ];
+
+  console.log(drawBox(statsContent, { title: 'Task Progress' }));
+
+  // Progress bar
+  renderProgressBar(data.stats.completed, data.stats.total);
+
+  // Lock status
+  if (data.lock.isLocked && data.lock.pid && data.lock.startTime) {
+    console.log();
+    console.log(
+      colorize(
+        `${getGlyph('bullet')} Speci run is active (PID: ${data.lock.pid})`,
+        'sky400'
+      )
+    );
+    console.log(colorize(`  Started: ${data.lock.startTime}`, 'dim'));
+    if (data.lock.elapsed) {
+      console.log(colorize(`  Elapsed: ${data.lock.elapsed}`, 'dim'));
+    }
+  }
+
+  console.log();
+}
+
+/**
+ * Get semantic color for state
+ * @param state - State string
+ * @returns Color name
+ */
+function getStateColor(
+  state: string
+): 'success' | 'sky400' | 'warning' | 'error' | 'dim' {
+  const colors: Record<
+    string,
+    'success' | 'sky400' | 'warning' | 'error' | 'dim'
+  > = {
+    DONE: 'success',
+    WORK_LEFT: 'sky400',
+    IN_REVIEW: 'warning',
+    BLOCKED: 'error',
+    NO_PROGRESS: 'dim',
+  };
+  return colors[state] || 'sky400';
+}
+
+/**
+ * Get icon for state
+ * @param state - State string
+ * @returns Glyph string
+ */
+function getStateIcon(state: string): string {
+  const icons: Record<string, string> = {
+    DONE: getGlyph('success') as string,
+    WORK_LEFT: getGlyph('arrow') as string,
+    IN_REVIEW: getGlyph('bullet') as string,
+    BLOCKED: getGlyph('error') as string,
+    NO_PROGRESS: getGlyph('warning') as string,
+  };
+  return icons[state] || (getGlyph('bullet') as string);
+}
+
+/**
+ * Render progress bar
+ * @param completed - Number of completed tasks
+ * @param total - Total number of tasks
+ */
+function renderProgressBar(completed: number, total: number): void {
+  const width = 40;
+  const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
+  const filled = total > 0 ? Math.round((completed / total) * width) : 0;
+  const empty = width - filled;
+
+  const bar =
+    colorize('█'.repeat(filled), 'success') +
+    colorize('░'.repeat(empty), 'dim');
+
+  console.log();
+  console.log(`  [${bar}] ${percentage}%`);
+}
+
+/**
+ * Format timestamp for display
+ * @param date - Date to format
+ * @returns Formatted timestamp string
+ */
+function formatTimestamp(date: Date): string {
+  const pad = (n: number) => n.toString().padStart(2, '0');
+  return (
+    `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
+    `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
+  );
+}

package/lib/commands/task.ts

@@ -0,0 +1,133 @@
+/**
+ * Task Command Module
+ *
+ * Invokes GitHub Copilot CLI in one-shot mode for task generation from a plan file.
+ * The command validates the plan file exists and is readable before invoking Copilot.
+ * Output streams to terminal in real-time using stdio: 'inherit'.
+ */
+
+import { existsSync, accessSync, constants } from 'node:fs';
+import { resolve } from 'node:path';
+import { loadConfig, resolveAgentPath } from '../config.js';
+import { buildCopilotArgs, spawnCopilot } from '../copilot.js';
+import { preflight } from '../utils/preflight.js';
+import { renderBanner } from '../ui/banner.js';
+import { log } from '../utils/logger.js';
+import { infoBox } from '../ui/box.js';
+
+/**
+ * Options for the task command
+ */
+export interface TaskOptions {
+  /** Required: path to plan file */
+  plan: string;
+  /** Custom agent path override */
+  agent?: string;
+  /** Show detailed output */
+  verbose?: boolean;
+}
+
+/**
+ * Validate that plan file exists and is readable
+ *
+ * @param planPath - Absolute path to plan file
+ * @throws Will exit process with code 1 if validation fails
+ */
+function validatePlanFile(planPath: string): void {
+  // Check existence
+  if (!existsSync(planPath)) {
+    log.error(`Plan file not found: ${planPath}`);
+    process.exit(1);
+  }
+
+  // Check readability
+  try {
+    accessSync(planPath, constants.R_OK);
+  } catch {
+    log.error(`Plan file not readable: ${planPath}`);
+    log.info('Check file permissions and try again.');
+    process.exit(1);
+  }
+}
+
+/**
+ * Task command handler
+ * Initializes one-shot Copilot session for task generation
+ *
+ * @param options - Command options
+ */
+export async function task(options: TaskOptions): Promise<void> {
+  try {
+    // Display banner
+    renderBanner();
+    console.log();
+
+    // Validate required option
+    if (!options.plan) {
+      log.error('Missing required option: --plan <path>');
+      log.info('Usage: speci task --plan <path-to-plan.md>');
+      process.exit(2);
+    }
+
+    // Resolve and validate plan file
+    const planPath = resolve(process.cwd(), options.plan);
+    validatePlanFile(planPath);
+
+    // Load configuration
+    const config = loadConfig();
+
+    // Run preflight checks
+    await preflight(config, {
+      requireCopilot: true,
+      requireConfig: true,
+      requireProgress: false,
+      requireGit: false,
+    });
+
+    // Resolve agent path (override or config)
+    const agentPath = options.agent
+      ? options.agent
+      : resolveAgentPath(config, 'task');
+
+    // Validate agent file exists
+    if (!existsSync(agentPath)) {
+      log.error(`Agent file not found: ${agentPath}`);
+      log.info('Check config.agents.task or provide --agent flag');
+      process.exit(1);
+    }
+
+    // Display command info
+    console.log(
+      infoBox('Task Generation', {
+        Plan: planPath,
+        Agent: agentPath,
+        Mode: 'One-shot',
+      })
+    );
+    console.log();
+
+    // Build Copilot args for one-shot mode with plan context
+    const args = buildCopilotArgs(config, {
+      interactive: false,
+      prompt: `Read the plan file at ${planPath} and generate implementation tasks.`,
+      agent: agentPath,
+      allowAll: true,
+    });
+
+    // Spawn Copilot with stdio:inherit
+    log.debug(`Spawning: copilot ${args.join(' ')}`);
+    const exitCode = await spawnCopilot(args, { inherit: true });
+
+    // Exit with Copilot's exit code
+    process.exit(exitCode);
+  } catch (error) {
+    if (error instanceof Error) {
+      log.error(`Task command failed: ${error.message}`);
+    } else {
+      log.error(`Task command failed: ${String(error)}`);
+    }
+    throw error;
+  }
+}
+
+export default task;