aiki-cli 0.2.0

package/dist/providers/detect.js

@@ -0,0 +1,21 @@
+import { runCommand } from './spawn.js';
+const DETECT_TIMEOUT_MS = 5000;
+const INSTALL_HINT = {
+    claude: "not on PATH — install: npm i -g @anthropic-ai/claude-code",
+    codex: "not on PATH — install: npm i -g @openai/codex",
+    agy: "not on PATH — install the Antigravity CLI (agy) and log in",
+};
+/** Pull a semver-ish token out of a `--version` line (formats vary per CLI). */
+export function parseVersion(stdout) {
+    const m = stdout.match(/\d+\.\d+\.\d+[\w.-]*/);
+    return m ? m[0] : undefined;
+}
+/** Detection: PATH lookup + `--version`, 5s timeout, no model calls (§8). */
+export async function detect(id, run = runCommand) {
+    const r = await run(id, ['--version'], DETECT_TIMEOUT_MS);
+    if (r.notFound) {
+        return { id, status: 'NOT_INSTALLED', hint: INSTALL_HINT[id] };
+    }
+    const version = parseVersion(r.stdout) ?? parseVersion(r.stderr);
+    return { id, status: 'READY', version };
+}

package/dist/providers/probe.js

@@ -0,0 +1,43 @@
+import { captureFull } from './spawn.js';
+const PROBE_TIMEOUT_MS = 5000;
+// Which binary + args to ask for --help, per provider (codex flags live under `exec`).
+const HELP_INVOCATION = {
+    claude: { bin: 'claude', args: ['--help'] },
+    codex: { bin: 'codex', args: ['exec', '--help'] },
+    agy: { bin: 'agy', args: ['--help'] },
+};
+/**
+ * Parse a --help dump into a FlagProfile. Pure — the seam T2 tests directly.
+ * Flag names verified against installed CLIs at build time (see docs/PROVIDER_NOTES.md).
+ */
+export function parseFlagProfile(id, help) {
+    const has = (re) => re.test(help);
+    switch (id) {
+        case 'claude':
+            return {
+                id,
+                jsonOutput: has(/--output-format/),
+                readOnlyFlag: has(/--permission-mode/) ? 'plan' : 'none',
+            };
+        case 'codex':
+            return {
+                id,
+                jsonOutput: has(/--json\b/),
+                readOnlyFlag: has(/--sandbox/) ? 'sandbox' : 'none',
+            };
+        case 'agy':
+            // agy has no JSON-output flag; `-p` returns raw text (the JSON we ask for) → §14 extraction.
+            // Read-only is best-effort via `--sandbox` (terminal restrictions); see docs/PROVIDER_NOTES.md.
+            return {
+                id,
+                jsonOutput: false,
+                readOnlyFlag: has(/--sandbox/) ? 'sandbox' : 'none',
+            };
+    }
+}
+/** Flag probe: `<bin> --help`, regex-match §7.3 flags, no model calls (§8). */
+export async function probeFlags(id, capture = captureFull) {
+    const { bin, args } = HELP_INVOCATION[id];
+    const help = await capture(id, bin, args, PROBE_TIMEOUT_MS);
+    return parseFlagProfile(id, help);
+}

package/dist/providers/profiles.js

@@ -0,0 +1,38 @@
+// Static capability profiles (§7.4), merged with live detection + flag probe into the
+// machine-readable profile that `aiki providers --json` prints (§5).
+//
+// Ordinals (1–3) are hand-maintained and exist ONLY to drive default role assignment (§10).
+// They are NOT a benchmark output — do not build dynamic scoring in v1 (§7.4).
+//
+// CAVEAT (revisit at T5, per .agent/STATE.md): the plan's §7.4 table describes the OLD `gemini`
+// CLI. Our third provider is `agy` (Antigravity / Gemini 3.1 Pro) — strong AND quota-metered,
+// not the old free-tier gemini. We kept §7.4's ordinals here to avoid silently changing default
+// role assignment before T5, but corrected `cost` to `quota-metered` (using `free-tier-generous`
+// would contradict a decided fact). The ordinals + their role impact are re-decided at T5.
+import { createRequire } from 'node:module';
+import { DISPLAY_NAME, PROVIDER_IDS } from './types.js';
+import { detect } from './detect.js';
+import { probeFlags } from './probe.js';
+// Read the JSON via require: keeps `rootDir` = src clean (no dist copy step needed for an import
+// assertion) and works under NodeNext without pulling the file into the TS program.
+const require = createRequire(import.meta.url);
+const STATIC_PROFILES = require('./profiles.json');
+/**
+ * Resolve every provider's machine profile: detection (PATH + --version) and flag probe (--help),
+ * merged with the static capability ordinals. No model calls (§8) — this is fast and safe.
+ */
+export async function resolveProfiles() {
+    return Promise.all(PROVIDER_IDS.map(async (id) => {
+        const det = await detect(id);
+        const installed = det.status === 'READY';
+        const flags = installed ? await probeFlags(id) : null;
+        return {
+            id,
+            displayName: DISPLAY_NAME[id],
+            installed,
+            version: det.version ?? null,
+            flags: flags ? { jsonOutput: flags.jsonOutput, readOnlyFlag: flags.readOnlyFlag } : null,
+            capability: STATIC_PROFILES[id],
+        };
+    }));
+}

