@bamptee/aia-code 1.0.5 → 2.0.1

package/README.md

@@ -35,10 +35,12 @@ Each CLI manages its own authentication. Run `claude`, `codex`, or `gemini` once
 | `aia next <feature> [description]` | Run the next pending step automatically |
 | `aia status <feature>` | Show the current status of a feature |
 | `aia reset <step> <feature>` | Reset a step to pending so it can be re-run |
+| `aia iterate <step> <feature> <instructions>` | Re-run a step with additional instructions to refine the output |
 | `aia quick <name> [description]` | Quick story/ticket: dev-plan → implement → review only |
 | `aia repo scan` | Scan codebase and generate `repo-map.json` |
+| `aia ui` | Launch the local web UI to manage features and config |
 
-### Options for `run`, `next`, and `quick`
+### Options for `run`, `next`, `quick`, and `iterate`
 
 | Flag | Description |
 |------|-------------|
@@ -281,6 +283,18 @@ aia reset tech-spec session-replay
 aia run tech-spec session-replay "Add WebSocket support and rate limiting"
 ```
 
+#### Iterating on a step
+
+Use `aia iterate` to refine a completed step with specific instructions. It resets the step, feeds back the previous output, and applies your instructions in a single command:
+
+```bash
+aia iterate tech-spec session-replay "Add error handling for WebSocket disconnections"
+aia iterate brief session-replay "Focus more on mobile use cases"
+aia iterate dev-plan session-replay "Split the implementation into smaller PRs" -v
+```
+
+You can iterate multiple times — each run builds on the previous output.
+
 #### Quick mode (stories & tickets)
 
 For small stories or tickets that don't need the full 8-step pipeline, use `aia quick`. It skips brief, ba-spec, questions, tech-spec, and challenge, and runs only **dev-plan → implement → review**:
@@ -419,6 +433,7 @@ src/
     feature.js            # aia feature <name>
     run.js                # aia run <step> <feature>
     next.js               # aia next <feature>
+    iterate.js            # aia iterate <step> <feature> <instructions>
     quick.js              # aia quick <name> [description]
     status.js             # aia status <feature>
     reset.js              # aia reset <step> <feature>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamptee/aia-code",
-  "version": "1.0.5",
+  "version": "2.0.1",
   "description": "AI Architecture Assistant - orchestrate AI-assisted development workflows via CLI tools (Claude, Codex, Gemini)",
   "type": "module",
   "license": "MIT",

package/src/cli.js

@@ -13,6 +13,7 @@ import { registerStatusCommand } from './commands/status.js';
 import { registerResetCommand } from './commands/reset.js';
 import { registerNextCommand } from './commands/next.js';
 import { registerQuickCommand } from './commands/quick.js';
+import { registerIterateCommand } from './commands/iterate.js';
 import { registerUiCommand } from './commands/ui.js';
 
 export function createCli() {
@@ -31,6 +32,7 @@ export function createCli() {
   registerRepoCommand(program);
   registerStatusCommand(program);
   registerResetCommand(program);
+  registerIterateCommand(program);
   registerUiCommand(program);
 
   return program;

package/src/commands/iterate.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+import { resetStep } from '../services/status.js';
+import { runStep } from '../services/runner.js';
+
+export function registerIterateCommand(program) {
+  program
+    .command('iterate <step> <feature> <instructions>')
+    .description('Re-run a step with additional instructions to refine the output')
+    .option('-v, --verbose', 'Show AI thinking/tool usage')
+    .option('-a, --apply', 'Force agent mode (file editing)')
+    .action(async (step, feature, instructions, opts) => {
+      try {
+        await resetStep(feature, step);
+        console.log(chalk.gray(`Reset "${step}" — iterating with new instructions...`));
+
+        await runStep(step, feature, {
+          instructions,
+          verbose: opts.verbose,
+          apply: opts.apply,
+        });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+      }
+    });
+}

package/src/prompt-builder.js

@@ -77,7 +77,7 @@ async function loadPromptTemplate(step, root) {
   return content;
 }
 
-export async function buildPrompt(feature, step, { description, root = process.cwd() } = {}) {
+export async function buildPrompt(feature, step, { description, instructions, root = process.cwd() } = {}) {
   const config = await loadConfig(root);
 
   const [context, knowledgeCategories, initSpecs, featureContent, previousOutput, task] = await Promise.all([
@@ -127,6 +127,12 @@ export async function buildPrompt(feature, step, { description, root = process.c
     parts.push('\n\nThe above is a previous version of this step. Rewrite it incorporating any new information, answers to questions, and improvements.');
   }
 
+  if (instructions) {
+    parts.push('\n\n=== ITERATION INSTRUCTIONS ===\n');
+    parts.push('Apply the following changes/feedback to the previous output:\n');
+    parts.push(instructions);
+  }
+
   parts.push('\n\n=== TASK ===\n');
   parts.push(task);
 

package/src/services/runner.js

@@ -8,7 +8,7 @@ import { callModel } from './model-call.js';
 import { loadStatus, updateStepStatus } from './status.js';
 import { logExecution } from '../logger.js';
 
-export async function runStep(step, feature, { description, verbose = false, apply = false, root = process.cwd(), onData } = {}) {
+export async function runStep(step, feature, { description, instructions, model: modelOverride, verbose = false, apply = false, root = process.cwd(), onData } = {}) {
   if (!FEATURE_STEPS.includes(step)) {
     throw new Error(`Unknown step "${step}". Valid steps: ${FEATURE_STEPS.join(', ')}`);
   }
@@ -26,8 +26,8 @@ export async function runStep(step, feature, { description, verbose = false, app
   const shouldApply = apply || APPLY_STEPS.has(step);
 
   try {
-    const model = await resolveModel(step, root);
-    const prompt = await buildPrompt(feature, step, { description, root });
+    const model = modelOverride || await resolveModel(step, root);
+    const prompt = await buildPrompt(feature, step, { description, instructions, root });
 
     const start = performance.now();
     const output = await callModel(model, prompt, { verbose, apply: shouldApply, onData });

package/src/ui/api/constants.js

@@ -1,8 +1,25 @@
 import { FEATURE_STEPS, STEP_STATUS, QUICK_STEPS } from '../../constants.js';
+import { loadConfig } from '../../models.js';
 import { json } from '../router.js';
 
 export function registerConstantsRoutes(router) {
   router.get('/api/constants', (req, res) => {
     json(res, { FEATURE_STEPS, STEP_STATUS, QUICK_STEPS });
   });
+
+  // List all unique models from config
+  router.get('/api/models', async (req, res, { root }) => {
+    try {
+      const config = await loadConfig(root);
+      const all = new Set();
+      for (const models of Object.values(config.models || {})) {
+        for (const entry of models) {
+          all.add(entry.model);
+        }
+      }
+      json(res, [...all]);
+    } catch (err) {
+      json(res, []);
+    }
+  });
 }

package/src/ui/api/features.js

@@ -97,6 +97,7 @@ export function registerFeatureRoutes(router) {
     try {
       const output = await runStep(params.step, params.name, {
         description: body.description,
+        model: body.model || undefined,
         verbose: true,
         apply: body.apply || false,
         root,
@@ -157,6 +158,34 @@ export function registerFeatureRoutes(router) {
     res.end();
   });
 
+  // Iterate a step with SSE streaming (reset + re-run with instructions)
+  router.post('/api/features/:name/iterate/:step', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    sseHeaders(res);
+    sseSend(res, 'status', { step: params.step, status: 'iterating' });
+
+    try {
+      await resetStep(params.name, params.step, root);
+
+      const onData = ({ type, text }) => {
+        try { sseSend(res, 'log', { type, text }); } catch {}
+      };
+
+      const output = await runStep(params.step, params.name, {
+        instructions: body.instructions,
+        model: body.model || undefined,
+        verbose: true,
+        apply: body.apply || false,
+        root,
+        onData,
+      });
+      sseSend(res, 'done', { step: params.step });
+    } catch (err) {
+      sseSend(res, 'error', { message: err.message });
+    }
+    res.end();
+  });
+
   // Reset a step
   router.post('/api/features/:name/reset/:step', async (req, res, { params, root }) => {
     try {

package/src/ui/public/components/feature-detail.js

@@ -138,75 +138,121 @@ function LogViewer({ logs }) {
   }, logs.join(''));
 }
 
-function RunPanel({ name, step, onDone }) {
+function ModelSelect({ model, onChange, disabled }) {
+  const [models, setModels] = React.useState([]);
+
+  React.useEffect(() => {
+    api.get('/models').then(setModels).catch(() => {});
+  }, []);
+
+  return React.createElement('select', {
+    value: model,
+    onChange: e => onChange(e.target.value),
+    disabled,
+    className: 'bg-aia-card border border-aia-border rounded px-2 py-1 text-xs text-slate-300 focus:border-aia-accent focus:outline-none',
+  },
+    React.createElement('option', { value: '' }, 'Model: auto (weighted)'),
+    ...models.map(m => React.createElement('option', { key: m, value: m }, m)),
+  );
+}
+
+function RunPanel({ name, step, stepStatus, onDone }) {
+  const isDone = stepStatus === 'done';
   const [description, setDescription] = React.useState('');
+  const [instructions, setInstructions] = React.useState('');
+  const [model, setModel] = React.useState('');
   const [apply, setApply] = React.useState(false);
   const [running, setRunning] = React.useState(false);
   const [result, setResult] = React.useState(null);
   const [err, setErr] = React.useState(null);
   const [logs, setLogs] = React.useState([]);
 
-  async function run() {
-    setRunning(true);
-    setResult(null);
-    setErr(null);
-    setLogs([]);
+  const sseCallbacks = {
+    onLog: (text) => setLogs(prev => [...prev, text]),
+    onStatus: (data) => setLogs(prev => [...prev, `[${data.status}] ${data.step || ''}\n`]),
+  };
 
-    const res = await streamPost(`/features/${name}/run/${step}`, { description, apply }, {
-      onLog: (text) => setLogs(prev => [...prev, text]),
-      onStatus: (data) => setLogs(prev => [...prev, `[${data.status}] ${data.step || ''}\n`]),
-    });
+  async function run() {
+    setRunning(true); setResult(null); setErr(null); setLogs([]);
+    const res = await streamPost(`/features/${name}/run/${step}`, { description, apply, model: model || undefined }, sseCallbacks);
+    if (res.ok) { setResult('Step completed.'); if (onDone) onDone(); }
+    else setErr(res.error);
+    setRunning(false);
+  }
 
-    if (res.ok) {
-      setResult('Step completed.');
-      if (onDone) onDone();
-    } else {
-      setErr(res.error);
-    }
+  async function iterate() {
+    setRunning(true); setResult(null); setErr(null); setLogs([]);
+    const res = await streamPost(`/features/${name}/iterate/${step}`, { instructions, apply, model: model || undefined }, sseCallbacks);
+    if (res.ok) { setResult('Iteration completed.'); setInstructions(''); if (onDone) onDone(); }
+    else setErr(res.error);
     setRunning(false);
   }
 
   async function reset() {
-    try {
-      await api.post(`/features/${name}/reset/${step}`);
-      if (onDone) onDone();
-    } catch (e) {
-      setErr(e.message);
-    }
+    try { await api.post(`/features/${name}/reset/${step}`); if (onDone) onDone(); }
+    catch (e) { setErr(e.message); }
   }
 
-  return React.createElement('div', { className: 'bg-slate-900 border border-aia-border rounded p-4 space-y-3' },
-    React.createElement('h4', { className: 'text-sm font-semibold text-slate-300' }, `Run: ${step}`),
-    React.createElement('input', {
-      type: 'text',
-      value: description,
-      onChange: e => setDescription(e.target.value),
-      placeholder: 'Optional description...',
-      disabled: running,
-      className: 'w-full bg-aia-card border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 placeholder-slate-500 focus:border-aia-accent focus:outline-none',
-    }),
-    React.createElement('div', { className: 'flex items-center gap-4' },
-      React.createElement('label', { className: 'flex items-center gap-2 text-xs text-slate-400 cursor-pointer' },
-        React.createElement('input', {
-          type: 'checkbox',
-          checked: apply,
-          onChange: e => setApply(e.target.checked),
-          disabled: running,
-          className: 'rounded',
-        }),
-        'Agent mode (--apply)'
-      ),
-      React.createElement('button', {
-        onClick: run,
+  return React.createElement('div', { className: 'space-y-3' },
+
+    // --- Run block (when step is not done) ---
+    !isDone && React.createElement('div', { className: 'bg-slate-900 border border-aia-border rounded p-4 space-y-3' },
+      React.createElement('h4', { className: 'text-sm font-semibold text-emerald-400' }, `Run: ${step}`),
+      React.createElement('input', {
+        type: 'text',
+        value: description,
+        onChange: e => setDescription(e.target.value),
+        placeholder: 'Optional description...',
         disabled: running,
-        className: 'bg-emerald-500/20 text-emerald-400 border border-emerald-500/30 rounded px-4 py-1.5 text-sm hover:bg-emerald-500/30 disabled:opacity-40',
-      }, running ? 'Running...' : 'Run Step'),
-      React.createElement('button', {
-        onClick: reset,
+        className: 'w-full bg-aia-card border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 placeholder-slate-500 focus:border-emerald-400 focus:outline-none',
+      }),
+      React.createElement('div', { className: 'flex items-center gap-4 flex-wrap' },
+        React.createElement(ModelSelect, { model, onChange: setModel, disabled: running }),
+        React.createElement('label', { className: 'flex items-center gap-2 text-xs text-slate-400 cursor-pointer' },
+          React.createElement('input', { type: 'checkbox', checked: apply, onChange: e => setApply(e.target.checked), disabled: running, className: 'rounded' }),
+          'Agent mode (--apply)'
+        ),
+        React.createElement('button', {
+          onClick: run, disabled: running,
+          className: 'bg-emerald-500/20 text-emerald-400 border border-emerald-500/30 rounded px-4 py-1.5 text-sm hover:bg-emerald-500/30 disabled:opacity-40',
+        }, running ? 'Running...' : 'Run Step'),
+      ),
+    ),
+
+    // --- Iterate block (when step is done) ---
+    isDone && React.createElement('div', { className: 'bg-slate-900 border border-violet-500/30 rounded p-4 space-y-3' },
+      React.createElement('div', { className: 'flex items-center justify-between' },
+        React.createElement('h4', { className: 'text-sm font-semibold text-violet-400' }, `Iterate: ${step}`),
+        React.createElement('span', { className: 'text-xs bg-emerald-500/20 text-emerald-400 px-2 py-0.5 rounded' }, 'done'),
+      ),
+      React.createElement('p', { className: 'text-xs text-slate-500' }, 'The previous output will be used as base. Describe what to change below.'),
+      React.createElement('label', { className: 'text-xs font-medium text-slate-400 block' }, 'Iteration instructions'),
+      React.createElement('textarea', {
+        value: instructions,
+        onChange: e => setInstructions(e.target.value),
+        placeholder: 'e.g. "Add error handling for edge cases", "Focus more on mobile", "Split into smaller functions"...',
         disabled: running,
-        className: 'text-slate-500 hover:text-slate-300 text-xs',
-      }, 'Reset'),
+        rows: 3,
+        className: 'w-full bg-aia-card border border-aia-border rounded px-3 py-2 text-sm text-slate-200 placeholder-slate-500 focus:border-violet-400 focus:outline-none resize-y',
+      }),
+      React.createElement('div', { className: 'flex items-center gap-4 flex-wrap' },
+        React.createElement(ModelSelect, { model, onChange: setModel, disabled: running }),
+        React.createElement('label', { className: 'flex items-center gap-2 text-xs text-slate-400 cursor-pointer' },
+          React.createElement('input', { type: 'checkbox', checked: apply, onChange: e => setApply(e.target.checked), disabled: running, className: 'rounded' }),
+          'Agent mode (--apply)'
+        ),
+        React.createElement('button', {
+          onClick: iterate, disabled: running || !instructions.trim(),
+          className: 'bg-violet-500/20 text-violet-400 border border-violet-500/30 rounded px-4 py-1.5 text-sm hover:bg-violet-500/30 disabled:opacity-40',
+        }, running ? 'Iterating...' : 'Iterate'),
+        React.createElement('button', {
+          onClick: reset, disabled: running,
+          className: 'text-slate-500 hover:text-slate-300 text-xs',
+        }, 'Reset to pending'),
+      ),
     ),
+
+    // --- Shared log viewer + results ---
     React.createElement(LogViewer, { logs }),
     result && React.createElement('p', { className: 'text-emerald-400 text-xs' }, result),
     err && React.createElement('p', { className: 'text-red-400 text-xs' }, err),
@@ -258,8 +304,8 @@ export function FeatureDetail({ name }) {
       )
     ),
 
-    // Run panel
-    activeStep && React.createElement(RunPanel, { name, step: activeStep, onDone: load }),
+    // Run / Iterate panel
+    activeStep && React.createElement(RunPanel, { name, step: activeStep, stepStatus: steps[activeStep], onDone: load }),
 
     // File tabs
     React.createElement('div', { className: 'flex gap-1 border-b border-aia-border' },