@vexdo/cli 0.1.0

package/src/commands/fix.ts

@@ -0,0 +1,106 @@
+import path from 'node:path';
+
+import type { Command } from 'commander';
+
+import { ClaudeClient } from '../lib/claude.js';
+import * as codex from '../lib/codex.js';
+import { findProjectRoot, loadConfig } from '../lib/config.js';
+import * as logger from '../lib/logger.js';
+import { requireAnthropicApiKey } from '../lib/requirements.js';
+import { runReviewLoop } from '../lib/review-loop.js';
+import { loadState, saveState } from '../lib/state.js';
+import { ensureTaskDirectory, loadAndValidateTask, moveTaskFileAtomically } from '../lib/tasks.js';
+
+interface FixOptions { dryRun?: boolean; verbose?: boolean }
+
+function fatalAndExit(message: string): never {
+  logger.fatal(message);
+  process.exit(1);
+}
+
+export async function runFix(feedback: string, options: FixOptions): Promise<void> {
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      fatalAndExit('Not inside a vexdo project.');
+    }
+
+    const config = loadConfig(projectRoot);
+    const state = loadState(projectRoot);
+    if (!state) {
+      fatalAndExit('No active task.');
+    }
+
+    if (!options.dryRun) {
+      requireAnthropicApiKey();
+      await codex.checkCodexAvailable();
+    }
+
+    const currentStep = state.steps.find((step) => step.status === 'in_progress' || step.status === 'pending');
+    if (!currentStep) {
+      fatalAndExit('No in-progress step found in active task.');
+    }
+
+    const task = loadAndValidateTask(state.taskPath, config);
+    const step = task.steps.find((item) => item.service === currentStep.service);
+    if (!step) {
+      fatalAndExit(`Could not locate task step for service '${currentStep.service}'.`);
+    }
+
+    if (!options.dryRun) {
+      const serviceConfig = config.services.find((service) => service.name === currentStep.service);
+      if (!serviceConfig) {
+        fatalAndExit(`Unknown service in step: ${currentStep.service}`);
+      }
+
+      await codex.exec({
+        spec: feedback,
+        model: config.codex.model,
+        cwd: path.resolve(projectRoot, serviceConfig.path),
+        verbose: options.verbose,
+      });
+    }
+
+    const result = await runReviewLoop({
+      taskId: task.id,
+      task,
+      step,
+      stepState: currentStep,
+      projectRoot,
+      config,
+      claude: new ClaudeClient(process.env.ANTHROPIC_API_KEY ?? ''),
+      dryRun: options.dryRun,
+      verbose: options.verbose,
+    });
+
+    if (result.decision === 'escalate') {
+      currentStep.status = 'escalated';
+      state.status = 'escalated';
+      if (!options.dryRun) {
+        saveState(projectRoot, state);
+        const blockedDir = ensureTaskDirectory(projectRoot, 'blocked');
+        state.taskPath = moveTaskFileAtomically(state.taskPath, blockedDir);
+        saveState(projectRoot, state);
+      }
+      process.exit(1);
+    }
+
+    currentStep.status = 'done';
+    if (!options.dryRun) {
+      saveState(projectRoot, state);
+    }
+  } catch (error: unknown) {
+    fatalAndExit(error instanceof Error ? error.message : String(error));
+  }
+}
+
+export function registerFixCommand(program: Command): void {
+  program
+    .command('fix')
+    .description('Provide feedback to codex and rerun review')
+    .argument('<feedback>')
+    .action(async (feedback: string, options: FixOptions, command: Command) => {
+      const merged = command.optsWithGlobals();
+      await runFix(feedback, { ...options, ...merged });
+    });
+}

package/src/commands/init.ts