package/dist/providers/profiles.json

@@ -0,0 +1,5 @@
+{
+  "claude": { "reasoning": 3, "codeNav": 3, "jsonReliability": 3, "cost": "quota-metered", "contextExplore": 3 },
+  "codex": { "reasoning": 2, "codeNav": 3, "jsonReliability": 2, "cost": "quota-metered", "contextExplore": 2 },
+  "agy": { "reasoning": 2, "codeNav": 2, "jsonReliability": 2, "cost": "quota-metered", "contextExplore": 2 }
+}

package/dist/providers/smoke.js

@@ -0,0 +1,26 @@
+import { randomBytes } from 'node:crypto';
+import { ADAPTERS } from './adapters.js';
+const SMOKE_TIMEOUT_MS = 60_000;
+function nonce() {
+    return randomBytes(4).toString('hex'); // 8 hex chars
+}
+/**
+ * One cheap model call per provider (§8): ask it to echo a random nonce as JSON.
+ * Pass = process exits ok within timeout AND extracted JSON echoes the nonce.
+ */
+export async function smokeTest(id, flags, deps = {}) {
+    const adapter = ADAPTERS[id];
+    const n = nonce();
+    const prompt = `Reply with ONLY this JSON and nothing else: {"ok": true, "echo": "${n}"}`;
+    const res = await adapter.run({ prompt, cwd: process.cwd(), timeoutMs: SMOKE_TIMEOUT_MS, expectJson: true, readOnly: true }, flags, deps);
+    if (!res.ok) {
+        return { ok: false, error: res.error, nonce: n, durationMs: res.durationMs, detail: res.stderrTail.slice(-160) };
+    }
+    const echoed = res.json?.echo;
+    return {
+        ok: echoed === n,
+        nonce: n,
+        echoed: typeof echoed === 'string' ? echoed : undefined,
+        durationMs: res.durationMs,
+    };
+}

package/dist/providers/spawn.js

