@vexdo/cli 0.1.0 → 0.1.1

package/src/commands/logs.ts

@@ -1,74 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,197 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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();
-  });
-}

package/src/commands/submit.ts

@@ -1,38 +0,0 @@
-import type { Command } from 'commander';
-
-import { findProjectRoot, loadConfig } from '../lib/config.js';
-import * as logger from '../lib/logger.js';
-import { requireGhAvailable } from '../lib/requirements.js';
-import { loadState } from '../lib/state.js';
-import { submitActiveTask } from '../lib/submit-task.js';
-
-function fatalAndExit(message: string): never {
-  logger.fatal(message);
-  process.exit(1);
-}
-
-export async function runSubmit(): 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.');
-    }
-
-    await requireGhAvailable();
-    await submitActiveTask(projectRoot, config, state);
-  } catch (error: unknown) {
-    fatalAndExit(error instanceof Error ? error.message : String(error));
-  }
-}
-
-export function registerSubmitCommand(program: Command): void {
-  program.command('submit').description('Create PRs for active task').action(async () => {
-    await runSubmit();
-  });
-}

package/src/index.ts

@@ -1,42 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-import { Command } from 'commander';
-
-import { registerAbortCommand } from './commands/abort.js';
-import { registerFixCommand } from './commands/fix.js';
-import { registerInitCommand } from './commands/init.js';
-import { registerLogsCommand } from './commands/logs.js';
-import { registerReviewCommand } from './commands/review.js';
-import { registerStartCommand } from './commands/start.js';
-import { registerStatusCommand } from './commands/status.js';
-import { registerSubmitCommand } from './commands/submit.js';
-import * as logger from './lib/logger.js';
-
-const packageJsonPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', 'package.json');
-const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')) as { version: string };
-
-const program = new Command();
-
-program
-  .name('vexdo')
-  .description('Vexdo CLI')
-  .version(packageJson.version)
-  .option('--verbose', 'Enable verbose logs')
-  .option('--dry-run', 'Print plan without making changes');
-
-program.hook('preAction', (_thisCommand, actionCommand) => {
-  const globalOpts = actionCommand.optsWithGlobals();
-  logger.setVerbose(Boolean(globalOpts.verbose));
-});
-
-registerInitCommand(program);
-registerStartCommand(program);
-registerReviewCommand(program);
-registerFixCommand(program);
-registerSubmitCommand(program);
-registerStatusCommand(program);
-registerAbortCommand(program);
-registerLogsCommand(program);
-
-program.parse(process.argv);