@vexdo/cli 0.1.0 → 0.1.1

package/src/lib/claude.ts

@@ -1,259 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-
-import { ARBITER_SYSTEM_PROMPT } from '../prompts/arbiter.js';
-import { REVIEWER_SYSTEM_PROMPT } from '../prompts/reviewer.js';
-import type { ArbiterResult, ReviewComment, ReviewResult } from '../types/index.js';
-
-const REVIEWER_MAX_TOKENS_DEFAULT = 4096;
-const ARBITER_MAX_TOKENS_DEFAULT = 2048;
-const MAX_ATTEMPTS = 3;
-
-export interface ReviewerOptions {
-  spec: string;
-  diff: string;
-  model: string;
-  maxTokens?: number;
-}
-
-export interface ArbiterOptions {
-  spec: string;
-  diff: string;
-  reviewComments: ReviewComment[];
-  model: string;
-  maxTokens?: number;
-}
-
-export class ClaudeError extends Error {
-  attempt: number;
-  cause: unknown;
-
-  constructor(attempt: number, cause: unknown) {
-    const message = cause instanceof Error ? cause.message : String(cause);
-    super(`Claude API failed after ${String(attempt)} attempts: ${message}`);
-    this.name = 'ClaudeError';
-    this.attempt = attempt;
-    this.cause = cause;
-  }
-}
-
-export async function sleep(ms: number): Promise<void> {
-  await new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-export class ClaudeClient {
-  private client: Anthropic;
-
-  constructor(apiKey: string) {
-    this.client = new Anthropic({ apiKey });
-  }
-
-  async runReviewer(opts: ReviewerOptions): Promise<ReviewResult> {
-    return this.runWithRetry(async () => {
-      const response = await this.client.messages.create({
-        model: opts.model,
-        max_tokens: opts.maxTokens ?? REVIEWER_MAX_TOKENS_DEFAULT,
-        system: REVIEWER_SYSTEM_PROMPT,
-        messages: [
-          {
-            role: 'user',
-            content: `SPEC:\n${opts.spec}\n\nDIFF:\n${opts.diff}`,
-          },
-        ],
-      });
-
-      return parseReviewerResult(extractTextFromResponse(response));
-    });
-  }
-
-  async runArbiter(opts: ArbiterOptions): Promise<ArbiterResult> {
-    return this.runWithRetry(async () => {
-      const response = await this.client.messages.create({
-        model: opts.model,
-        max_tokens: opts.maxTokens ?? ARBITER_MAX_TOKENS_DEFAULT,
-        system: ARBITER_SYSTEM_PROMPT,
-        messages: [
-          {
-            role: 'user',
-            content: `SPEC:\n${opts.spec}\n\nDIFF:\n${opts.diff}\n\nREVIEWER COMMENTS:\n${JSON.stringify(opts.reviewComments)}`,
-          },
-        ],
-      });
-
-      return parseArbiterResult(extractTextFromResponse(response));
-    });
-  }
-
-  private async runWithRetry<T>(fn: () => Promise<T>): Promise<T> {
-    let lastError: unknown = new Error('Unknown Claude failure');
-
-    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
-      try {
-        return await fn();
-      } catch (error: unknown) {
-        lastError = error;
-
-        if (!isRetryableError(error) || attempt === MAX_ATTEMPTS) {
-          throw new ClaudeError(attempt, error);
-        }
-
-        await sleep(1000 * 2 ** (attempt - 1));
-      }
-    }
-
-    throw new ClaudeError(MAX_ATTEMPTS, lastError);
-  }
-}
-
-function extractTextFromResponse(response: unknown): string {
-  const content =
-    typeof response === 'object' && response !== null && 'content' in response
-      ? (response as { content?: unknown }).content
-      : null;
-
-  if (!Array.isArray(content)) {
-    throw new Error('Claude response missing content array');
-  }
-
-  const text = content
-    .filter((block): block is { type: string; text?: string } => typeof block === 'object' && block !== null && 'type' in block)
-    .filter((block) => block.type === 'text')
-    .map((block) => (typeof block.text === 'string' ? block.text : ''))
-    .join('\n')
-    .trim();
-
-  if (!text) {
-    throw new Error('Claude response had no text content');
-  }
-
-  return text;
-}
-
-function extractJson(text: string): string {
-  const trimmed = text.trim();
-
-  if (!trimmed.startsWith('```')) {
-    return trimmed;
-  }
-
-  const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/i.exec(trimmed);
-  if (fenced && fenced[1]) {
-    return fenced[1].trim();
-  }
-
-  return trimmed;
-}
-
-function parseReviewerResult(raw: string): ReviewResult {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(extractJson(raw));
-  } catch (error: unknown) {
-    throw new Error(`Failed to parse reviewer JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-
-  if (!isReviewResult(parsed)) {
-    throw new Error('Reviewer JSON does not match schema');
-  }
-
-  return parsed;
-}
-
-function parseArbiterResult(raw: string): ArbiterResult {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(extractJson(raw));
-  } catch (error: unknown) {
-    throw new Error(`Failed to parse arbiter JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-
-  if (!isArbiterResult(parsed)) {
-    throw new Error('Arbiter JSON does not match schema');
-  }
-
-  return parsed;
-}
-
-function isReviewComment(value: unknown): value is ReviewComment {
-  if (typeof value !== 'object' || value === null) {
-    return false;
-  }
-
-  const candidate = value as Record<string, unknown>;
-  if (!['critical', 'important', 'minor', 'noise'].includes(String(candidate.severity))) {
-    return false;
-  }
-  if (typeof candidate.comment !== 'string') {
-    return false;
-  }
-  if (candidate.file !== undefined && typeof candidate.file !== 'string') {
-    return false;
-  }
-  if (candidate.line !== undefined && typeof candidate.line !== 'number') {
-    return false;
-  }
-  if (candidate.suggestion !== undefined && typeof candidate.suggestion !== 'string') {
-    return false;
-  }
-
-  return true;
-}
-
-function isReviewResult(value: unknown): value is ReviewResult {
-  if (typeof value !== 'object' || value === null) {
-    return false;
-  }
-
-  const comments = (value as { comments?: unknown }).comments;
-  return Array.isArray(comments) && comments.every((comment) => isReviewComment(comment));
-}
-
-function isArbiterResult(value: unknown): value is ArbiterResult {
-  if (typeof value !== 'object' || value === null) {
-    return false;
-  }
-
-  const candidate = value as Record<string, unknown>;
-
-  if (!['fix', 'submit', 'escalate'].includes(String(candidate.decision))) {
-    return false;
-  }
-  if (typeof candidate.reasoning !== 'string' || typeof candidate.summary !== 'string') {
-    return false;
-  }
-
-  if (candidate.decision === 'fix') {
-    return typeof candidate.feedback_for_codex === 'string' && candidate.feedback_for_codex.length > 0;
-  }
-
-  return candidate.feedback_for_codex === undefined;
-}
-
-function getStatusCode(error: unknown): number | undefined {
-  if (typeof error !== 'object' || error === null) {
-    return undefined;
-  }
-
-  const candidate = error as { status?: unknown; statusCode?: unknown };
-  if (typeof candidate.status === 'number') {
-    return candidate.status;
-  }
-  if (typeof candidate.statusCode === 'number') {
-    return candidate.statusCode;
-  }
-
-  return undefined;
-}
-
-function isRetryableError(error: unknown): boolean {
-  const status = getStatusCode(error);
-  if (status === 400 || status === 401 || status === 403) {
-    return false;
-  }
-  if (status === 429 || (status !== undefined && status >= 500 && status <= 599)) {
-    return true;
-  }
-
-  return true;
-}

package/src/lib/codex.ts

@@ -1,96 +0,0 @@
-import { execFile as execFileCb } from 'node:child_process';
-
-import * as logger from './logger.js';
-
-const CODEX_TIMEOUT_MS = 600_000;
-
-export interface CodexExecOptions {
-  spec: string;
-  model: string;
-  cwd: string;
-  verbose?: boolean;
-}
-
-export interface CodexResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-export class CodexError extends Error {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-
-  constructor(stdout: string, stderr: string, exitCode: number) {
-    super(`codex exec failed (exit ${String(exitCode)})`);
-    this.name = 'CodexError';
-    this.stdout = stdout;
-    this.stderr = stderr;
-    this.exitCode = exitCode;
-  }
-}
-
-export class CodexNotFoundError extends Error {
-  constructor() {
-    super('codex CLI not found. Install it: npm install -g @openai/codex');
-    this.name = 'CodexNotFoundError';
-  }
-}
-
-/**
- * Ensure codex CLI is installed and executable.
- */
-export async function checkCodexAvailable(): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    execFileCb('codex', ['--version'], { timeout: CODEX_TIMEOUT_MS, encoding: 'utf8' }, (error) => {
-      if (error) {
-        reject(new CodexNotFoundError());
-        return;
-      }
-      resolve();
-    });
-  });
-}
-
-/**
- * Execute codex with a task spec and model.
- */
-export async function exec(opts: CodexExecOptions): Promise<CodexResult> {
-  const args = ['exec', '--model', opts.model, '--full-auto', '--', opts.spec];
-
-  const result = await new Promise<CodexResult>((resolve, reject) => {
-    execFileCb(
-      'codex',
-      args,
-      { cwd: opts.cwd, timeout: CODEX_TIMEOUT_MS, encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 },
-      (error, stdout, stderr) => {
-        const normalizedStdout = stdout.trimEnd();
-        const normalizedStderr = stderr.trimEnd();
-
-        if (opts.verbose) {
-          if (normalizedStdout) {
-            logger.debug(normalizedStdout);
-          }
-          if (normalizedStderr) {
-            logger.debug(normalizedStderr);
-          }
-        }
-
-        if (error) {
-          const exitCode = typeof error.code === 'number' ? error.code : 1;
-          reject(new CodexError(normalizedStdout, normalizedStderr || error.message, exitCode));
-          return;
-        }
-
-        resolve({
-          stdout: normalizedStdout,
-          stderr: normalizedStderr,
-          exitCode: 0,
-        });
-      },
-    );
-  });
-
-  return result;
-}

