aiki-cli 0.2.0

package/dist/tui/timeline.js

@@ -0,0 +1,91 @@
+// Pure timeline model for the run screen (T8, §4.2). No Ink here — the reducer that turns the
+// engine's stage events into row states, plus provider resolution and glyphs. Unit-tested directly.
+import { DISPLAY_NAME } from '../providers/types.js';
+/** §4.2 state glyphs. */
+export const GLYPH = {
+    pending: '○',
+    running: '◐',
+    done: '●',
+    failed: '✖',
+    skipped: '⊘',
+};
+/** Which provider chip(s) a row shows, from its role hint + the resolved roles. */
+export function stageProviders(role, roles, available) {
+    switch (role) {
+        case 'analyst':
+            return [roles.analyst];
+        case 'judge':
+            return [roles.judge];
+        case 'verifier':
+            return [roles.verifier];
+        case 's4':
+            return roles.s4;
+        case 'all':
+            return available;
+        case null:
+            return [];
+    }
+}
+/** All rows pending, providers resolved — the skeleton drawn before the run starts. */
+export function initTimeline(stages, roles, available) {
+    return stages.map((s) => ({
+        id: s.id,
+        label: s.label,
+        providers: stageProviders(s.role, roles, available),
+        status: 'pending',
+    }));
+}
+export function markStart(rows, id, now) {
+    return rows.map((r) => (r.id === id ? { ...r, status: 'running', startedAt: now } : r));
+}
+export function markEnd(rows, id, status, now) {
+    return rows.map((r) => (r.id === id ? { ...r, status, endedAt: now } : r));
+}
+/** Elapsed label for a row: final duration once ended, live seconds while running, else empty. */
+export function elapsedLabel(row, now) {
+    if (row.status === 'done' || row.status === 'failed') {
+        if (row.startedAt === undefined || row.endedAt === undefined)
+            return '';
+        return `${((row.endedAt - row.startedAt) / 1000).toFixed(1)}s`;
+    }
+    if (row.status === 'running' && row.startedAt !== undefined)
+        return `${Math.floor((now - row.startedAt) / 1000)}s`;
+    return '';
+}
+export const displayNames = (ps) => ps.map((p) => DISPLAY_NAME[p]).join(', ');
+// ── V10 run-screen life: rotating status phrases + progress bar + total time. Pure; unit-tested. ────
+/** Stage-flavored status phrases, rotated every 4s so long stages feel alive (not stuck). */
+const PHRASES = {
+    S0: ['grilling the intent', 'sharpening the run brief'],
+    S1: ['pinning down what you actually asked', 'writing the task contract'],
+    S2: ['checking every model read it the same way', 'guarding against a misread'],
+    S3: ["writing each seat's brief", 'tailoring the role prompts'],
+    S4: ['council working in separate rooms', 'independent takes incoming'],
+    S5: ['checking nobody drifted off-task', 'comparing echoes against the contract'],
+    S6: ['boiling the output down to claims', 'extracting the claims'],
+    S7: ['mapping where they disagree', 'drawing the disagreement map'],
+    S8: ['cross-examining the claims', 'stress-testing the evidence'],
+    S9: ['the judge is deliberating', 'weighing evidence over confidence'],
+    S9b: ['planning decisive validation', 'ordering the next tests'],
+    S10: ['writing the report', 'assembling the decision brief'],
+};
+/** The phrase for a running stage at `seconds` elapsed (cycles its list every 4s). */
+export function runningPhrase(stageId, seconds) {
+    const list = PHRASES[stageId];
+    if (!list || list.length === 0)
+        return 'working';
+    return list[Math.floor(seconds / 4) % list.length];
+}
+/** Overall progress: finished-stage count (done/failed/skipped) as a ▰▱ bar + counts. */
+export function progressBar(rows) {
+    const done = rows.filter((r) => r.status === 'done' || r.status === 'failed' || r.status === 'skipped').length;
+    return { bar: '▰'.repeat(done) + '▱'.repeat(rows.length - done), done, total: rows.length };
+}
+/** Whole-run elapsed (first start → last end), e.g. "84s"; '' before anything ran. */
+export function totalElapsed(rows) {
+    const starts = rows.map((r) => r.startedAt).filter((n) => n !== undefined);
+    const ends = rows.map((r) => r.endedAt).filter((n) => n !== undefined);
+    if (starts.length === 0 || ends.length === 0)
+        return '';
+    return `${((Math.max(...ends) - Math.min(...starts)) / 1000).toFixed(0)}s`;
+}

