@aibridge/cli 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,184 @@
+import { CommandContext } from "@stricli/core";
+import { AgyQuotaSnapshot } from "@aibridge/agy";
+import { ClaudeQuotaSnapshot } from "@aibridge/claude";
+import { CodexQuotaSnapshot } from "@aibridge/codex";
+//#region src/context.d.ts
+interface LocalContext extends CommandContext {
+  /** Full Node process — satisfies stricli WritableStreams + exitCode/env/cwd used by impls. */
+  readonly process: NodeJS.Process;
+}
+declare function buildContext(process: NodeJS.Process): LocalContext;
+//#endregion
+//#region src/app.d.ts
+declare const app: import("@stricli/core").Application<LocalContext>;
+/** Public entry used by cli.ts and index.ts — preserves runCli(ctx, argv) surface. */
+declare function runCli(ctx: LocalContext, argv: readonly string[]): Promise<void>;
+//#endregion
+//#region src/models.d.ts
+/**
+ * Canonical model registry and resolution for aibridge.
+ *
+ * Models are registered by canonical, provider-qualified slug —
+ * `<vendor>-<cli>/<model>[-<effort>]`, e.g. `openai-codex/gpt-5.6-sol-high`.
+ * Canonical slugs only — no short aliases, by design.
+ */
+type Backend = 'agy' | 'claude' | 'codex' | 'grok';
+type Effort = 'low' | 'medium' | 'high' | 'xhigh' | 'max';
+interface ModelSpec {
+  readonly slug: string;
+  readonly backend: Backend;
+  readonly backendModel: string | undefined;
+  readonly efforts: readonly Effort[] | null;
+  readonly defaultEffort?: Effort;
+  readonly brief: string;
+}
+interface ResolvedModel {
+  readonly spec: ModelSpec;
+  readonly effort: Effort | undefined;
+}
+declare const MODELS: Record<string, ModelSpec>;
+declare const DEFAULT_MODEL = "xai-grok/grok-4.5";
+declare const DEFAULT_IMPLEMENTER = "google-antigravity/gemini-3.6-flash";
+declare const DEFAULT_IMAGE_GEN = "openai-codex/gpt-5.6-sol";
+declare function supportsImageGen(resolved: ResolvedModel): boolean;
+declare function resolveModel(input: string): ResolvedModel | undefined;
+declare function backendModelId(resolved: ResolvedModel): string | undefined;
+declare function listModelHelpLines(opts?: {
+  readonly imageOnly?: boolean;
+}): string[];
+declare function formatUnknownModelError(input: string): string;
+declare function formatImageGenModelError(input: string, resolved: ResolvedModel): string;
+//#endregion
+//#region src/driver.d.ts
+type Availability = {
+  readonly ok: true;
+  readonly version: string;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+interface DelegationTask {
+  readonly prompt: string;
+  readonly tools: boolean;
+  readonly timeoutSec: number;
+  readonly cwd: string;
+  readonly backendModel: string | undefined;
+  readonly effort: Effort | undefined;
+  readonly onStdout?: (chunk: string) => void;
+  readonly onStderr?: (chunk: string) => void;
+  readonly onSpawn?: (pid: number) => void;
+}
+type DelegationResult = {
+  readonly ok: true;
+  readonly response: string;
+  readonly exitCode: number;
+} | {
+  readonly ok: false;
+  readonly kind: 'not-found' | 'spawn' | 'timeout' | 'no-answer';
+  readonly message: string;
+  readonly exitCode: number | null;
+};
+type QuotaSnapshot = AgyQuotaSnapshot | CodexQuotaSnapshot | ClaudeQuotaSnapshot;
+interface ImageGenRequest {
+  readonly prompt: string;
+  readonly workDir: string;
+  readonly backendModel: string | undefined;
+  readonly effort: Effort | undefined;
+  readonly quality: string;
+  readonly size: {
+    readonly w: number;
+    readonly h: number;
+  } | undefined;
+  readonly imagePaths: readonly string[];
+  readonly timeoutSec: number;
+  readonly forceful: boolean;
+  readonly minBytes: number;
+}
+type ImageResult = {
+  readonly kind: 'ok';
+  readonly path: string;
+  readonly bytes: number;
+} | {
+  readonly kind: 'suspect';
+} | {
+  readonly kind: 'error';
+  readonly reason: string;
+};
+interface AgentCliDriver {
+  probe(): Promise<Availability>;
+  run(task: DelegationTask): Promise<DelegationResult>;
+  quota?(): Promise<QuotaSnapshot>;
+  generateImage?(req: ImageGenRequest): Promise<ImageResult>;
+}
+//#endregion
+//#region src/runlog.d.ts
+interface RunMeta {
+  readonly id: string;
+  readonly command: string;
+  readonly detail: string;
+  pid: number | null;
+  readonly startedAt: string;
+  endedAt: string | null;
+  status: 'running' | 'done' | 'error' | 'timeout' | 'stale';
+  exitCode: number | null;
+}
+interface RunLog {
+  readonly id: string;
+  readonly dir: string;
+  setPid(pid: number): void;
+  stdout(chunk: string): void;
+  stderr(chunk: string): void;
+  finish(status: 'done' | 'error' | 'timeout', exitCode: number | null): void;
+}
+declare function startRun(command: string, detail: string): RunLog;
+declare function listRuns(): RunMeta[];
+declare function readRunLogs(id: string): {
+  meta: RunMeta;
+  stdout: string;
+  stderr: string;
+} | null;
+//#endregion
+//#region src/delegate.d.ts
+interface DelegateOptions {
+  readonly model: ResolvedModel;
+  readonly prompt: string;
+  readonly tools: boolean;
+  readonly timeoutSec: number;
+  readonly cwd: string;
+  readonly run: RunLog;
+}
+type DelegateOutcome = DelegationResult;
+declare function delegate(opts: DelegateOptions, driver?: AgentCliDriver): Promise<DelegateOutcome>;
+//#endregion
+//#region src/drivers.d.ts
+declare function getDriver(backend: Backend): AgentCliDriver;
+//#endregion
+//#region src/parsers.d.ts
+/**
+ * stricli `parse` functions (string -> T). Throwing inside one makes stricli
+ * reject the argument up-front with a clean, flag-named error — instead of
+ * silently letting a bad value (NaN, Infinity, "") flow into an impl where it
+ * gets masked or, worse, breaks `setTimeout`.
+ */
+declare function positiveIntSeconds(input: string): number;
+declare function nonEmptyPrompt(input: string): string;
+//#endregion
+//#region src/quotaPreflight.d.ts
+type PreflightVerdict = {
+  readonly ok: true;
+  readonly warning?: string;
+} | {
+  readonly ok: false;
+  readonly message: string;
+  readonly resetAt: string | undefined;
+};
+declare function evaluateAgyPreflight(snapshot: AgyQuotaSnapshot, backendModel: string): PreflightVerdict;
+declare function evaluateCodexPreflight(snapshot: CodexQuotaSnapshot): PreflightVerdict;
+declare function preflightModel(resolved: ResolvedModel): Promise<PreflightVerdict>;
+declare function preflightCodex(): Promise<PreflightVerdict>;
+declare function renderPreflightRefusal(cmd: string, verdict: {
+  message: string;
+  resetAt: string | undefined;
+}): string;
+//#endregion
+export { type AgentCliDriver, type Backend, DEFAULT_IMAGE_GEN, DEFAULT_IMPLEMENTER, DEFAULT_MODEL, type DelegateOptions, type DelegateOutcome, type DelegationResult, type DelegationTask, type Effort, type LocalContext, MODELS, type ModelSpec, type PreflightVerdict, type ResolvedModel, type RunLog, type RunMeta, app, backendModelId, buildContext, delegate, evaluateAgyPreflight, evaluateCodexPreflight, formatImageGenModelError, formatUnknownModelError, getDriver, listModelHelpLines, listRuns, nonEmptyPrompt, positiveIntSeconds, preflightCodex, preflightModel, readRunLogs, renderPreflightRefusal, resolveModel, runCli, startRun, supportsImageGen };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { C as listModelHelpLines, S as formatUnknownModelError, T as supportsImageGen, _ as DEFAULT_IMPLEMENTER, a as readRunLogs, b as backendModelId, c as evaluateCodexPreflight, d as renderPreflightRefusal, f as delegate, g as DEFAULT_IMAGE_GEN, h as positiveIntSeconds, i as listRuns, l as preflightCodex, m as nonEmptyPrompt, n as app, o as startRun, p as getDriver, r as runCli, s as evaluateAgyPreflight, t as buildContext, u as preflightModel, v as DEFAULT_MODEL, w as resolveModel, x as formatImageGenModelError, y as MODELS } from "./context-BLjTHa41.mjs";
+export { DEFAULT_IMAGE_GEN, DEFAULT_IMPLEMENTER, DEFAULT_MODEL, MODELS, app, backendModelId, buildContext, delegate, evaluateAgyPreflight, evaluateCodexPreflight, formatImageGenModelError, formatUnknownModelError, getDriver, listModelHelpLines, listRuns, nonEmptyPrompt, positiveIntSeconds, preflightCodex, preflightModel, readRunLogs, renderPreflightRefusal, resolveModel, runCli, startRun, supportsImageGen };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@aibridge/cli",
+  "version": "0.0.1",
+  "description": "CLI that bridges tasks to non-Claude AI CLIs (plan / implement / review / subagent / image-gen)",
+  "type": "module",
+  "license": "MIT",
+  "engines": {
+    "node": ">=24.11"
+  },
+  "keywords": [
+    "aibridge",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fishballapp/aibridge.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/fishballapp/aibridge#readme",
+  "bugs": {
+    "url": "https://github.com/fishballapp/aibridge/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "bin": {
+    "aibridge": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@stricli/core": "1.3.0",
+    "@aibridge/proc": "0.0.1",
+    "@aibridge/codex": "0.0.1",
+    "@aibridge/claude": "0.0.1",
+    "@aibridge/grok": "0.0.1",
+    "@aibridge/agy": "0.0.1"
+  },
+  "devDependencies": {
+    "tsdown": "0.22.14"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}

package/src/app.exit-code.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import { runCli } from './app.ts';
+import type { LocalContext } from './context.ts';
+
+function fakeCtx(): LocalContext & { _stdout: string[]; _stderr: string[] } {
+  const _stdout: string[] = [];
+  const _stderr: string[] = [];
+  const processLike = {
+    stdout: {
+      write: (s: string) => {
+        _stdout.push(s);
+        return true;
+      },
+    },
+    stderr: {
+      write: (s: string) => {
+        _stderr.push(s);
+        return true;
+      },
+    },
+    exitCode: undefined as number | undefined,
+    env: { ...process.env, NO_COLOR: '1', STRICLI_NO_COLOR: '1' },
+    cwd: () => process.cwd(),
+  };
+  return { process: processLike as unknown as NodeJS.Process, _stdout, _stderr };
+}
+
+describe('stricli exit-code lock & routing', () => {
+  it('unknown command → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['nonsense']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('unknown flag → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['plan', '--not-a-flag', 'x']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('missing required arg → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['plan']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('empty prompt → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['plan', '']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('review with stray positional → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['review', 'stray']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('runs --watch with idPrefix → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['runs', '--watch', 'someid']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('runs --watch with --json → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['runs', '--watch', '--json']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('runs --no-json → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['runs', '--no-json']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('runs --no-watch → 2', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['runs', '--no-watch']);
+    expect(ctx.process.exitCode).toBe(2);
+  });
+
+  it('root --help lists all commands', async () => {
+    const ctx = fakeCtx();
+    await runCli(ctx, ['--help']);
+    const output = ctx._stdout.join('');
+    for (const cmd of ['plan', 'implement', 'review', 'subagent', 'image-gen', 'runs', 'quota']) {
+      expect(output).toContain(cmd);
+    }
+  });
+});

package/src/app.ts

@@ -0,0 +1,49 @@
+import { createRequire } from 'node:module';
+import { buildApplication, buildRouteMap, run } from '@stricli/core';
+import { imageGen } from './commands/image-gen/command.ts';
+import { implement } from './commands/implement/command.ts';
+import { plan } from './commands/plan/command.ts';
+import { quota } from './commands/quota/command.ts';
+import { review } from './commands/review/command.ts';
+import { runs } from './commands/runs/command.ts';
+import { subagent } from './commands/subagent/command.ts';
+import type { LocalContext } from './context.ts';
+import { normalizeExitCode } from './exitCode.ts';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json') as { version: string };
+
+const BRIEF =
+  'Bridge tasks to non-Claude AI CLIs — a plan → implement → review workflow, task delegation, and image generation (codex gpt-image-2 / grok Imagine).';
+
+const routes = buildRouteMap({
+  routes: {
+    plan,
+    implement,
+    review,
+    subagent,
+    'image-gen': imageGen,
+    runs,
+    quota,
+  },
+  docs: {
+    brief: BRIEF,
+  },
+});
+
+export const app = buildApplication(routes, {
+  name: 'aibridge',
+  versionInfo: {
+    currentVersion: version,
+  },
+  scanner: {
+    // Accept --no-preflight / --no-tools while flag keys stay camelCase in TS
+    caseStyle: 'allow-kebab-for-camel',
+  },
+});
+
+/** Public entry used by cli.ts and index.ts — preserves runCli(ctx, argv) surface. */
+export async function runCli(ctx: LocalContext, argv: readonly string[]): Promise<void> {
+  await run(app, argv, ctx);
+  normalizeExitCode(ctx);
+}

package/src/cli.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { runCli } from './app.ts';
+import { buildContext } from './context.ts';
+
+await runCli(buildContext(process), process.argv.slice(2));

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

@@ -0,0 +1,77 @@
+import { buildCommand } from '@stricli/core';
+import { DEFAULT_IMAGE_GEN, listModelHelpLines } from '../../models.ts';
+import { nonEmptyPrompt, positiveIntSeconds } from '../../parsers.ts';
+import imageGenImpl from './impl.ts';
+
+const fullDescription = [
+  "Renders an image by driving the seat's CLI (codex → gpt-image-2, grok →",
+  'Imagine), then verifies the result is a real render before returning it.',
+  '',
+  'Image-gen seats (canonical slug):',
+  ...listModelHelpLines({ imageOnly: true }),
+  `Default: ${DEFAULT_IMAGE_GEN} (gpt-image-2 via codex; historical default).`,
+].join('\n');
+
+export const imageGen = buildCommand({
+  func: imageGenImpl,
+  parameters: {
+    flags: {
+      model: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: `Model slug (default: ${DEFAULT_IMAGE_GEN})`,
+      },
+      out: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: 'Path to write the image (default: ./aibridge-image.png)',
+      },
+      size: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief:
+          'WIDTHxHEIGHT (codex: each edge ÷16; grok: mapped to aspect_ratio, then optionally resized)',
+      },
+      image: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: 'Reference image path(s), comma-separated — visual reference',
+      },
+      quality: {
+        kind: 'parsed',
+        parse: String,
+        optional: true,
+        brief: 'low | medium | high (codex/gpt-image-2; default high)',
+      },
+      timeout: {
+        kind: 'parsed',
+        parse: positiveIntSeconds,
+        optional: true,
+        brief: 'Max seconds to wait for the render (default: 600)',
+      },
+      json: {
+        kind: 'boolean',
+        withNegated: false,
+        brief: 'Emit a machine-readable JSON result instead of prose',
+      },
+    },
+    positional: {
+      kind: 'tuple',
+      parameters: [
+        {
+          brief: 'Description of the image to generate',
+          parse: nonEmptyPrompt,
+          placeholder: 'prompt',
+        },
+      ],
+    },
+  },
+  docs: {
+    brief: 'Generate a raster image via a model seat',
+    fullDescription,
+  },
+});