@@ -0,0 +1,142 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+
+import type { Command } from 'commander';
+import { stringify } from 'yaml';
+
+import * as logger from '../lib/logger.js';
+import type { VexdoConfig } from '../types/index.js';
+
+const DEFAULT_REVIEW_MODEL = 'claude-haiku-4-5-20251001';
+const DEFAULT_MAX_ITERATIONS = 3;
+const DEFAULT_CODEX_MODEL = 'gpt-4o';
+
+const TASK_DIRS = ['backlog', 'in_progress', 'review', 'done', 'blocked'] as const;
+
+export type PromptFn = (question: string) => Promise<string>;
+
+async function defaultPrompt(question: string): Promise<string> {
+  const rl = createInterface({ input, output });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+}
+
+function parseServices(value: string): string[] {
+  const parsed = value
+    .split(',')
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+
+  return Array.from(new Set(parsed));
+}
+
+function parseBoolean(value: string): boolean {
+  const normalized = value.trim().toLowerCase();
+  return normalized === 'y' || normalized === 'yes';
+}
+
+function parseMaxIterations(value: string): number {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : DEFAULT_MAX_ITERATIONS;
+}
+
+function ensureGitignoreEntry(gitignorePath: string, entry: string): boolean {
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, `${entry}\n`, 'utf8');
+    return true;
+  }
+
+  const content = fs.readFileSync(gitignorePath, 'utf8');
+  const lines = content.split(/\r?\n/).map((line) => line.trim());
+
+  if (lines.includes(entry)) {
+    return false;
+  }
+
+  const suffix = content.endsWith('\n') || content.length === 0 ? '' : '\n';
+  fs.appendFileSync(gitignorePath, `${suffix}${entry}\n`, 'utf8');
+  return true;
+}
+
+export async function runInit(projectRoot: string, prompt: PromptFn = defaultPrompt): Promise<void> {
+  const configPath = path.join(projectRoot, '.vexdo.yml');
+
+  if (fs.existsSync(configPath)) {
+    logger.warn('Found existing .vexdo.yml.');
+    const overwriteAnswer = await prompt('Overwrite existing .vexdo.yml? (y/N): ');
+    if (!parseBoolean(overwriteAnswer)) {
+      logger.info('Initialization cancelled.');
+      return;
+    }
+  }
+
+  let services = parseServices(await prompt('Project services (comma-separated names, e.g. api,web): '));
+  if (services.length === 0) {
+    services = ['api'];
+  }
+
+  const serviceConfigs: VexdoConfig['services'] = [];
+  for (const name of services) {
+    const answer = await prompt(`Path for ${name} (default: ./${name}): `);
+    serviceConfigs.push({
+      name,
+      path: answer.trim().length > 0 ? answer.trim() : `./${name}`,
+    });
+  }
+
+  const reviewModelRaw = await prompt(`Review model (default: ${DEFAULT_REVIEW_MODEL}): `);
+  const maxIterationsRaw = await prompt(`Max review iterations (default: ${String(DEFAULT_MAX_ITERATIONS)}): `);
+  const autoSubmitRaw = await prompt('Auto-submit PRs? (y/N): ');
+  const codexModelRaw = await prompt(`Codex model (default: ${DEFAULT_CODEX_MODEL}): `);
+
+  const config: VexdoConfig = {
+    version: 1,
+    services: serviceConfigs,
+    review: {
+      model: reviewModelRaw.trim() || DEFAULT_REVIEW_MODEL,
+      max_iterations: maxIterationsRaw.trim() ? parseMaxIterations(maxIterationsRaw.trim()) : DEFAULT_MAX_ITERATIONS,
+      auto_submit: parseBoolean(autoSubmitRaw),
+    },
+    codex: {
+      model: codexModelRaw.trim() || DEFAULT_CODEX_MODEL,
+    },
+  };
+
+  fs.writeFileSync(configPath, stringify(config), 'utf8');
+
+  const createdDirs: string[] = [];
+  for (const taskDir of TASK_DIRS) {
+    const directory = path.join(projectRoot, 'tasks', taskDir);
+    fs.mkdirSync(directory, { recursive: true });
+    createdDirs.push(path.relative(projectRoot, directory));
+  }
+
+  const logDir = path.join(projectRoot, '.vexdo', 'logs');
+  fs.mkdirSync(logDir, { recursive: true });
+  createdDirs.push(path.relative(projectRoot, logDir));
+
+  const gitignorePath = path.join(projectRoot, '.gitignore');
+  const gitignoreUpdated = ensureGitignoreEntry(gitignorePath, '.vexdo/');
+
+  logger.success('Initialized vexdo project.');
+  logger.info(`Created: ${path.relative(projectRoot, configPath)}`);
+  logger.info(`Created directories: ${createdDirs.join(', ')}`);
+  if (gitignoreUpdated) {
+    logger.info('Updated .gitignore with .vexdo/');
+  }
+  logger.info("Next: create a task file in tasks/backlog/ and run 'vexdo start tasks/backlog/my-task.yml'");
+}
+
+export function registerInitCommand(program: Command): void {
+  program
+    .command('init')
+    .description('Initialize vexdo in the current project')
+    .action(async () => {
+      await runInit(process.cwd());
+    });
+}