package/dist/workflows/code-review.js

@@ -0,0 +1,76 @@
+// code-review workflow (§12.2, T10). Stage COMPOSITION only. A bespoke lean pipeline — NOT the idea
+// S1–S10 stages (findings have no assumption/attack structure): deterministic S1/S3 (no model calls) →
+// S4 reviewers + file:line validator → S8 mutual cross-exam → deterministic ReviewMap → S9 judge → S10
+// report. ~5 model calls. `input` is the unified diff (the CLI computed it via git; §12.2).
+//
+// Artifact order note: the ReviewMap (07) is written BEFORE the cross-exam verifications (08) even though
+// it's derived from them — the artifact writer requires ascending stage ordinals, so S8 returns its data
+// and the workflow orders the two writes.
+import { resolve } from 'node:path';
+import { runStage } from '../orchestration/context.js';
+import { parseDiffFiles } from '../orchestration/git.js';
+import { s4Review } from '../orchestration/stages/cr-s4-review.js';
+import { s8CrossExam } from '../orchestration/stages/cr-s8-crossexam.js';
+import { buildReviewMap } from '../orchestration/stages/cr-map.js';
+import { s9ReviewJudge } from '../orchestration/stages/cr-s9-judge.js';
+import { s10ReviewRender } from '../orchestration/stages/cr-report.js';
+import { loadSkill } from '../orchestration/skills.js';
+/** §12.2 reviewer prompt (per reviewer). S3 fills {{DIFF_PATH}} deterministically (no model call). */
+export const CR_REVIEWER_TEMPLATE = `ROLE: Independent senior code reviewer. You work ALONE. You have READ-ONLY
+access to the repository at your working directory.
+
+Review ONLY the changes in the diff at {{DIFF_PATH}} (context: repo root = your cwd). Investigate
+surrounding code as needed before reporting.{{SKILL}}
+
+Produce ONLY JSON:
+- task_echo (≤2 sentences),
+- findings: ≤12, each {id "F1"..., file, line_start, line_end, severity P0|P1|P2|P3,
+  category CORRECTNESS|SECURITY|CONCURRENCY|ERROR_HANDLING|PERF|MAINTAINABILITY,
+  claim, evidence "<the code/behavior that proves it>", suggested_fix, self_confidence 0-1}.
+Rules: severity P0 = correctness/security/data-loss. No style nits below P2.
+Every finding MUST cite a file and line range you verified exists (paths relative to the repo root). JSON only.`;
+/**
+ * Fill the reviewer template: {{DIFF_PATH}} → the diff file, {{SKILL}} → the role playbook (or nothing).
+ * An empty skill collapses the slot to nothing, so the prompt is byte-for-byte the pre-skill baseline.
+ */
+export function buildReviewerPrompt(diffPath, skill) {
+    return CR_REVIEWER_TEMPLATE.replace('{{DIFF_PATH}}', diffPath).replace('{{SKILL}}', skill ? `\n\n${skill}` : '');
+}
+/** Timeline manifest (T8) for the code-review pipeline. S7 (map) is pure/deterministic (role null). */
+export const CR_STAGES = [
+    { id: 'S4', label: 'Parallel review', role: 's4' },
+    { id: 'S8', label: 'Cross-exam', role: 's4' },
+    { id: 'S7', label: 'Disagreement map', role: null },
+    { id: 'S9', label: 'Judge adjudication', role: 'judge' },
+    { id: 'S10', label: 'Report', role: null },
+];
+export async function runCodeReview(ctx, input) {
+    // `input` is the unified diff. Persist it where the reviewer prompt points; parse the touched files.
+    await ctx.writer.writeInput('diff.patch', input);
+    const diffPath = resolve(ctx.writer.dir, 'inputs', 'diff.patch');
+    const files = parseDiffFiles(input);
+    // S1 (deterministic, NO call): a trivial contract, for artifact consistency + forensics.
+    const contract = {
+        task: 'Review the changes in the supplied diff.',
+        task_type: 'code-review',
+        constraints: [],
+        unknowns: [],
+        success_criteria: ['adjudicated findings on the diff, with derived confidence'],
+    };
+    await ctx.writer.writeJson('intent-contract', contract);
+    // S3 (deterministic, NO call): fill the reviewer template's slots — DIFF_PATH + the reviewer
+    // playbook (skill); persist the assembled prompt for forensics.
+    const prompt = buildReviewerPrompt(diffPath, loadSkill('code-review', 'reviewer'));
+    await ctx.writer.writePrompt('reviewer.md', prompt);
+    const reviewers = await runStage(ctx, 'S4', () => s4Review(ctx, prompt, files));
+    const cross = await runStage(ctx, 'S8', () => s8CrossExam(ctx, reviewers));
+    // S7 — build + persist the ReviewMap (07), then the cross-exam verifications (08). Order: 07 < 08.
+    const map = await runStage(ctx, 'S7', async () => {
+        const m = buildReviewMap(reviewers, cross.byKey);
+        await ctx.writer.writeJson('review-map', m);
+        await ctx.writer.writeJson('verifications', { verifications: cross.verifications });
+        return m;
+    });
+    const judge = await runStage(ctx, 'S9', () => s9ReviewJudge(ctx, map));
+    await runStage(ctx, 'S10', () => s10ReviewRender(ctx, map, judge));
+}

