aiki-cli 0.2.0

package/dist/cli/show.js

@@ -0,0 +1,73 @@
+// `aiki show <run-id>` (§5) — print a stored run's final report; `--raw` lists artifact files.
+// A partial/aborted run (no final-report.md) falls back to a short summary from meta.json (grilled
+// 2026-07-04). Run-id arg is resolved by suffix/substring (no arg → latest).
+import { resolve } from 'node:path';
+import { listArtifacts, readFinalReport, readJsonArtifact, resolveRunId, runDir } from '../storage/runs-read.js';
+import { writeCouncilHtml } from '../council/view.js';
+import { openInBrowser } from '../council/open.js';
+/** Emit the resolution error for a failed run-id match. */
+function reportMatchError(match) {
+    if (match.kind === 'none') {
+        process.stderr.write('no runs found under .aiki/runs/ — run one first (`aiki run idea-refinement …`)\n');
+    }
+    else if (match.kind === 'no-match') {
+        process.stderr.write(`no run matches "${match.arg}". Omit the id for the most recent run.\n`);
+    }
+    else {
+        process.stderr.write(`"${match.arg}" is ambiguous — matches:\n${match.candidates.map((c) => `  ${c}`).join('\n')}\n`);
+    }
+}
+/** Short summary for a run with no final report (aborted/partial). */
+function partialSummary(runId, meta, artifacts) {
+    const stages = artifacts.filter((f) => /^\d\d?[-/]/.test(f)).map((f) => f.split('/')[0]);
+    const uniqueStages = [...new Set(stages)];
+    const lines = [`  run ${runId} — incomplete (no final report)`];
+    if (meta) {
+        lines.push(`  workflow:     ${meta.workflow}`);
+        lines.push(`  exit status:  ${meta.exit_status}${meta.aborted ? ' (aborted:true)' : ''}`);
+        lines.push(`  calls:        ${meta.call_count}/${meta.budget.limit}`);
+        if (meta.flags?.length)
+            lines.push(`  flags:        ${meta.flags.join(', ')}`);
+    }
+    else {
+        lines.push('  meta.json absent — run likely crashed before finalize.');
+    }
+    lines.push(`  stages on disk: ${uniqueStages.join(', ') || '(none)'}`);
+    lines.push(`  → inspect partial artifacts:  aiki show ${runId} --raw`);
+    return lines.join('\n');
+}
+export async function show(runArg, opts = {}) {
+    const root = opts.root ?? '.aiki';
+    const match = await resolveRunId(runArg, root);
+    if (!match.ok) {
+        reportMatchError(match);
+        return 1;
+    }
+    const dir = runDir(match.runId, root);
+    if (opts.html) {
+        const path = await writeCouncilHtml(match.runId, dir);
+        if (!path) {
+            process.stderr.write(`cannot render council view for ${match.runId}: missing or unreadable meta.json\n`);
+            return 1;
+        }
+        const abs = resolve(path);
+        process.stdout.write(`${abs}\n`);
+        if (opts.open)
+            openInBrowser(abs);
+        return 0;
+    }
+    if (opts.raw) {
+        const files = await listArtifacts(dir);
+        process.stdout.write(`${dir}\n${files.map((f) => `  ${f}`).join('\n')}\n`);
+        return 0;
+    }
+    const report = await readFinalReport(dir);
+    if (report !== null) {
+        process.stdout.write(report.endsWith('\n') ? report : `${report}\n`);
+        return 0;
+    }
+    // No final report → partial/aborted run: summarize instead of failing.
+    const [meta, artifacts] = await Promise.all([readJsonArtifact(dir, 'meta.json'), listArtifacts(dir)]);
+    process.stdout.write(`\n${partialSummary(match.runId, meta, artifacts)}\n\n`);
+    return 0;
+}

package/dist/config/config.js