@@ -0,0 +1,152 @@
+import { execa } from 'execa';
+import { spawn } from 'node:child_process';
+import { openSync, closeSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+const STDERR_TAIL_CAP = 8000;
+let seq = 0;
+/**
+ * Real process runner backing detection and flag probes (metadata calls only).
+ * `shell: false` (execa default) — argv array, no shell interpolation (§7.2 injection safety).
+ * Adapter run() in T2 adds env filtering, process-tree kill, and retry on top of this shape.
+ */
+export const runCommand = async (bin, args, timeoutMs) => {
+    try {
+        const r = await execa(bin, args, { timeout: timeoutMs, reject: false });
+        return {
+            code: r.exitCode ?? null,
+            stdout: r.stdout ?? '',
+            stderr: r.stderr ?? '',
+            timedOut: r.timedOut ?? false,
+            notFound: false,
+        };
+    }
+    catch (e) {
+        const err = e;
+        return {
+            code: err.exitCode ?? null,
+            stdout: err.stdout ?? '',
+            stderr: err.stderr ?? err.message ?? '',
+            timedOut: err.timedOut ?? false,
+            notFound: err.code === 'ENOENT',
+        };
+    }
+};
+/**
+ * Capture a command's full output by redirecting the child's stdout/stderr straight
+ * to a temp file (true fd redirect, not a pipe). Some CLIs (claude) call process.exit()
+ * which truncates async *pipe* writes at ~8KB; execa's own pipe/`{file}` capture hits
+ * this. Inheriting a file fd lets the child write the full ~16KB --help. Fixed internal
+ * argv only — no user input reaches here.
+ */
+export function captureFull(id, bin, args, timeoutMs) {
+    const path = join(tmpdir(), `aiki-probe-${id}-${process.pid}.txt`);
+    const fd = openSync(path, 'w');
+    return new Promise((resolve) => {
+        const child = spawn(bin, args, { stdio: ['ignore', fd, fd] });
+        const timer = setTimeout(() => child.kill('SIGKILL'), timeoutMs);
+        const done = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        child.on('close', done);
+        child.on('error', done); // ENOENT etc → empty file, probe reports drift
+    }).then(() => {
+        closeSync(fd);
+        try {
+            return readFileSync(path, 'utf8');
+        }
+        catch {
+            return '';
+        }
+        finally {
+            rmSync(path, { force: true });
+        }
+    });
+}
+/**
+ * Run a provider CLI and capture its full output for adapter run() (§7.2).
+ * - stdout → temp file via inherited fd (true redirect; avoids claude's 8KB pipe truncation).
+ * - stderr → pipe, kept as a tail (for error classification / stderrTail).
+ * - detached process group so a timeout kills the whole tree, not just the direct child.
+ * - env is supplied filtered by the caller (adapter-core strips /KEY|TOKEN|SECRET/i).
+ */
+export const spawnCapture = (bin, args, { cwd, timeoutMs, env, signal }) => {
+    const started = Date.now();
+    const outPath = join(tmpdir(), `aiki-run-${process.pid}-${seq++}.out`);
+    const fd = openSync(outPath, 'w');
+    return new Promise((resolve) => {
+        let stderr = '';
+        let timedOut = false;
+        let notFound = false;
+        let settled = false;
+        const child = spawn(bin, args, { cwd, env, detached: true, stdio: ['ignore', fd, 'pipe'] });
+        // SIGKILL the whole detached process group. Shared by the timeout and the Ctrl+C abort (T8).
+        const killGroup = () => {
+            try {
+                if (child.pid)
+                    process.kill(-child.pid, 'SIGKILL');
+            }
+            catch {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch {
+                    /* already gone */
+                }
+            }
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            killGroup();
+        }, timeoutMs);
+        // Ctrl+C: kill the in-flight child immediately so no orphaned metered call survives (§472, T8).
+        const onAbort = () => killGroup();
+        if (signal) {
+            if (signal.aborted)
+                killGroup();
+            else
+                signal.addEventListener('abort', onAbort, { once: true });
+        }
+        const finish = (code, signal2) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            try {
+                closeSync(fd);
+            }
+            catch {
+                /* already closed */
+            }
+            let stdout = '';
+            try {
+                stdout = readFileSync(outPath, 'utf8');
+            }
+            catch {
+                /* empty */
+            }
+            rmSync(outPath, { force: true });
+            resolve({
+                code,
+                signal: signal2 ?? null,
+                stdout,
+                stderr: stderr.length > STDERR_TAIL_CAP ? stderr.slice(-STDERR_TAIL_CAP) : stderr,
+                timedOut,
+                notFound,
+                durationMs: Date.now() - started,
+            });
+        };
+        child.stderr?.on('data', (d) => {
+            stderr += d.toString();
+            if (stderr.length > STDERR_TAIL_CAP * 2)
+                stderr = stderr.slice(-STDERR_TAIL_CAP);
+        });
+        child.on('error', (e) => {
+            notFound = e.code === 'ENOENT';
+            finish(null, null);
+        });
+        child.on('close', (code, signal) => finish(code, signal));
+    });
+};

package/dist/providers/types.js

@@ -0,0 +1,17 @@
+// Provider layer types.
+//
+// NOTE: the third provider is `agy` (Antigravity CLI, runs Gemini 3.1 Pro). It replaces the
+// discontinued `gemini` CLI referenced throughout the plan — wherever the plan says "gemini",
+// it now means `agy`. See docs/PROVIDER_NOTES.md.
+export const PROVIDER_IDS = ['claude', 'codex', 'agy'];
+/**
+ * User-facing display names. Internally (ids, artifacts, meta.json, logs) we always use the
+ * true id — `agy` — for audit accuracy. The UI shows the familiar model name instead: users
+ * know "Gemini", not the Antigravity binary. Command/binary references (e.g. "run `agy`") must
+ * still use the real id.
+ */
+export const DISPLAY_NAME = {
+    claude: 'Claude',
+    codex: 'Codex',
+    agy: 'Gemini',
+};