package/src/lib/config.ts

@@ -1,157 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { parse } from 'yaml';
-
-import type { CodexConfig, ReviewConfig, ServiceConfig, VexdoConfig } from '../types/index.js';
-
-const DEFAULT_REVIEW_MODEL = 'claude-haiku-4-5-20251001';
-const DEFAULT_MAX_ITERATIONS = 3;
-const DEFAULT_AUTO_SUBMIT = false;
-const DEFAULT_CODEX_MODEL = 'gpt-4o';
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-function readObjectField(obj: Record<string, unknown>, fieldPath: string): unknown {
-  return obj[fieldPath];
-}
-
-function requireString(value: unknown, fieldPath: string): string {
-  if (typeof value !== 'string' || value.length === 0) {
-    throw new Error(`${fieldPath} must be a non-empty string`);
-  }
-  return value;
-}
-
-function parseServices(value: unknown): ServiceConfig[] {
-  if (!Array.isArray(value) || value.length === 0) {
-    throw new Error('services must be a non-empty array');
-  }
-
-  return value.map((service, index) => {
-    if (!isRecord(service)) {
-      throw new Error(`services[${String(index)}] must be an object`);
-    }
-
-    const name = requireString(readObjectField(service, 'name'), `services[${String(index)}].name`);
-    const servicePath = requireString(readObjectField(service, 'path'), `services[${String(index)}].path`);
-
-    return {
-      name,
-      path: servicePath,
-    };
-  });
-}
-
-function parseReview(value: unknown): ReviewConfig {
-  if (value === undefined) {
-    return {
-      model: DEFAULT_REVIEW_MODEL,
-      max_iterations: DEFAULT_MAX_ITERATIONS,
-      auto_submit: DEFAULT_AUTO_SUBMIT,
-    };
-  }
-
-  if (!isRecord(value)) {
-    throw new Error('review must be an object');
-  }
-
-  const modelRaw = readObjectField(value, 'model');
-  const iterationsRaw = readObjectField(value, 'max_iterations');
-  const autoSubmitRaw = readObjectField(value, 'auto_submit');
-
-  const model = modelRaw === undefined ? DEFAULT_REVIEW_MODEL : requireString(modelRaw, 'review.model');
-
-  let max_iterations = DEFAULT_MAX_ITERATIONS;
-  if (iterationsRaw !== undefined) {
-    if (typeof iterationsRaw !== 'number' || !Number.isInteger(iterationsRaw) || iterationsRaw <= 0) {
-      throw new Error('review.max_iterations must be a positive integer');
-    }
-    max_iterations = iterationsRaw;
-  }
-
-  let auto_submit = DEFAULT_AUTO_SUBMIT;
-  if (autoSubmitRaw !== undefined) {
-    if (typeof autoSubmitRaw !== 'boolean') {
-      throw new Error('review.auto_submit must be a boolean');
-    }
-    auto_submit = autoSubmitRaw;
-  }
-
-  return {
-    model,
-    max_iterations,
-    auto_submit,
-  };
-}
-
-function parseCodex(value: unknown): CodexConfig {
-  if (value === undefined) {
-    return { model: DEFAULT_CODEX_MODEL };
-  }
-
-  if (!isRecord(value)) {
-    throw new Error('codex must be an object');
-  }
-
-  const modelRaw = readObjectField(value, 'model');
-  const model = modelRaw === undefined ? DEFAULT_CODEX_MODEL : requireString(modelRaw, 'codex.model');
-  return { model };
-}
-
-export function findProjectRoot(startDir: string = process.cwd()): string | null {
-  let current = path.resolve(startDir);
-  let reachedRoot = false;
-
-  while (!reachedRoot) {
-    const candidate = path.join(current, '.vexdo.yml');
-    if (fs.existsSync(candidate)) {
-      return current;
-    }
-
-    const parent = path.dirname(current);
-    reachedRoot = parent === current;
-    current = parent;
-  }
-
-  return null;
-}
-
-export function loadConfig(projectRoot: string): VexdoConfig {
-  const configPath = path.join(projectRoot, '.vexdo.yml');
-
-  if (!fs.existsSync(configPath)) {
-    throw new Error(`Configuration file not found: ${configPath}`);
-  }
-
-  const configRaw = fs.readFileSync(configPath, 'utf8');
-  let parsed: unknown;
-
-  try {
-    parsed = parse(configRaw);
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Invalid YAML in .vexdo.yml: ${message}`);
-  }
-
-  if (!isRecord(parsed)) {
-    throw new Error('config must be an object');
-  }
-
-  const versionRaw = readObjectField(parsed, 'version');
-  if (versionRaw !== 1) {
-    throw new Error('version must be 1');
-  }
-
-  const services = parseServices(readObjectField(parsed, 'services'));
-  const review = parseReview(readObjectField(parsed, 'review'));
-  const codex = parseCodex(readObjectField(parsed, 'codex'));
-
-  return {
-    version: 1,
-    services,
-    review,
-    codex,
-  };
-}

package/src/lib/gh.ts

@@ -1,78 +0,0 @@
-import { execFile as execFileCb } from 'node:child_process';
-
-const GH_TIMEOUT_MS = 30_000;
-
-export interface CreatePrOptions {
-  title: string;
-  body: string;
-  base?: string;
-  cwd: string;
-}
-
-export class GhNotFoundError extends Error {
-  constructor() {
-    super('gh CLI not found. Install it: https://cli.github.com');
-    this.name = 'GhNotFoundError';
-  }
-}
-
-/**
- * Ensure GitHub CLI is installed and executable.
- */
-export async function checkGhAvailable(): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    execFileCb('gh', ['--version'], { timeout: GH_TIMEOUT_MS, encoding: 'utf8' }, (error) => {
-      if (error) {
-        reject(new GhNotFoundError());
-        return;
-      }
-      resolve();
-    });
-  });
-}
-
-/**
- * Create a pull request and return the new PR URL.
- */
-export async function createPr(opts: CreatePrOptions): Promise<string> {
-  const base = opts.base ?? 'main';
-  const output = await new Promise<string>((resolve, reject) => {
-    execFileCb(
-      'gh',
-      ['pr', 'create', '--title', opts.title, '--body', opts.body, '--base', base],
-      { cwd: opts.cwd, timeout: GH_TIMEOUT_MS, encoding: 'utf8' },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(new Error((stderr || error.message).trim()));
-          return;
-        }
-        resolve(stdout.trim());
-      },
-    );
-  });
-
-  return output;
-}
-
-/**
- * Return an existing PR URL for a branch, or null when no PR exists.
- */
-export async function getPrUrl(branch: string, cwd: string): Promise<string | null> {
-  const output = await new Promise<string | null>((resolve) => {
-    execFileCb(
-      'gh',
-      ['pr', 'view', branch, '--json', 'url', '--jq', '.url'],
-      { cwd, timeout: GH_TIMEOUT_MS, encoding: 'utf8' },
-      (error, stdout) => {
-        if (error) {
-          resolve(null);
-          return;
-        }
-        const url = stdout.trim();
-        resolve(url || null);
-      },
-    );
-  });
-
-  return output;
-}

package/src/lib/git.ts

@@ -1,119 +0,0 @@
-import { execFile as execFileCb } from 'node:child_process';
-
-const GIT_TIMEOUT_MS = 30_000;
-
-/** Error thrown when a git command fails. */
-export class GitError extends Error {
-  command: string;
-  exitCode: number;
-  stderr: string;
-
-  constructor(args: string[], exitCode: number, stderr: string) {
-    super(`git ${args.join(' ')} failed (exit ${String(exitCode)}): ${stderr}`);
-    this.name = 'GitError';
-    this.command = `git ${args.join(' ')}`;
-    this.exitCode = exitCode;
-    this.stderr = stderr;
-  }
-}
-
-/**
- * Run a git command in a specific working directory.
- */
-export async function exec(args: string[], cwd: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    execFileCb('git', args, { cwd, timeout: GIT_TIMEOUT_MS, encoding: 'utf8' }, (error, stdout, stderr) => {
-      if (error) {
-        const exitCode = typeof error.code === 'number' ? error.code : -1;
-        reject(new GitError(args, exitCode, (stderr || error.message).trim()));
-        return;
-      }
-      resolve(stdout.trimEnd());
-    });
-  });
-}
-
-/**
- * Get the current branch name.
- */
-export async function getCurrentBranch(cwd: string): Promise<string> {
-  return exec(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
-}
-
-/**
- * Check whether a local branch exists.
- */
-export async function branchExists(name: string, cwd: string): Promise<boolean> {
-  try {
-    await exec(['rev-parse', '--verify', '--quiet', `refs/heads/${name}`], cwd);
-    return true;
-  } catch (error) {
-    if (error instanceof GitError && error.exitCode === 1) {
-      return false;
-    }
-    throw error;
-  }
-}
-
-/**
- * Create and checkout a new branch.
- */
-export async function createBranch(name: string, cwd: string): Promise<void> {
-  if (await branchExists(name, cwd)) {
-    throw new GitError(['checkout', '-b', name], 128, `branch '${name}' already exists`);
-  }
-  await exec(['checkout', '-b', name], cwd);
-}
-
-/**
- * Checkout an existing branch.
- */
-export async function checkoutBranch(name: string, cwd: string): Promise<void> {
-  await exec(['checkout', name], cwd);
-}
-
-/**
- * Get the git diff for the working directory.
- */
-export async function getDiff(cwd: string, base?: string): Promise<string> {
-  if (base) {
-    return exec(['diff', `${base}..HEAD`], cwd);
-  }
-  return exec(['diff', 'HEAD'], cwd);
-}
-
-/**
- * Get porcelain status output.
- */
-export async function getStatus(cwd: string): Promise<string> {
-  return exec(['status', '--porcelain'], cwd);
-}
-
-/**
- * Return whether the repository has uncommitted changes.
- */
-export async function hasUncommittedChanges(cwd: string): Promise<boolean> {
-  const status = await getStatus(cwd);
-  return status.length > 0;
-}
-
-/**
- * Stage all changes.
- */
-export async function stageAll(cwd: string): Promise<void> {
-  await exec(['add', '-A'], cwd);
-}
-
-/**
- * Commit staged changes.
- */
-export async function commit(message: string, cwd: string): Promise<void> {
-  await exec(['commit', '-m', message], cwd);
-}
-
-/**
- * Build the task branch name for a service.
- */
-export function getBranchName(taskId: string, service: string): string {
-  return `vexdo/${taskId}/${service}`;
-}