package/src/commands/logs.ts

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { Command } from 'commander';
+
+import { findProjectRoot } from '../lib/config.js';
+import * as logger from '../lib/logger.js';
+import { getLogsDir, getStateDir, loadState } from '../lib/state.js';
+
+interface LogsOptions { full?: boolean }
+
+function fatalAndExit(message: string): never {
+  logger.fatal(message);
+  process.exit(1);
+}
+
+export function runLogs(taskIdArg?: string, options?: LogsOptions): void {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    fatalAndExit('Not inside a vexdo project.');
+  }
+
+  const state = loadState(projectRoot);
+  const taskId = taskIdArg ?? state?.taskId;
+
+  if (!taskId) {
+    const base = path.join(getStateDir(projectRoot), 'logs');
+    if (!fs.existsSync(base)) {
+      logger.info('No logs available.');
+      return;
+    }
+
+    const tasks = fs.readdirSync(base, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+    for (const dir of tasks) {
+      logger.info(dir.name);
+    }
+    return;
+  }
+
+  const logsDir = getLogsDir(projectRoot, taskId);
+  if (!fs.existsSync(logsDir)) {
+    fatalAndExit(`No logs found for task '${taskId}'.`);
+  }
+
+  const files = fs.readdirSync(logsDir).filter((name) => name.endsWith('-arbiter.json'));
+  for (const arbiterFile of files) {
+    const base = arbiterFile.replace(/-arbiter\.json$/, '');
+    const arbiterPath = path.join(logsDir, `${base}-arbiter.json`);
+    const reviewPath = path.join(logsDir, `${base}-review.json`);
+    const diffPath = path.join(logsDir, `${base}-diff.txt`);
+
+    const arbiter = JSON.parse(fs.readFileSync(arbiterPath, 'utf8')) as { decision: string; summary: string };
+    const review = JSON.parse(fs.readFileSync(reviewPath, 'utf8')) as { comments?: unknown[] };
+
+    logger.info(`${base}: decision=${arbiter.decision}, comments=${String(review.comments?.length ?? 0)}, summary=${arbiter.summary}`);
+
+    if (options?.full) {
+      console.log(fs.readFileSync(diffPath, 'utf8'));
+      console.log(JSON.stringify(review, null, 2));
+      console.log(JSON.stringify(arbiter, null, 2));
+    }
+  }
+}
+
+export function registerLogsCommand(program: Command): void {
+  program
+    .command('logs')
+    .description('Show iteration logs')
+    .argument('[task-id]')
+    .option('--full', 'Print full diff and comments')
+    .action((taskId?: string, options?: LogsOptions) => {
+      runLogs(taskId, options);
+    });
+}