package/dist/workflows/idea-refinement.js

@@ -0,0 +1,105 @@
+// idea-refinement workflow (§12.1). Stage COMPOSITION only — no orchestration mechanics (those
+// live in the engine) and, for now, prompts inline here rather than in skills/<workflow>/ (the
+// full skill loader + registry, §11, is deferred; it must not register without bench/ + validate.ts).
+//
+// v1 T5 scope: S1 → S2 → S3. S4–S10 are added as later tasks extend this composition.
+import { resolve } from 'node:path';
+import { runStage } from '../orchestration/context.js';
+import { renderGrilledInput, s0Grill } from '../orchestration/stages/s0-grill.js';
+import { s1Intent } from '../orchestration/stages/s1-intent.js';
+import { s2Misread } from '../orchestration/stages/s2-misread.js';
+import { s3Prompts } from '../orchestration/stages/s3-prompts.js';
+import { s4Analyze } from '../orchestration/stages/s4-analyze.js';
+import { s5Drift } from '../orchestration/stages/s5-drift.js';
+import { s6Claims } from '../orchestration/stages/s6-claims.js';
+import { s7Disagreement } from '../orchestration/stages/s7-disagreement.js';
+import { s8Verify } from '../orchestration/stages/s8-verify.js';
+import { s9Judge } from '../orchestration/stages/s9-judge.js';
+import { s9bPlan } from '../orchestration/stages/s9b-plan.js';
+import { s10Render } from '../orchestration/stages/s10-render.js';
+import { loadSkill } from '../orchestration/skills.js';
+/** §12.1 idea-vetting rubric: 12 mandatory coverage items. S7 flags any item no analyst addressed
+ *  as a blind spot. Inlined here (like the S4 template) while the skill/`rubric.json` loader (§11)
+ *  is deferred; it moves to skills/idea-refinement/rubric.json when that loader lands. */
+export const IDEA_RUBRIC = [
+    { id: 'R1', label: 'target user / audience', keywords: ['target user', 'audience', 'customer', 'persona'] },
+    { id: 'R2', label: 'existing alternatives / competition', keywords: ['existing', 'alternative', 'competitor', 'incumbent'] },
+    { id: 'R3', label: 'differentiation / unique value', keywords: ['differentiation', 'unique', 'moat', 'advantage'] },
+    { id: 'R4', label: 'feasibility / technical viability', keywords: ['feasibility', 'feasible', 'viable', 'technical'] },
+    { id: 'R5', label: 'cost / effort / resources', keywords: ['cost', 'effort', 'budget', 'resource'] },
+    { id: 'R6', label: 'policy / legal / compliance risk', keywords: ['policy', 'legal', 'compliance', 'regulatory'] },
+    { id: 'R7', label: 'kill criteria / failure conditions', keywords: ['kill criteria', 'failure', 'abandon', 'stop'] },
+    { id: 'R8', label: 'business model / monetization', keywords: ['business model', 'monetization', 'revenue', 'pricing'] },
+    { id: 'R9', label: 'distribution / go-to-market', keywords: ['distribution', 'market', 'adoption', 'channel'] },
+    { id: 'R10', label: 'timing / market readiness', keywords: ['timing', 'readiness', 'trend', 'now'] },
+    { id: 'R11', label: 'scalability / growth', keywords: ['scalability', 'scale', 'growth'] },
+    { id: 'R12', label: 'key risks / assumptions to validate', keywords: ['risk', 'assumption', 'validate', 'uncertain'] },
+];
+/** §13 S4 analyst template (idea-refinement). S3 fills its slots; S4 will consume it (T6). */
+export const IDEA_S4_ANALYST_TEMPLATE = `ROLE: Independent analyst on a decision panel. You work ALONE; you will not see
+other analysts' output. Be adversarial toward the idea, not polite.
+
+TASK CONTRACT: {{INTENT_CONTRACT_JSON}}
+INPUT DOCUMENT: read the file at {{INPUT_PATH}}{{SKILL}}
+
+Produce ONLY JSON matching {{S4_SCHEMA_REF}} with:
+- task_echo: restate the task in ≤2 sentences (drift check).
+- strongest_version: the best honest version of this idea in ≤150 words.
+- assumptions: ≤8, each {id "A1"..., statement, type VERIFIABLE|JUDGMENT, load_bearing bool}.
+- attacks: ≤6, each {id "X1"..., target_assumption, argument, severity HIGH|MED|LOW}.
+  Every attack MUST target an assumption id. Unanchored attacks will be discarded.
+- open_questions: ≤5 questions whose answers would change the verdict.
+Rules: no motivation, no summaries of your own output, no markdown, JSON only.`;
+/**
+ * Resolve the {{SKILL}} slot in the analyst template BEFORE S3 (S3 is a model call that tailors the
+ * template + errors on any leftover {{...}}). An empty skill collapses the slot → exact pre-skill
+ * baseline; the S3 deterministic fallback then preserves the embedded playbook verbatim.
+ */
+export function buildAnalystTemplate(skill) {
+    return IDEA_S4_ANALYST_TEMPLATE.replace('{{SKILL}}', skill ? `\n\n${skill}` : '');
+}
+/** Timeline manifest (T8): the stages in order, each with the provider-role its row displays.
+ *  The TUI draws the pending skeleton from this and resolves chips from `ctx.roles`. Ids match the
+ *  `runStage` calls below. S7 shows the judge (it makes the grouping call); S5/S6/S10 are pure (—). */
+export const IDEA_STAGES = [
+    { id: 'S0', label: 'Intent preflight', role: 'analyst' },
+    { id: 'S1', label: 'Intent contract', role: 'analyst' },
+    { id: 'S2', label: 'Misunderstanding guard', role: 'all' },
+    { id: 'S3', label: 'Prompt generation', role: 'analyst' },
+    { id: 'S4', label: 'Parallel analysis', role: 's4' },
+    { id: 'S5', label: 'Drift check', role: null },
+    { id: 'S6', label: 'Claim extraction', role: null },
+    { id: 'S7', label: 'Disagreement map', role: 'judge' },
+    { id: 'S8', label: 'Verifier loop', role: 'verifier' },
+    { id: 'S9', label: 'Judge synthesis', role: 'judge' },
+    { id: 'S9b', label: 'Validation plan', role: 'judge' },
+    { id: 'S10', label: 'Report', role: null },
+];
+/** Runs the full idea-refinement pipeline S0–S10. Throws on any fatal condition; the engine's
+ *  `executeRun` wrapper turns that into a graceful failure + meta. Each stage is wrapped in
+ *  `runStage` so the TUI timeline (T8) gets start/end events; headless, that's a no-op. */
+export async function runIdeaRefinement(ctx, input) {
+    const brief = await runStage(ctx, 'S0', () => s0Grill(ctx, input));
+    const grilledInput = renderGrilledInput(input, brief);
+    const contract = await runStage(ctx, 'S1', () => s1Intent(ctx, grilledInput));
+    const guard = await runStage(ctx, 'S2', () => s2Misread(ctx, contract, grilledInput));
+    // Persist the input as a file so S4's "read the file at {{INPUT_PATH}}" resolves (not a stage).
+    await ctx.writer.writeInput('idea.md', input);
+    await ctx.writer.writeInput('idea-brief.md', grilledInput);
+    const inputPath = resolve(ctx.writer.dir, 'inputs', 'idea-brief.md');
+    const stagePrompts = await runStage(ctx, 'S3', () => s3Prompts(ctx, {
+        contract,
+        interpretation: guard.chosen.my_interpretation,
+        templates: { analyst: buildAnalystTemplate(loadSkill('idea-refinement', 'analyst')) },
+        slots: { INPUT_PATH: inputPath, S4_SCHEMA_REF: 'the idea-refinement S4 RoleOutput schema' },
+    }));
+    // s3Prompts guarantees an entry for every template key (it iterates them), so `analyst` is present.
+    const seats = await runStage(ctx, 'S4', () => s4Analyze(ctx, stagePrompts.prompts.analyst));
+    const { kept } = await runStage(ctx, 'S5', () => s5Drift(ctx, contract, seats));
+    const claimSet = await runStage(ctx, 'S6', () => s6Claims(ctx, kept));
+    const map = await runStage(ctx, 'S7', () => s7Disagreement(ctx, claimSet, kept, IDEA_RUBRIC));
+    const verifications = await runStage(ctx, 'S8', () => s8Verify(ctx, map));
+    const judgeReport = await runStage(ctx, 'S9', () => s9Judge(ctx, contract, map, verifications, IDEA_RUBRIC));
+    const actionPlan = await runStage(ctx, 'S9b', () => s9bPlan(ctx, contract, kept, map, judgeReport));
+    await runStage(ctx, 'S10', () => s10Render(ctx, { contract, seats: kept, map, verifications, judgeReport, actionPlan, rubric: IDEA_RUBRIC }));
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "aiki-cli",
+  "version": "0.2.0",
+  "description": "Local-first orchestration CLI binding your installed AI coding CLIs into schema-validated multi-model workflows.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Gaurav Palaspagar",
+  "homepage": "https://github.com/kratos619/Aiki#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kratos619/Aiki.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kratos619/Aiki/issues"
+  },
+  "keywords": [
+    "cli",
+    "llm",
+    "orchestration",
+    "code-review",
+    "multi-model",
+    "claude",
+    "codex",
+    "gemini",
+    "local-first"
+  ],
+  "bin": {
+    "aiki": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"require('fs').copyFileSync('src/providers/profiles.json','dist/providers/profiles.json')\" && node -e \"require('fs').cpSync('src/skills','dist/skills',{recursive:true})\"",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build && npm run typecheck && npm test",
+    "aiki": "node --loader tsx dist/cli/index.js"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "execa": "^9.5.1",
+    "ink": "^5.1.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "pino": "^9.5.0",
+    "react": "^18.3.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.10",
+    "@types/react": "^18.3.18",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}