@@ -0,0 +1,102 @@
+// `.aiki/config.json` loading (T9, §5/§273/§443). Project-local, human-edited config that pins
+// roles + budget/deadline. Precedence is always: run flag > config > built-in default.
+//
+// Design decisions (grilled 2026-07-04, see .agent/STATE.md):
+// - `roles` is a FLAT GLOBAL Partial<RoleMap> — applied as roleOverrides for every workflow via the
+//   existing resolveRoles(workflow, available, overrides) seam. (§273 "config pins roles globally".)
+// - Missing file → defaults (not an error). Present but invalid (bad JSON or schema) → HARD-FAIL with a
+//   message naming the file + the exact problem. We never silently ignore a config the user believes is
+//   active (schema-boundary rule, CLAUDE.md).
+// - The 6h smoke cache is NOT here — it lives in a separate tool-owned .aiki/smoke-cache.json so `doctor`
+//   never rewrites this human-edited file (deviation from the plan's literal "cached in config.json").
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { ProviderIdSchema } from '../schemas/index.js';
+import { DEFAULT_BUDGET, DEFAULT_DEADLINE_MS } from '../orchestration/context.js';
+import { homeAikiRoot } from '../storage/paths.js';
+/** Partial role pin — any subset of the RoleMap roles. `.strict()` so a typo'd key hard-fails. */
+const ConfigRoles = z
+    .object({
+    analyst: ProviderIdSchema.optional(),
+    judge: ProviderIdSchema.optional(),
+    verifier: ProviderIdSchema.optional(),
+    s4: z.array(ProviderIdSchema).min(1).optional(),
+})
+    .strict();
+/** Per-provider model override (V8). Each CLI runs its own model families, so model choice is per
+ *  provider; the id is passed verbatim to the CLI as `--model <id>` (see docs/PROVIDER_NOTES.md). */
+const ProviderModels = z
+    .object({
+    claude: z.string().min(1).optional(),
+    codex: z.string().min(1).optional(),
+    agy: z.string().min(1).optional(),
+})
+    .strict();
+/** The `.aiki/config.json` schema. `.strict()` → an unknown top-level key is a hard-fail (typo guard). */
+export const AikiConfig = z
+    .object({
+    roles: ConfigRoles.optional(),
+    models: ProviderModels.optional(),
+    budget: z.number().int().positive().optional(),
+    deadlineMs: z.number().int().positive().optional(),
+})
+    .strict();
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigError';
+    }
+}
+/**
+ * Load `.aiki/config.json`. Missing → `{}` (defaults). Present-but-invalid (unparseable JSON or a
+ * value that fails the zod schema) → throws `ConfigError` naming the file + the precise problem.
+ */
+export async function loadConfig(root = '.aiki') {
+    const path = join(root, 'config.json');
+    let raw;
+    try {
+        raw = await readFile(path, 'utf8');
+    }
+    catch {
+        return {}; // missing file = use defaults (not an error)
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (e) {
+        throw new ConfigError(`${path}: invalid JSON — ${e.message}`);
+    }
+    const res = AikiConfig.safeParse(parsed);
+    if (!res.success) {
+        const issue = res.error.issues[0];
+        const where = issue?.path.length ? `config.${issue.path.join('.')}` : 'config';
+        throw new ConfigError(`${path}: ${where} — ${issue?.message ?? 'invalid config'}`);
+    }
+    return res.data;
+}
+/** Merge the loaded config over built-in defaults for display (`aiki config`). Roles = pins only. */
+export function effectiveConfig(cfg) {
+    return {
+        budget: cfg.budget ?? DEFAULT_BUDGET,
+        deadlineMs: cfg.deadlineMs ?? DEFAULT_DEADLINE_MS,
+        roles: cfg.roles ?? {},
+        models: cfg.models ?? {},
+    };
+}
+/** Merge a global (base) config with a project (override): project wins per field; roles/models KEYS merge. */
+export function mergeConfig(base, over) {
+    const merged = { ...base, ...over };
+    if (base.roles || over.roles)
+        merged.roles = { ...base.roles, ...over.roles };
+    if (base.models || over.models)
+        merged.models = { ...base.models, ...over.models };
+    return merged;
+}
+/** Layered config: global `~/.aiki/config.json` (base) overlaid by the project `.aiki/config.json`. What
+ *  the CLI actually uses (V8) — a user can set defaults once in the global file and override per project. */
+export async function loadLayeredConfig() {
+    const [global, project] = await Promise.all([loadConfig(homeAikiRoot()), loadConfig('.aiki')]);
+    return mergeConfig(global, project);
+}

package/dist/config/smoke-cache.js

@@ -0,0 +1,65 @@
+// `.aiki/smoke-cache.json` — the §242 6h smoke-test cache. Tool-owned (doctor writes it), kept SEPARATE
+// from the human-edited .aiki/config.json so doctor never clobbers hand-edits (grilled 2026-07-04).
+//
+// Unlike config.json, a corrupt/missing cache is NOT a hard error — it's disposable, so we silently
+// treat it as empty and re-run the smoke. An entry is stale when it's older than 6h OR the provider's
+// detected version has changed since it was cached (an upgrade should re-prove the provider).
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { ProviderIdSchema } from '../schemas/index.js';
+export const SMOKE_TTL_MS = 6 * 60 * 60 * 1000; // §242
+const SmokeCacheEntrySchema = z.object({
+    ok: z.boolean(),
+    error: z.string().optional(),
+    durationMs: z.number().nonnegative(),
+    version: z.string().nullable(), // detected --version when cached; version change ⇒ stale
+    at: z.string(), // ISO-8601 of when the smoke ran
+});
+const SmokeCacheSchema = z.record(ProviderIdSchema, SmokeCacheEntrySchema);
+/** Pure: is a cached entry still usable? Fresh = same detected version AND within the TTL. */
+export function isFresh(entry, detectedVersion, nowMs, ttlMs = SMOKE_TTL_MS) {
+    if (entry.version !== detectedVersion)
+        return false;
+    const at = Date.parse(entry.at);
+    if (Number.isNaN(at))
+        return false;
+    return nowMs - at < ttlMs;
+}
+/** Pure: build a cache entry from a fresh smoke result. */
+export function toEntry(smoke, version, at = new Date()) {
+    return {
+        ok: smoke.ok,
+        ...(smoke.error ? { error: smoke.error } : {}),
+        durationMs: smoke.durationMs,
+        version,
+        at: at.toISOString(),
+    };
+}
+/** Reconstruct a Smoke (for rendering) from a cached entry. */
+export function entryToSmoke(entry) {
+    return {
+        ok: entry.ok,
+        ...(entry.error ? { error: entry.error } : {}),
+        nonce: 'cached',
+        durationMs: entry.durationMs,
+    };
+}
+/** Read the cache; missing or corrupt → `{}` (disposable, never throws). */
+export async function readSmokeCache(root = '.aiki') {
+    try {
+        const parsed = SmokeCacheSchema.safeParse(JSON.parse(await readFile(join(root, 'smoke-cache.json'), 'utf8')));
+        return parsed.success ? parsed.data : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Atomically write the cache (temp + rename). */
+export async function writeSmokeCache(cache, root = '.aiki') {
+    await mkdir(root, { recursive: true });
+    const full = join(root, 'smoke-cache.json');
+    const tmp = `${full}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(cache, null, 2)}\n`, 'utf8');
+    await rename(tmp, full);
+}

package/dist/council/open.js

@@ -0,0 +1,26 @@
+// Open a finished run's council HTML in the OS browser. Shared by `aiki show --open`, the headless
+// `aiki run` success path, and the TUI. Best-effort: auto-open is a convenience, never a run failure.
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { writeCouncilHtml } from './view.js';
+/** Open a file in the OS default handler. Detached + unref so aiki can exit immediately. */
+export function openInBrowser(path) {
+    const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    const child = spawn(cmd, [path], { stdio: 'ignore', detached: true, shell: process.platform === 'win32' });
+    child.on('error', () => process.stderr.write(`could not auto-open — open it manually: ${path}\n`));
+    child.unref();
+}
+/** Render a finished run's council HTML and open it. Never throws — returns the absolute path, or null. */
+export async function openCouncilHtml(runId, dir) {
+    try {
+        const path = await writeCouncilHtml(runId, dir);
+        if (!path)
+            return null;
+        const abs = resolve(path);
+        openInBrowser(abs);
+        return abs;
+    }
+    catch {
+        return null;
+    }
+}