package/src/commands/review.ts

@@ -0,0 +1,107 @@
+import fs from 'node:fs';
+
+import type { Command } from 'commander';
+
+import { ClaudeClient } from '../lib/claude.js';
+import { findProjectRoot, loadConfig } from '../lib/config.js';
+import * as logger from '../lib/logger.js';
+import { requireAnthropicApiKey } from '../lib/requirements.js';
+import { runReviewLoop } from '../lib/review-loop.js';
+import { loadState, saveState } from '../lib/state.js';
+import { ensureTaskDirectory, loadAndValidateTask, moveTaskFileAtomically } from '../lib/tasks.js';
+
+interface ReviewOptions { dryRun?: boolean; verbose?: boolean }
+
+function fatalAndExit(message: string): never {
+  logger.fatal(message);
+  process.exit(1);
+}
+
+export async function runReview(options: ReviewOptions): Promise<void> {
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      fatalAndExit('Not inside a vexdo project.');
+    }
+
+    const config = loadConfig(projectRoot);
+    const state = loadState(projectRoot);
+    if (!state) {
+      fatalAndExit('No active task.');
+    }
+
+    if (!options.dryRun) {
+      requireAnthropicApiKey();
+    }
+
+    const currentStep = state.steps.find((step) => step.status === 'in_progress' || step.status === 'pending');
+    if (!currentStep) {
+      fatalAndExit('No in-progress step found in active task.');
+    }
+
+    if (!fs.existsSync(state.taskPath)) {
+      fatalAndExit(`Task file not found: ${state.taskPath}`);
+    }
+
+    const task = loadAndValidateTask(state.taskPath, config);
+    const step = task.steps.find((item) => item.service === currentStep.service);
+    if (!step) {
+      fatalAndExit(`Could not locate task step for service '${currentStep.service}'.`);
+    }
+
+    const result = await runReviewLoop({
+      taskId: task.id,
+      task,
+      step,
+      stepState: currentStep,
+      projectRoot,
+      config,
+      claude: new ClaudeClient(process.env.ANTHROPIC_API_KEY ?? ''),
+      dryRun: options.dryRun,
+      verbose: options.verbose,
+    });
+
+    if (result.decision === 'escalate') {
+      logger.escalation({
+        taskId: task.id,
+        service: step.service,
+        iteration: result.finalIteration,
+        spec: step.spec,
+        diff: '',
+        reviewComments: result.lastReviewComments,
+        arbiterReasoning: result.lastArbiterResult.reasoning,
+        summary: result.lastArbiterResult.summary,
+      });
+
+      currentStep.status = 'escalated';
+      state.status = 'escalated';
+
+      if (!options.dryRun) {
+        saveState(projectRoot, state);
+        const blockedDir = ensureTaskDirectory(projectRoot, 'blocked');
+        state.taskPath = moveTaskFileAtomically(state.taskPath, blockedDir);
+        saveState(projectRoot, state);
+      }
+
+      process.exit(1);
+    }
+
+    currentStep.status = 'done';
+    if (!options.dryRun) {
+      saveState(projectRoot, state);
+    }
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    fatalAndExit(message);
+  }
+}
+
+export function registerReviewCommand(program: Command): void {
+  program
+    .command('review')
+    .description('Run review loop for the current step')
+    .action(async (options: ReviewOptions, command: Command) => {
+      const merged = command.optsWithGlobals();
+      await runReview({ ...options, ...merged });
+    });
+}

package/src/commands/start.ts

