@aibridge/cli 0.0.1

package/src/commands/image-gen/impl.ts

@@ -0,0 +1,268 @@
+import {
+  closeSync,
+  copyFileSync,
+  existsSync,
+  mkdtempSync,
+  openSync,
+  readSync,
+  rmSync,
+  statSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { isNotFound, runCaptured } from '@aibridge/proc';
+import type { LocalContext } from '../../context.ts';
+import type { ImageResult } from '../../driver.ts';
+import { getDriver } from '../../drivers.ts';
+import {
+  DEFAULT_IMAGE_GEN,
+  formatImageGenModelError,
+  formatUnknownModelError,
+  resolveModel,
+  supportsImageGen,
+} from '../../models.ts';
+
+export interface ImageGenFlags {
+  readonly model?: string;
+  readonly out?: string;
+  readonly size?: string;
+  readonly image?: string;
+  readonly quality?: string;
+  readonly timeout?: number;
+  readonly json: boolean;
+}
+
+const MIN_REAL_BYTES_CODEX = 100_000;
+const MIN_REAL_BYTES_GROK = 10_000;
+
+export default async function imageGen(
+  this: LocalContext,
+  flags: ImageGenFlags,
+  prompt: string,
+): Promise<void> {
+  const fail = (msg: string): void => {
+    this.process.stderr.write(`aibridge image-gen: ${msg}\n`);
+    this.process.exitCode = 1;
+  };
+
+  const inputSlug = flags.model ?? DEFAULT_IMAGE_GEN;
+  const model = resolveModel(inputSlug);
+  if (!model) return fail(formatUnknownModelError(inputSlug));
+  if (!supportsImageGen(model)) return fail(formatImageGenModelError(inputSlug, model));
+
+  if (model.spec.backend === 'codex' && model.effort) {
+    return fail(
+      `effort "-${model.effort}" has no effect on image-gen (gpt-image-2 renders, not the seat model); use ${DEFAULT_IMAGE_GEN}.`,
+    );
+  }
+
+  const quality = (flags.quality ?? 'high').toLowerCase();
+  if (!['low', 'medium', 'high'].includes(quality)) {
+    return fail(`invalid --quality "${flags.quality}" (use low | medium | high)`);
+  }
+
+  let size: { w: number; h: number } | undefined;
+  if (flags.size !== undefined) {
+    const m = flags.size.match(/^(\d+)\s*x\s*(\d+)$/i);
+    if (!m) return fail(`invalid --size "${flags.size}" (expected e.g. 1024x1024)`);
+    size = { w: Number(m[1]), h: Number(m[2]) };
+    if (model.spec.backend === 'codex') {
+      const constraint = sizeConstraintError(size.w, size.h);
+      if (constraint) return fail(`invalid --size ${size.w}x${size.h}: ${constraint}`);
+    } else if (size.w < 1 || size.h < 1) {
+      return fail(`invalid --size ${size.w}x${size.h}: dimensions must be positive`);
+    }
+  }
+
+  const timeoutSec = flags.timeout ?? 600;
+  const outPath = resolve(this.process.cwd(), flags.out ?? './aibridge-image.png');
+
+  const imagePaths: string[] = [];
+  if (flags.image !== undefined) {
+    for (const raw of flags.image
+      .split(',')
+      .map(s => s.trim())
+      .filter(Boolean)) {
+      const abs = resolve(this.process.cwd(), raw);
+      if (!existsSync(abs)) return fail(`reference image not found: ${raw}`);
+      imagePaths.push(abs);
+    }
+  }
+
+  const driver = getDriver(model.spec.backend);
+  if (!driver.generateImage) {
+    return fail(formatImageGenModelError(inputSlug, model));
+  }
+
+  const minBytes = model.spec.backend === 'codex' ? MIN_REAL_BYTES_CODEX : MIN_REAL_BYTES_GROK;
+  const work = mkdtempSync(join(tmpdir(), 'aibridge-imagegen-'));
+
+  try {
+    let outcome: ImageResult = await driver.generateImage({
+      prompt,
+      workDir: work,
+      backendModel: model.spec.backendModel,
+      effort: model.effort,
+      quality,
+      size,
+      imagePaths,
+      timeoutSec,
+      forceful: false,
+      minBytes,
+    });
+
+    if (model.spec.backend === 'codex' && outcome.kind === 'suspect') {
+      outcome = await driver.generateImage({
+        prompt,
+        workDir: work,
+        backendModel: model.spec.backendModel,
+        effort: model.effort,
+        quality,
+        size,
+        imagePaths,
+        timeoutSec,
+        forceful: true,
+        minBytes,
+      });
+    }
+
+    if (outcome.kind === 'ok' && outcome.bytes < minBytes) {
+      outcome = { kind: 'suspect' };
+    }
+
+    if (outcome.kind === 'error') return fail(outcome.reason);
+    if (outcome.kind === 'suspect') {
+      return fail(
+        model.spec.backend === 'grok'
+          ? 'grok produced no usable image. Check SuperGrok image access and re-run with a simpler prompt.'
+          : 'codex produced only a tiny/code-drawn image, not a real gpt-image-2 render. ' +
+              'Try --quality high or a clearer, simpler prompt.',
+      );
+    }
+
+    const local = join(work, 'result.bin');
+    copyFileSync(outcome.path, local);
+
+    let dims = imageSize(local);
+    if (size && dims && (dims.width !== size.w || dims.height !== size.h)) {
+      const resized = await magick([local, '-resize', `${size.w}x${size.h}!`, local]);
+      if (resized) {
+        dims = imageSize(local) ?? dims;
+      } else {
+        this.process.stderr.write(
+          `aibridge image-gen: rendered ${dims.width}x${dims.height}, wanted ${size.w}x${size.h}, ` +
+            'and ImageMagick (magick/convert) is unavailable to resize.\n',
+        );
+      }
+    }
+
+    const outExt = /\.png$/i.test(outPath) ? 'png' : /\.jpe?g$/i.test(outPath) ? 'jpg' : null;
+    const actualFmt = pngSize(local) ? 'png' : jpegSize(local) ? 'jpg' : null;
+    const needsConvert = outExt !== null && actualFmt !== null && outExt !== actualFmt;
+    if (!needsConvert || !(await magick([local, outPath]))) {
+      if (needsConvert) {
+        this.process.stderr.write(
+          `aibridge image-gen: render is ${actualFmt.toUpperCase()} but out path wants ` +
+            `${outExt.toUpperCase()}, and ImageMagick (magick/convert) is unavailable to convert; ` +
+            'writing the raw bytes as-is.\n',
+        );
+      }
+      copyFileSync(local, outPath);
+    }
+    const bytes = statSync(outPath).size;
+
+    if (flags.json) {
+      this.process.stdout.write(
+        `${JSON.stringify({
+          out: outPath,
+          bytes,
+          width: dims?.width ?? null,
+          height: dims?.height ?? null,
+          sizeRequested: flags.size ?? null,
+          quality: model.spec.backend === 'codex' ? quality : null,
+          model: model.spec.slug,
+          backend: model.spec.backend,
+          real: true,
+        })}\n`,
+      );
+    } else {
+      const kb = Math.round(bytes / 1024);
+      const dimStr = dims ? `${dims.width}x${dims.height}, ` : '';
+      const qualityStr = model.spec.backend === 'codex' ? `, ${quality} quality` : '';
+      this.process.stdout.write(
+        `✓ Wrote ${outPath} (${dimStr}${kb} KB${qualityStr}, ${model.spec.slug})\n`,
+      );
+    }
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+
+function sizeConstraintError(w: number, h: number): string | null {
+  if (w % 16 !== 0 || h % 16 !== 0) return 'each edge must be divisible by 16';
+  const long = Math.max(w, h);
+  const short = Math.min(w, h);
+  if (long / short > 3) return 'aspect ratio must be within 1:3–3:1';
+  if (long > 3840) return 'longest edge must be <= 3840px';
+  const px = w * h;
+  if (px < 655_360 || px > 8_294_400) return 'total pixels must be 655,360–8,294,400';
+  return null;
+}
+
+function imageSize(path: string): { width: number; height: number } | null {
+  return pngSize(path) ?? jpegSize(path);
+}
+
+function pngSize(path: string): { width: number; height: number } | null {
+  try {
+    const fd = openSync(path, 'r');
+    const head = Buffer.alloc(24);
+    readSync(fd, head, 0, 24, 0);
+    closeSync(fd);
+    if (head.toString('latin1', 1, 4) !== 'PNG') return null;
+    if (head.toString('latin1', 12, 16) !== 'IHDR') return null;
+    return { width: head.readUInt32BE(16), height: head.readUInt32BE(20) };
+  } catch {
+    return null;
+  }
+}
+
+function jpegSize(path: string): { width: number; height: number } | null {
+  try {
+    const fd = openSync(path, 'r');
+    const buf = Buffer.alloc(64 * 1024);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    closeSync(fd);
+    if (n < 4 || buf[0] !== 0xff || buf[1] !== 0xd8) return null;
+    let i = 2;
+    while (i + 9 < n) {
+      if (buf[i] !== 0xff) return null;
+      const marker = buf[i + 1];
+      if (marker === undefined) return null;
+      if (marker === 0xc0 || marker === 0xc1 || marker === 0xc2) {
+        const height = buf.readUInt16BE(i + 5);
+        const width = buf.readUInt16BE(i + 7);
+        return { width, height };
+      }
+      if (marker === 0xd9 || marker === 0xda) return null;
+      const len = buf.readUInt16BE(i + 2);
+      if (len < 2) return null;
+      i += 2 + len;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function magick(args: readonly string[]): Promise<boolean> {
+  for (const tool of ['magick', 'convert']) {
+    try {
+      const r = await runCaptured(tool, [...args], { timeoutMs: 60_000 });
+      if (!r.timedOut && r.code === 0) return true;
+    } catch (err) {
+      if (!isNotFound(err)) throw err;
+    }
+  }
+  return false;
+}

package/src/commands/implement/command.ts

@@ -0,0 +1,50 @@
+import { buildCommand } from '@stricli/core';
+import { DEFAULT_IMPLEMENTER, listModelHelpLines } from '../../models.ts';
+import { positiveIntSeconds } from '../../parsers.ts';
+import implementImpl from './impl.ts';
+
+const fullDescription = [
+  'Reads an implementation plan file and delegates execution to a model.',
+  '',
+  'Available models (canonical slug):',
+  ...listModelHelpLines(),
+].join('\n');
+
+export const implement = buildCommand({
+  func: implementImpl,
+  parameters: {
+    flags: {
+      model: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: `Model slug (default: ${DEFAULT_IMPLEMENTER})`,
+      },
+      timeout: {
+        kind: 'parsed',
+        parse: positiveIntSeconds,
+        optional: true,
+        brief: 'Max seconds for implementation (default: 1800)',
+      },
+      preflight: {
+        kind: 'boolean',
+        default: true,
+        brief: 'Check model quota before running (use --no-preflight to skip)',
+      },
+    },
+    positional: {
+      kind: 'tuple',
+      parameters: [
+        {
+          brief: 'Path to the plan file to implement',
+          parse: String,
+          placeholder: 'plan-file',
+        },
+      ],
+    },
+  },
+  docs: {
+    brief: 'Execute an implementation plan',
+    fullDescription,
+  },
+});

package/src/commands/implement/impl.ts

@@ -0,0 +1,99 @@
+import { existsSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { runCaptured } from '@aibridge/proc';
+import type { LocalContext } from '../../context.ts';
+import { delegate } from '../../delegate.ts';
+import { DEFAULT_IMPLEMENTER, formatUnknownModelError, resolveModel } from '../../models.ts';
+import { preflightModel, renderPreflightRefusal } from '../../quotaPreflight.ts';
+import { startRun } from '../../runlog.ts';
+
+export interface ImplementFlags {
+  readonly model?: string;
+  readonly timeout?: number;
+  readonly preflight: boolean;
+}
+
+export default async function implement(
+  this: LocalContext,
+  flags: ImplementFlags,
+  planFile: string,
+): Promise<void> {
+  const inputSlug = flags.model ?? DEFAULT_IMPLEMENTER;
+  const model = resolveModel(inputSlug);
+  if (!model) {
+    this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
+    this.process.exitCode = 2;
+    return;
+  }
+
+  const cwd = this.process.cwd();
+  const absPlanPath = isAbsolute(planFile) ? planFile : resolve(cwd, planFile);
+  if (!existsSync(absPlanPath)) {
+    this.process.stderr.write(`aibridge implement: plan file "${absPlanPath}" not found\n`);
+    this.process.exitCode = 2;
+    return;
+  }
+
+  if (flags.preflight) {
+    const verdict = await preflightModel(model);
+    if (!verdict.ok) {
+      this.process.stderr.write(`${renderPreflightRefusal('implement', verdict)}\n`);
+      this.process.exitCode = 3;
+      return;
+    }
+    if (verdict.warning) this.process.stderr.write(`aibridge implement: ${verdict.warning}\n`);
+  }
+
+  const timeoutSec = flags.timeout ?? 1800;
+  const run = startRun('implement', `${model.spec.slug}: ${planFile}`);
+
+  const implementPrompt =
+    `Read the implementation plan file at ${absPlanPath} and implement it EXACTLY.\n` +
+    `Edit only the files it names. Run the project's REAL typecheck and tests and fix until green.\n` +
+    `Do NOT commit, push, or delete unrelated files. Reply with a short summary (files changed + final typecheck/test results).`;
+
+  const outcome = await delegate({
+    model,
+    prompt: implementPrompt,
+    tools: true,
+    timeoutSec,
+    cwd,
+    run,
+  });
+
+  if (!outcome.ok) {
+    this.process.stderr.write(`${outcome.message}\n`);
+    this.process.exitCode = 1;
+    return;
+  }
+
+  const diffRes = await runCaptured('git', ['diff', '--stat'], { cwd });
+  const diffStat = diffRes.stdout.trim();
+
+  const statusRes = await runCaptured('git', ['status', '--porcelain'], { cwd });
+  let untrackedCount = 0;
+  if (statusRes.code === 0) {
+    for (const line of statusRes.stdout.split(/\r?\n/)) {
+      if (line.startsWith('??')) {
+        untrackedCount++;
+      }
+    }
+  }
+
+  if (diffStat.length === 0 && untrackedCount === 0) {
+    this.process.stderr.write(
+      `aibridge implement: delegate completed but made zero working tree changes.\n`,
+    );
+    this.process.exitCode = 1;
+    return;
+  }
+
+  const outputParts = [outcome.response, ''];
+  if (diffStat.length > 0) {
+    outputParts.push(diffStat);
+  }
+  outputParts.push(`untracked files: ${untrackedCount}`);
+  outputParts.push(`run: ${run.id}`);
+
+  this.process.stdout.write(`${outputParts.join('\n')}\n`);
+}

package/src/commands/plan/command.ts

@@ -0,0 +1,56 @@
+import { buildCommand } from '@stricli/core';
+import { DEFAULT_MODEL, listModelHelpLines } from '../../models.ts';
+import { nonEmptyPrompt, positiveIntSeconds } from '../../parsers.ts';
+import planImpl from './impl.ts';
+
+const fullDescription = [
+  'Produce a detailed implementation plan for a task prompt.',
+  '',
+  'Available models (canonical slug):',
+  ...listModelHelpLines(),
+].join('\n');
+
+export const plan = buildCommand({
+  func: planImpl,
+  parameters: {
+    flags: {
+      model: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: `Model slug (default: ${DEFAULT_MODEL})`,
+      },
+      out: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: 'Where to write the plan (default: <run.dir>/plan.md)',
+      },
+      timeout: {
+        kind: 'parsed',
+        parse: positiveIntSeconds,
+        optional: true,
+        brief: 'Max seconds for planning (default: 1800)',
+      },
+      preflight: {
+        kind: 'boolean',
+        default: true,
+        brief: 'Check model quota before running (use --no-preflight to skip)',
+      },
+    },
+    positional: {
+      kind: 'tuple',
+      parameters: [
+        {
+          brief: 'Task prompt to expand into a detailed implementation plan',
+          parse: nonEmptyPrompt,
+          placeholder: 'task-prompt',
+        },
+      ],
+    },
+  },
+  docs: {
+    brief: 'Produce a detailed implementation plan for a task prompt',
+    fullDescription,
+  },
+});

package/src/commands/plan/impl.ts

@@ -0,0 +1,172 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+import { runCaptured } from '@aibridge/proc';
+import type { LocalContext } from '../../context.ts';
+import { delegate } from '../../delegate.ts';
+import { DEFAULT_MODEL, formatUnknownModelError, resolveModel } from '../../models.ts';
+import { preflightModel, renderPreflightRefusal } from '../../quotaPreflight.ts';
+import { startRun } from '../../runlog.ts';
+
+export interface PlanFlags {
+  readonly model?: string;
+  readonly out?: string;
+  readonly timeout?: number;
+  readonly preflight: boolean;
+}
+
+export function countOpenQuestions(markdown: string): number {
+  const headingIdx = markdown.search(/^## Open questions[ \t]*$/m);
+  if (headingIdx === -1) return 0;
+
+  const afterHeading = markdown.slice(headingIdx);
+  const lines = afterHeading.split(/\r?\n/);
+  lines.shift();
+
+  let count = 0;
+  for (const line of lines) {
+    if (/^## /.test(line)) break;
+    const trimmed = line.trim();
+    if (trimmed === 'None.' && count === 0) return 0;
+    if (/^[-*] /.test(trimmed)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+async function getPorcelainStatus(cwd: string): Promise<Set<string>> {
+  const res = await runCaptured('git', ['status', '--porcelain'], { cwd });
+  if (res.code !== 0) return new Set();
+  const set = new Set<string>();
+  for (const line of res.stdout.split(/\r?\n/)) {
+    if (line.trim().length > 0) {
+      set.add(line);
+    }
+  }
+  return set;
+}
+
+function extractPathFromPorcelainLine(line: string): string {
+  let content = line.slice(3).trim();
+  if (content.includes(' -> ')) {
+    const parts = content.split(' -> ');
+    content = (parts[parts.length - 1] ?? '').trim();
+  }
+  if (content.startsWith('"') && content.endsWith('"')) {
+    content = content.slice(1, -1);
+  }
+  return content;
+}
+
+export default async function plan(
+  this: LocalContext,
+  flags: PlanFlags,
+  taskPrompt: string,
+): Promise<void> {
+  const inputSlug = flags.model ?? DEFAULT_MODEL;
+  const model = resolveModel(inputSlug);
+  if (!model) {
+    this.process.stderr.write(`${formatUnknownModelError(inputSlug)}\n`);
+    this.process.exitCode = 2;
+    return;
+  }
+
+  if (flags.preflight) {
+    const verdict = await preflightModel(model);
+    if (!verdict.ok) {
+      this.process.stderr.write(`${renderPreflightRefusal('plan', verdict)}\n`);
+      this.process.exitCode = 3;
+      return;
+    }
+    if (verdict.warning) this.process.stderr.write(`aibridge plan: ${verdict.warning}\n`);
+  }
+
+  const timeoutSec = flags.timeout ?? 1800;
+  const cwd = this.process.cwd();
+  const promptSnippet = taskPrompt.replace(/\r?\n/g, ' ').slice(0, 80);
+  const run = startRun('plan', `${model.spec.slug}: ${promptSnippet}`);
+
+  const absOutPath = flags.out
+    ? isAbsolute(flags.out)
+      ? flags.out
+      : resolve(cwd, flags.out)
+    : resolve(run.dir, 'plan.md');
+
+  const beforePorcelain = await getPorcelainStatus(cwd);
+
+  const plannerPrompt =
+    `You are a senior implementation planner. Study the real codebase with your tools at ${cwd}.\n` +
+    `Design module boundaries, interfaces, and naming. Name every file to touch and describe what changes; define clear verification gates.\n` +
+    `Write EXACTLY one file to the absolute path: ${absOutPath}\n` +
+    `Touch nothing else in the working tree.\n` +
+    `End the document with a section titled "## Open questions" (write "None." under it if you are confident and have no open questions).\n` +
+    `Do not commit or push.\n\n` +
+    `Task Prompt:\n${taskPrompt}`;
+
+  const outcome = await delegate({
+    model,
+    prompt: plannerPrompt,
+    tools: true,
+    timeoutSec,
+    cwd,
+    run,
+  });
+
+  if (!outcome.ok) {
+    this.process.stderr.write(`${outcome.message}\n`);
+    this.process.exitCode = 1;
+    return;
+  }
+
+  if (!existsSync(absOutPath)) {
+    this.process.stderr.write(`aibridge plan: plan file was not written to ${absOutPath}\n`);
+    this.process.exitCode = 1;
+    return;
+  }
+
+  const planContent = readFileSync(absOutPath, 'utf8');
+  if (planContent.trim().length === 0) {
+    this.process.stderr.write(`aibridge plan: plan file at ${absOutPath} is empty\n`);
+    this.process.exitCode = 1;
+    return;
+  }
+
+  if (!/^## Open questions/m.test(planContent)) {
+    this.process.stderr.write(
+      `aibridge plan: plan file at ${absOutPath} missing required "## Open questions" section\n`,
+    );
+    this.process.exitCode = 1;
+    return;
+  }
+
+  const afterPorcelain = await getPorcelainStatus(cwd);
+  const normalizedOut = resolve(absOutPath);
+  const normalizedCwd = resolve(cwd);
+  const isOutInRepo = normalizedOut.startsWith(normalizedCwd);
+
+  const unexpectedPaths: string[] = [];
+  for (const line of afterPorcelain) {
+    if (!beforePorcelain.has(line)) {
+      const relPath = extractPathFromPorcelainLine(line);
+      const absPath = resolve(cwd, relPath);
+      if (isOutInRepo && absPath === normalizedOut) {
+        continue;
+      }
+      unexpectedPaths.push(relPath);
+    }
+  }
+
+  if (unexpectedPaths.length > 0) {
+    this.process.stderr.write(
+      `aibridge plan: unexpected working tree changes beyond plan file:\n${unexpectedPaths.map(p => `  ${p}`).join('\n')}\n`,
+    );
+    this.process.exitCode = 1;
+    return;
+  }
+
+  const openQuestions = countOpenQuestions(planContent);
+
+  this.process.stdout.write(
+    `plan: ${absOutPath}\nopen questions: ${openQuestions}\nrun: ${run.id}\n`,
+  );
+}

package/src/commands/plan/plan.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { countOpenQuestions } from './impl.ts';
+
+describe('countOpenQuestions', () => {
+  it('returns 0 for None. section', () => {
+    const md = `# Title\n\n## Open questions\n\nNone.\n`;
+    expect(countOpenQuestions(md)).toBe(0);
+  });
+
+  it('returns 0 for empty section', () => {
+    const md = `# Title\n\n## Open questions\n\n`;
+    expect(countOpenQuestions(md)).toBe(0);
+  });
+
+  it('counts bullet points correctly', () => {
+    const md = `# Title\n\n## Open questions\n- Question 1?\n* Question 2?\n\n## Next section\n`;
+    expect(countOpenQuestions(md)).toBe(2);
+  });
+});

package/src/commands/quota/command.ts

@@ -0,0 +1,30 @@
+import { buildCommand } from '@stricli/core';
+import quotaImpl from './impl.ts';
+
+const fullDescription = [
+  'agy: reads its cached OAuth token (~/.gemini/antigravity-cli/) and asks the',
+  'Cloud Code API for per-model remaining quota. EXHAUSTED means agy turns on',
+  'that model fail with an empty answer until the reset time.',
+  'codex: reads ~/.codex/auth.json and asks the ChatGPT usage endpoint for the',
+  '5-hour and weekly windows (used % + reset). No separate logins for either.',
+  'claude: shells out to `claude -p "/usage"` (the slow leg, ~5-10s) and parses',
+  'the session + weekly windows — no HTTP endpoint exists and we never touch',
+  'the Keychain; the claude CLI uses its own credentials.',
+].join('\n');
+
+export const quota = buildCommand({
+  func: quotaImpl,
+  parameters: {
+    flags: {
+      json: {
+        kind: 'boolean',
+        withNegated: false,
+        brief: 'Emit the raw snapshot as JSON',
+      },
+    },
+  },
+  docs: {
+    brief: 'Show agy / codex / claude quota with reset times',
+    fullDescription,
+  },
+});