@bamptee/aia-code 0.2.0 → 0.4.0

package/package.json

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

package/src/cli.js

@@ -5,6 +5,7 @@ import { registerRunCommand } from './commands/run.js';
 import { registerRepoCommand } from './commands/repo.js';
 import { registerStatusCommand } from './commands/status.js';
 import { registerResetCommand } from './commands/reset.js';
+import { registerNextCommand } from './commands/next.js';
 
 export function createCli() {
   const program = new Command();
@@ -17,6 +18,7 @@ export function createCli() {
   registerInitCommand(program);
   registerFeatureCommand(program);
   registerRunCommand(program);
+  registerNextCommand(program);
   registerRepoCommand(program);
   registerStatusCommand(program);
   registerResetCommand(program);

package/src/commands/next.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk';
+import { loadStatus } from '../services/status.js';
+import { runStep } from '../services/runner.js';
+
+export function registerNextCommand(program) {
+  program
+    .command('next <feature> [description]')
+    .description('Run the next pending step for a feature')
+    .option('-v, --verbose', 'Show CLI logs (thinking, tool use, etc.)')
+    .option('-a, --apply', 'Let the AI edit and create files in the project')
+    .action(async (feature, description, opts) => {
+      try {
+        const status = await loadStatus(feature);
+        const nextStep = status.current_step;
+
+        if (!nextStep) {
+          console.log(chalk.green(`All steps completed for feature "${feature}".`));
+          return;
+        }
+
+        console.log(chalk.cyan(`[next] Running step: ${nextStep}`));
+        await runStep(nextStep, feature, { description, verbose: opts.verbose, apply: opts.apply });
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/run.js

@@ -3,11 +3,13 @@ import { runStep } from '../services/runner.js';
 
 export function registerRunCommand(program) {
   program
-    .command('run <step> <feature>')
+    .command('run <step> <feature> [description]')
     .description('Execute a step for a feature using the configured AI model')
-    .action(async (step, feature) => {
+    .option('-v, --verbose', 'Show CLI logs (thinking, tool use, etc.)')
+    .option('-a, --apply', 'Let the AI edit and create files in the project')
+    .action(async (step, feature, description, opts) => {
       try {
-        await runStep(step, feature);
+        await runStep(step, feature, { description, verbose: opts.verbose, apply: opts.apply });
       } catch (err) {
         console.error(chalk.red(err.message));
         process.exit(1);

package/src/prompt-builder.js

@@ -44,9 +44,14 @@ async function loadFeatureFiles(feature, step, root) {
   return sections.join('\n\n');
 }
 
+async function loadPreviousOutput(feature, step, root) {
+  const filePath = path.join(root, AIA_DIR, 'features', feature, `${step}.md`);
+  return readIfExists(filePath);
+}
+
 async function resolveKnowledgeCategories(feature, config, root) {
-  const statusPath = path.join(root, AIA_DIR, 'features', feature, 'status.yaml');
-  const raw = await readIfExists(statusPath);
+  const statusFile = path.join(root, AIA_DIR, 'features', feature, 'status.yaml');
+  const raw = await readIfExists(statusFile);
 
   if (raw) {
     const status = yaml.parse(raw);
@@ -67,13 +72,14 @@ async function loadPromptTemplate(step, root) {
   return content;
 }
 
-export async function buildPrompt(feature, step, root = process.cwd()) {
+export async function buildPrompt(feature, step, { description, root = process.cwd() } = {}) {
   const config = await loadConfig(root);
 
-  const [context, knowledgeCategories, featureContent, task] = await Promise.all([
+  const [context, knowledgeCategories, featureContent, previousOutput, task] = await Promise.all([
     loadContextFiles(config, root),
     resolveKnowledgeCategories(feature, config, root),
     loadFeatureFiles(feature, step, root),
+    loadPreviousOutput(feature, step, root),
     loadPromptTemplate(step, root),
   ]);
 
@@ -81,6 +87,12 @@ export async function buildPrompt(feature, step, root = process.cwd()) {
 
   const parts = [];
 
+  if (description) {
+    parts.push('=== DESCRIPTION ===\n');
+    parts.push(description);
+    parts.push('');
+  }
+
   parts.push('=== CONTEXT ===\n');
   parts.push(context || '(no context files)');
 
@@ -90,6 +102,12 @@ export async function buildPrompt(feature, step, root = process.cwd()) {
   parts.push('\n\n=== FEATURE ===\n');
   parts.push(featureContent || '(no prior steps)');
 
+  if (previousOutput) {
+    parts.push('\n\n=== PREVIOUS OUTPUT ===\n');
+    parts.push(previousOutput);
+    parts.push('\n\nThe above is a previous version of this step. Rewrite it incorporating any new information, answers to questions, and improvements.');
+  }
+
   parts.push('\n\n=== TASK ===\n');
   parts.push(task);
 

package/src/providers/anthropic.js

@@ -1,11 +1,17 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model) {
+export async function generate(prompt, model, { verbose = false, apply = false } = {}) {
   const args = ['-p'];
   if (model) {
     args.push('--model', model);
   }
+  if (apply) {
+    args.push('--allowedTools', 'Edit', 'Write', 'Bash', 'Read', 'Glob', 'Grep');
+  }
+  if (verbose) {
+    args.push('--verbose');
+  }
   args.push('-');
 
-  return runCli('claude', args, { stdin: prompt });
+  return runCli('claude', args, { stdin: prompt, verbose });
 }

package/src/providers/cli-runner.js

@@ -1,8 +1,9 @@
 import { spawn } from 'node:child_process';
+import chalk from 'chalk';
 
-const DEFAULT_TIMEOUT_MS = 300_000;
+const DEFAULT_IDLE_TIMEOUT_MS = 180_000;
 
-export function runCli(command, args, { stdin: stdinData, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+export function runCli(command, args, { stdin: stdinData, verbose = false, idleTimeoutMs = DEFAULT_IDLE_TIMEOUT_MS } = {}) {
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       stdio: ['pipe', 'pipe', 'pipe'],
@@ -11,37 +12,56 @@ export function runCli(command, args, { stdin: stdinData, timeoutMs = DEFAULT_TI
 
     const chunks = [];
     let stderr = '';
+    let settled = false;
+
+    function resetTimer() {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        child.kill('SIGTERM');
+        finish(new Error(`CLI idle timeout (no output for ${idleTimeoutMs / 1000}s): ${command} ${args.join(' ')}`));
+      }, idleTimeoutMs);
+    }
+
+    function finish(err, result) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (err) reject(err);
+      else resolve(result);
+    }
+
+    let timer;
+    resetTimer();
 
     child.stdout.on('data', (data) => {
       const text = data.toString();
       process.stdout.write(text);
       chunks.push(text);
+      resetTimer();
     });
 
     child.stderr.on('data', (data) => {
-      stderr += data.toString();
+      const text = data.toString();
+      stderr += text;
+      if (verbose) {
+        process.stderr.write(chalk.gray(text));
+      }
+      resetTimer();
     });
 
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM');
-      reject(new Error(`CLI timed out after ${timeoutMs / 1000}s: ${command} ${args.join(' ')}`));
-    }, timeoutMs);
-
     child.on('error', (err) => {
-      clearTimeout(timer);
       if (err.code === 'ENOENT') {
-        reject(new Error(`CLI not found: "${command}". Make sure it is installed and in your PATH.`));
+        finish(new Error(`CLI not found: "${command}". Make sure it is installed and in your PATH.`));
       } else {
-        reject(err);
+        finish(err);
       }
     });
 
     child.on('close', (code) => {
-      clearTimeout(timer);
       if (code !== 0) {
-        reject(new Error(`${command} exited with code ${code}:\n${stderr.trim()}`));
+        finish(new Error(`${command} exited with code ${code}:\n${stderr.trim()}`));
       } else {
-        resolve(chunks.join(''));
+        finish(null, chunks.join(''));
       }
     });
 

package/src/providers/gemini.js

@@ -1,11 +1,14 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model) {
+export async function generate(prompt, model, { verbose = false, apply = false } = {}) {
   const args = [];
   if (model) {
     args.push('-m', model);
   }
+  if (apply) {
+    args.push('--sandbox', 'false');
+  }
   args.push('-');
 
-  return runCli('gemini', args, { stdin: prompt });
+  return runCli('gemini', args, { stdin: prompt, verbose });
 }

package/src/providers/openai.js

@@ -1,11 +1,14 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model) {
+export async function generate(prompt, model, { verbose = false, apply = false } = {}) {
   const args = ['exec'];
   if (model) {
     args.push('-c', `model="${model}"`);
   }
+  if (apply) {
+    args.push('-c', 'approval_policy="auto-edit"');
+  }
   args.push('-');
 
-  return runCli('codex', args, { stdin: prompt });
+  return runCli('codex', args, { stdin: prompt, verbose });
 }

package/src/services/model-call.js

@@ -1,11 +1,12 @@
 import chalk from 'chalk';
 import { resolveModelAlias } from '../providers/registry.js';
 
-export async function callModel(model, prompt) {
+export async function callModel(model, prompt, { verbose = false, apply = false } = {}) {
   const resolved = resolveModelAlias(model);
   const displayName = resolved.model ?? `${model} (CLI default)`;
+  const mode = apply ? 'agent' : 'print';
 
-  console.log(chalk.yellow(`[AI] Calling ${displayName}...`));
+  console.log(chalk.yellow(`[AI] Calling ${displayName} (${mode} mode)...`));
 
-  return resolved.provider.generate(prompt, resolved.model);
+  return resolved.provider.generate(prompt, resolved.model, { verbose, apply });
 }

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, root = process.cwd()) {
+export async function runStep(step, feature, { description, verbose = false, apply = false, root = process.cwd() } = {}) {
   if (!FEATURE_STEPS.includes(step)) {
     throw new Error(`Unknown step "${step}". Valid steps: ${FEATURE_STEPS.join(', ')}`);
   }
@@ -25,10 +25,10 @@ export async function runStep(step, feature, root = process.cwd()) {
 
   try {
     const model = await resolveModel(step, root);
-    const prompt = await buildPrompt(feature, step, root);
+    const prompt = await buildPrompt(feature, step, { description, root });
 
     const start = performance.now();
-    const output = await callModel(model, prompt);
+    const output = await callModel(model, prompt, { verbose, apply });
     const duration = performance.now() - start;
 
     const outputPath = path.join(root, AIA_DIR, 'features', feature, `${step}.md`);

package/src/services/status.js

@@ -38,7 +38,7 @@ export async function updateStepStatus(feature, step, value, root = process.cwd(
 
   const stepIndex = FEATURE_STEPS.indexOf(step);
   const nextStep = FEATURE_STEPS[stepIndex + 1] ?? null;
-  if (value === STEP_STATUS.DONE && nextStep) {
+  if (value === STEP_STATUS.DONE) {
     status.current_step = nextStep;
   }
 
@@ -63,8 +63,5 @@ export async function resetStep(feature, step, root = process.cwd()) {
   const content = yaml.stringify(status);
   await fs.writeFile(statusPath(feature, root), content, 'utf-8');
 
-  const outputPath = path.join(root, AIA_DIR, 'features', feature, `${step}.md`);
-  if (await fs.pathExists(outputPath)) {
-    await fs.writeFile(outputPath, '', 'utf-8');
-  }
+  // Keep the existing output — it will be fed back as context on re-run
 }