@@ -0,0 +1,197 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { Command } from 'commander';
+
+import { ClaudeClient } from '../lib/claude.js';
+import * as codex from '../lib/codex.js';
+import { findProjectRoot, loadConfig } from '../lib/config.js';
+import * as git from '../lib/git.js';
+import * as logger from '../lib/logger.js';
+import { requireAnthropicApiKey } from '../lib/requirements.js';
+import { runReviewLoop } from '../lib/review-loop.js';
+import { createState, hasActiveTask, loadState, saveState } from '../lib/state.js';
+import { submitActiveTask } from '../lib/submit-task.js';
+import { buildInitialStepState, ensureTaskDirectory, loadAndValidateTask, moveTaskFileAtomically } from '../lib/tasks.js';
+
+export interface StartCommandOptions {
+  dryRun?: boolean;
+  verbose?: boolean;
+  resume?: boolean;
+}
+
+function fatalAndExit(message: string, hint?: string): never {
+  logger.fatal(message, hint);
+  process.exit(1);
+}
+
+export async function runStart(taskFile: string, options: StartCommandOptions): Promise<void> {
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      fatalAndExit('Not inside a vexdo project. Could not find .vexdo.yml.');
+    }
+
+    const config = loadConfig(projectRoot);
+    const taskPath = path.resolve(taskFile);
+    const task = loadAndValidateTask(taskPath, config);
+
+    if (hasActiveTask(projectRoot) && !options.resume) {
+      fatalAndExit('An active task already exists.', "Use --resume to continue or 'vexdo abort' to cancel.");
+    }
+
+    if (!options.dryRun) {
+      requireAnthropicApiKey();
+      await codex.checkCodexAvailable();
+    }
+
+    let state = loadState(projectRoot);
+
+    if (!options.resume) {
+      let taskPathInProgress = taskPath;
+      if (!options.dryRun) {
+        const inProgressDir = ensureTaskDirectory(projectRoot, 'in_progress');
+        taskPathInProgress = moveTaskFileAtomically(taskPath, inProgressDir);
+      }
+
+      state = createState(task.id, task.title, taskPathInProgress, buildInitialStepState(task));
+      if (!options.dryRun) {
+        saveState(projectRoot, state);
+      }
+    }
+
+    if (!state) {
+      fatalAndExit('No resumable task state found.');
+    }
+
+    const claude = new ClaudeClient(process.env.ANTHROPIC_API_KEY ?? '');
+    const total = task.steps.length;
+
+    for (let i = 0; i < task.steps.length; i += 1) {
+      const step = task.steps[i];
+      const stepState = state.steps[i];
+      if (!step || !stepState) {
+        continue;
+      }
+
+      if (stepState.status === 'done') {
+        continue;
+      }
+
+      if (step.depends_on && step.depends_on.length > 0) {
+        for (const depService of step.depends_on) {
+          const depState = state.steps.find((item) => item.service === depService);
+          if (depState?.status !== 'done') {
+            fatalAndExit(`Step dependency '${depService}' for service '${step.service}' is not done.`);
+          }
+        }
+      }
+
+      logger.step(i + 1, total, `${step.service}: ${task.title}`);
+
+      const serviceCfg = config.services.find((service) => service.name === step.service);
+      if (!serviceCfg) {
+        fatalAndExit(`Unknown service in step: ${step.service}`);
+      }
+
+      const serviceRoot = path.resolve(projectRoot, serviceCfg.path);
+      const branch = git.getBranchName(task.id, step.service);
+
+      if (!options.dryRun) {
+        if (options.resume) {
+          await git.checkoutBranch(stepState.branch ?? branch, serviceRoot);
+        } else {
+          await git.createBranch(branch, serviceRoot);
+        }
+      }
+
+      stepState.status = 'in_progress';
+      stepState.branch = branch;
+      if (!options.dryRun) {
+        saveState(projectRoot, state);
+      }
+
+      if (!options.resume && !options.dryRun) {
+        await codex.exec({
+          spec: step.spec,
+          model: config.codex.model,
+          cwd: serviceRoot,
+          verbose: options.verbose,
+        });
+      } else if (options.dryRun) {
+        logger.info(`[dry-run] Would run codex for service ${step.service}`);
+      }
+
+      const result = await runReviewLoop({
+        taskId: task.id,
+        task,
+        step,
+        stepState,
+        projectRoot,
+        config,
+        claude,
+        dryRun: options.dryRun,
+        verbose: options.verbose,
+      });
+
+      if (result.decision === 'escalate') {
+        logger.escalation({
+          taskId: task.id,
+          service: step.service,
+          iteration: result.finalIteration,
+          spec: step.spec,
+          diff: '',
+          reviewComments: result.lastReviewComments,
+          arbiterReasoning: result.lastArbiterResult.reasoning,
+          summary: result.lastArbiterResult.summary,
+        });
+
+        stepState.status = 'escalated';
+        state.status = 'escalated';
+
+        if (!options.dryRun) {
+          saveState(projectRoot, state);
+          const blockedDir = ensureTaskDirectory(projectRoot, 'blocked');
+          state.taskPath = moveTaskFileAtomically(state.taskPath, blockedDir);
+          saveState(projectRoot, state);
+        }
+
+        process.exit(1);
+      }
+
+      stepState.status = 'done';
+      if (!options.dryRun) {
+        saveState(projectRoot, state);
+      }
+    }
+
+    state.status = 'review';
+    if (!options.dryRun) {
+      const reviewDir = ensureTaskDirectory(projectRoot, 'review');
+      state.taskPath = moveTaskFileAtomically(state.taskPath, reviewDir);
+      saveState(projectRoot, state);
+    }
+
+    if (config.review.auto_submit && !options.dryRun) {
+      await submitActiveTask(projectRoot, config, state);
+      return;
+    }
+
+    logger.success("Task ready for PR. Run 'vexdo submit' to create PR.");
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    fatalAndExit(message);
+  }
+}
+
+export function registerStartCommand(program: Command): void {
+  program
+    .command('start')
+    .description('Start a task from a YAML file')
+    .argument('<task-file>')
+    .option('--resume', 'Resume an existing active task')
+    .action(async (taskFile: string, options: StartCommandOptions, command: Command) => {
+      const merged = command.optsWithGlobals();
+      await runStart(taskFile, { ...options, ...merged });
+    });
+}

package/src/commands/status.ts

@@ -0,0 +1,52 @@
+import type { Command } from 'commander';
+
+import { findProjectRoot } from '../lib/config.js';
+import * as logger from '../lib/logger.js';
+import { loadState } from '../lib/state.js';
+
+function fatalAndExit(message: string): never {
+  logger.fatal(message);
+  process.exit(1);
+}
+
+function formatElapsed(startedAt: string): string {
+  const elapsedMs = Date.now() - new Date(startedAt).getTime();
+  const minutes = Math.floor(elapsedMs / 1000 / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) {
+    return `${String(hours)}h ${String(minutes % 60)}m`;
+  }
+  return `${String(minutes)}m`;
+}
+
+export function runStatus(): void {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    fatalAndExit('Not inside a vexdo project.');
+  }
+
+  const state = loadState(projectRoot);
+  if (!state) {
+    fatalAndExit('No active task.');
+  }
+
+  logger.info(`Task: ${state.taskId} — ${state.taskTitle}`);
+  logger.info(`Status: ${state.status}`);
+  console.log('service | status | iteration | branch');
+  for (const step of state.steps) {
+    console.log(`${step.service} | ${step.status} | ${String(step.iteration)} | ${step.branch ?? '-'}`);
+  }
+
+  const inProgress = state.steps.find((step) => step.status === 'in_progress');
+  if (inProgress?.lastArbiterResult?.summary) {
+    logger.info(`Last arbiter summary: ${inProgress.lastArbiterResult.summary}`);
+  }
+
+  logger.info(`Elapsed: ${formatElapsed(state.startedAt)}`);
+}
+
+export function registerStatusCommand(program: Command): void {
+  program.command('status').description('Print active task status').action(() => {
+    runStatus();
+  });
+}