@bamptee/aia-code 0.10.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamptee/aia-code",
-  "version": "0.10.0",
+  "version": "1.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

@@ -7,6 +7,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 { registerUiCommand } from './commands/ui.js';
 
 export function createCli() {
   const program = new Command();
@@ -24,6 +25,7 @@ export function createCli() {
   registerRepoCommand(program);
   registerStatusCommand(program);
   registerResetCommand(program);
+  registerUiCommand(program);
 
   return program;
 }

package/src/commands/quick.js

@@ -1,58 +1,20 @@
 import chalk from 'chalk';
-import fs from 'fs-extra';
-import path from 'node:path';
-import yaml from 'yaml';
-import { AIA_DIR, FEATURE_STEPS, QUICK_STEPS, STEP_STATUS } from '../constants.js';
-import { createFeature, validateFeatureName } from '../services/feature.js';
-import { runStep } from '../services/runner.js';
-
-async function skipEarlySteps(feature, root) {
-  const statusFile = path.join(root, AIA_DIR, 'features', feature, 'status.yaml');
-  const raw = await fs.readFile(statusFile, 'utf-8');
-  const status = yaml.parse(raw);
-
-  for (const step of FEATURE_STEPS) {
-    if (!QUICK_STEPS.includes(step)) {
-      status.steps[step] = STEP_STATUS.DONE;
-    }
-  }
-  status.current_step = QUICK_STEPS[0];
-
-  await fs.writeFile(statusFile, yaml.stringify(status), 'utf-8');
-}
+import { runQuick } from '../services/quick.js';
+import { QUICK_STEPS } from '../constants.js';
 
 export function registerQuickCommand(program) {
   program
     .command('quick <name> [description]')
-    .description('Quick story/ticket: create feature then run dev-plan → implement → review')
+    .description(`Quick story/ticket: create feature then run ${QUICK_STEPS.join(' \u2192 ')}`)
     .option('-v, --verbose', 'Show AI thinking/tool usage')
     .option('-a, --apply', 'Force agent mode (file editing) for all steps')
     .action(async (name, description, opts) => {
       try {
-        validateFeatureName(name);
-
-        const root = process.cwd();
-        const featureDir = path.join(root, AIA_DIR, 'features', name);
-
-        if (!(await fs.pathExists(featureDir))) {
-          await createFeature(name, root);
-          console.log(chalk.green(`Feature "${name}" created.`));
-          const initPath = path.join(AIA_DIR, 'features', name, 'init.md');
-          console.log(chalk.gray(`Using ${initPath} as input.`));
-        }
-
-        await skipEarlySteps(name, root);
-
-        for (const step of QUICK_STEPS) {
-          console.log(chalk.cyan(`\n--- Running ${step} ---\n`));
-          await runStep(step, name, {
-            description,
-            verbose: opts.verbose,
-            apply: opts.apply,
-            root,
-          });
-        }
-
+        await runQuick(name, {
+          description,
+          verbose: opts.verbose,
+          apply: opts.apply,
+        });
         console.log(chalk.green(`\nQuick pipeline completed for "${name}".`));
       } catch (err) {
         console.error(chalk.red(err.message));

package/src/commands/ui.js

@@ -0,0 +1,19 @@
+import { execSync } from 'node:child_process';
+import { startServer } from '../ui/server.js';
+
+function openBrowser(url) {
+  const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+  try { execSync(`${cmd} ${url}`, { stdio: 'ignore' }); } catch {}
+}
+
+export function registerUiCommand(program) {
+  program
+    .command('ui')
+    .description('Launch the local web UI to manage features and config')
+    .option('-p, --port <port>', 'Port to listen on (scans from 3100 if not specified)')
+    .action(async (opts) => {
+      const port = opts.port ? parseInt(opts.port, 10) : undefined;
+      const { port: actualPort } = await startServer(port);
+      openBrowser(`http://127.0.0.1:${actualPort}`);
+    });
+}

package/src/providers/anthropic.js

@@ -1,6 +1,6 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model, { verbose = false, apply = false } = {}) {
+export async function generate(prompt, model, { verbose = false, apply = false, onData } = {}) {
   const args = ['-p'];
   if (model) {
     args.push('--model', model);
@@ -13,5 +13,5 @@ export async function generate(prompt, model, { verbose = false, apply = false }
   }
   args.push('-');
 
-  return runCli('claude', args, { stdin: prompt, verbose: verbose || apply, apply });
+  return runCli('claude', args, { stdin: prompt, verbose: verbose || apply, apply, onData });
 }

package/src/providers/cli-runner.js

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 const DEFAULT_IDLE_TIMEOUT_MS = 180_000;
 const AGENT_IDLE_TIMEOUT_MS = 600_000;
 
-export function runCli(command, args, { stdin: stdinData, verbose = false, apply = false, idleTimeoutMs } = {}) {
+export function runCli(command, args, { stdin: stdinData, verbose = false, apply = false, idleTimeoutMs, onData } = {}) {
   if (!idleTimeoutMs) {
     idleTimeoutMs = apply ? AGENT_IDLE_TIMEOUT_MS : DEFAULT_IDLE_TIMEOUT_MS;
   }
@@ -41,6 +41,7 @@ export function runCli(command, args, { stdin: stdinData, verbose = false, apply
       const text = data.toString();
       process.stdout.write(text);
       chunks.push(text);
+      if (onData) onData({ type: 'stdout', text });
       resetTimer();
     });
 
@@ -50,6 +51,7 @@ export function runCli(command, args, { stdin: stdinData, verbose = false, apply
       if (verbose) {
         process.stderr.write(chalk.gray(text));
       }
+      if (onData) onData({ type: 'stderr', text });
       resetTimer();
     });
 

package/src/providers/gemini.js

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

package/src/providers/openai.js

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

package/src/services/model-call.js

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

package/src/services/quick.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import yaml from 'yaml';
+import { AIA_DIR, FEATURE_STEPS, QUICK_STEPS, STEP_STATUS } from '../constants.js';
+import { createFeature, validateFeatureName } from './feature.js';
+import { runStep } from './runner.js';
+
+export async function skipEarlySteps(feature, root) {
+  const statusFile = path.join(root, AIA_DIR, 'features', feature, 'status.yaml');
+  const raw = await fs.readFile(statusFile, 'utf-8');
+  const status = yaml.parse(raw);
+
+  for (const step of FEATURE_STEPS) {
+    if (!QUICK_STEPS.includes(step)) {
+      status.steps[step] = STEP_STATUS.DONE;
+    }
+  }
+  status.current_step = QUICK_STEPS[0];
+
+  await fs.writeFile(statusFile, yaml.stringify(status), 'utf-8');
+}
+
+export async function runQuick(name, { description, verbose = false, apply = false, root = process.cwd(), onData } = {}) {
+  validateFeatureName(name);
+
+  const featureDir = path.join(root, AIA_DIR, 'features', name);
+  const created = !(await fs.pathExists(featureDir));
+
+  if (created) {
+    await createFeature(name, root);
+  }
+
+  await skipEarlySteps(name, root);
+
+  for (const step of QUICK_STEPS) {
+    await runStep(step, name, { description, verbose, apply, root, onData });
+  }
+
+  return { created };
+}

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

package/src/ui/api/config.js

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import yaml from 'yaml';
+import { AIA_DIR } from '../../constants.js';
+import { json, error } from '../router.js';
+
+export function registerConfigRoutes(router) {
+  // Get config
+  router.get('/api/config', async (req, res, { root }) => {
+    const configPath = path.join(root, AIA_DIR, 'config.yaml');
+    if (!(await fs.pathExists(configPath))) {
+      return error(res, 'config.yaml not found', 404);
+    }
+    const content = await fs.readFile(configPath, 'utf-8');
+    json(res, { content, parsed: yaml.parse(content) });
+  });
+
+  // Save config
+  router.put('/api/config', async (req, res, { root, parseBody }) => {
+    const body = await parseBody();
+    const configPath = path.join(root, AIA_DIR, 'config.yaml');
+    await fs.writeFile(configPath, body.content, 'utf-8');
+    json(res, { ok: true });
+  });
+
+  // List context files
+  router.get('/api/context', async (req, res, { root }) => {
+    const dir = path.join(root, AIA_DIR, 'context');
+    if (!(await fs.pathExists(dir))) return json(res, []);
+    const files = await fs.readdir(dir);
+    json(res, files.filter(f => f.endsWith('.md')));
+  });
+
+  // Read context file
+  router.get('/api/context/:filename', async (req, res, { params, root }) => {
+    const filePath = path.join(root, AIA_DIR, 'context', params.filename);
+    if (!(await fs.pathExists(filePath))) return error(res, 'Not found', 404);
+    const content = await fs.readFile(filePath, 'utf-8');
+    json(res, { filename: params.filename, content });
+  });
+
+  // Save context file
+  router.put('/api/context/:filename', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    const filePath = path.join(root, AIA_DIR, 'context', params.filename);
+    await fs.writeFile(filePath, body.content, 'utf-8');
+    json(res, { ok: true });
+  });
+
+  // List knowledge categories
+  router.get('/api/knowledge', async (req, res, { root }) => {
+    const dir = path.join(root, AIA_DIR, 'knowledge');
+    if (!(await fs.pathExists(dir))) return json(res, []);
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const categories = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const files = await fs.readdir(path.join(dir, entry.name));
+        categories.push({ name: entry.name, files: files.filter(f => f.endsWith('.md')) });
+      }
+    }
+    json(res, categories);
+  });
+
+  // Read knowledge file
+  router.get('/api/knowledge/:category/:filename', async (req, res, { params, root }) => {
+    const filePath = path.join(root, AIA_DIR, 'knowledge', params.category, params.filename);
+    if (!(await fs.pathExists(filePath))) return error(res, 'Not found', 404);
+    const content = await fs.readFile(filePath, 'utf-8');
+    json(res, { filename: params.filename, category: params.category, content });
+  });
+
+  // Save knowledge file
+  router.put('/api/knowledge/:category/:filename', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    const filePath = path.join(root, AIA_DIR, 'knowledge', params.category, params.filename);
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, body.content, 'utf-8');
+    json(res, { ok: true });
+  });
+}

package/src/ui/api/constants.js

@@ -0,0 +1,8 @@
+import { FEATURE_STEPS, STEP_STATUS, QUICK_STEPS } from '../../constants.js';
+import { json } from '../router.js';
+
+export function registerConstantsRoutes(router) {
+  router.get('/api/constants', (req, res) => {
+    json(res, { FEATURE_STEPS, STEP_STATUS, QUICK_STEPS });
+  });
+}

package/src/ui/api/features.js

@@ -0,0 +1,169 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { AIA_DIR } from '../../constants.js';
+import { loadStatus, updateStepStatus, resetStep } from '../../services/status.js';
+import { createFeature, validateFeatureName } from '../../services/feature.js';
+import { runStep } from '../../services/runner.js';
+import { runQuick } from '../../services/quick.js';
+import { json, error } from '../router.js';
+
+function sseHeaders(res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'Access-Control-Allow-Origin': '*',
+  });
+}
+
+function sseSend(res, event, data) {
+  res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+
+export function registerFeatureRoutes(router) {
+  // List all features
+  router.get('/api/features', async (req, res, { root }) => {
+    const featuresDir = path.join(root, AIA_DIR, 'features');
+    if (!(await fs.pathExists(featuresDir))) {
+      return json(res, []);
+    }
+    const entries = await fs.readdir(featuresDir, { withFileTypes: true });
+    const features = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        try {
+          const status = await loadStatus(entry.name, root);
+          features.push({ name: entry.name, ...status });
+        } catch {
+          features.push({ name: entry.name, error: true });
+        }
+      }
+    }
+    json(res, features);
+  });
+
+  // Get a single feature
+  router.get('/api/features/:name', async (req, res, { params, root }) => {
+    try {
+      const status = await loadStatus(params.name, root);
+      const featureDir = path.join(root, AIA_DIR, 'features', params.name);
+      const files = await fs.readdir(featureDir);
+      json(res, { name: params.name, ...status, files });
+    } catch (err) {
+      error(res, err.message, 404);
+    }
+  });
+
+  // Read a feature file
+  router.get('/api/features/:name/files/:filename', async (req, res, { params, root }) => {
+    const filePath = path.join(root, AIA_DIR, 'features', params.name, params.filename);
+    if (!(await fs.pathExists(filePath))) {
+      return error(res, 'File not found', 404);
+    }
+    const content = await fs.readFile(filePath, 'utf-8');
+    json(res, { filename: params.filename, content });
+  });
+
+  // Save a feature file
+  router.put('/api/features/:name/files/:filename', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    const filePath = path.join(root, AIA_DIR, 'features', params.name, params.filename);
+    await fs.writeFile(filePath, body.content, 'utf-8');
+    json(res, { ok: true });
+  });
+
+  // Create a new feature
+  router.post('/api/features', async (req, res, { root, parseBody }) => {
+    const body = await parseBody();
+    try {
+      validateFeatureName(body.name);
+      await createFeature(body.name, root);
+      json(res, { ok: true, name: body.name }, 201);
+    } catch (err) {
+      error(res, err.message, 400);
+    }
+  });
+
+  // Run a step with SSE streaming
+  router.post('/api/features/:name/run/:step', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    sseHeaders(res);
+    sseSend(res, 'status', { step: params.step, status: 'started' });
+
+    const onData = ({ type, text }) => {
+      try { sseSend(res, 'log', { type, text }); } catch {}
+    };
+
+    try {
+      const output = await runStep(params.step, params.name, {
+        description: body.description,
+        verbose: true,
+        apply: body.apply || false,
+        root,
+        onData,
+      });
+      sseSend(res, 'done', { step: params.step, output: output.slice(0, 500) });
+    } catch (err) {
+      sseSend(res, 'error', { message: err.message });
+    }
+    res.end();
+  });
+
+  // Quick ticket with SSE streaming (dev-plan -> implement -> review)
+  router.post('/api/features/:name/quick', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    sseHeaders(res);
+    sseSend(res, 'status', { status: 'started', mode: 'quick' });
+
+    const onData = ({ type, text }) => {
+      try { sseSend(res, 'log', { type, text }); } catch {}
+    };
+
+    try {
+      await runQuick(params.name, {
+        description: body.description,
+        apply: body.apply || false,
+        root,
+        onData,
+      });
+      sseSend(res, 'done', { status: 'completed' });
+    } catch (err) {
+      sseSend(res, 'error', { message: err.message });
+    }
+    res.end();
+  });
+
+  // Quick ticket with SSE streaming (create + run)
+  router.post('/api/quick', async (req, res, { root, parseBody }) => {
+    const body = await parseBody();
+    sseHeaders(res);
+    sseSend(res, 'status', { status: 'started', mode: 'quick', name: body.name });
+
+    const onData = ({ type, text }) => {
+      try { sseSend(res, 'log', { type, text }); } catch {}
+    };
+
+    try {
+      await runQuick(body.name, {
+        description: body.description,
+        apply: body.apply || false,
+        root,
+        onData,
+      });
+      sseSend(res, 'done', { status: 'completed', name: body.name });
+    } 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 {
+      await resetStep(params.name, params.step, root);
+      json(res, { ok: true });
+    } catch (err) {
+      error(res, err.message, 400);
+    }
+  });
+}

package/src/ui/api/index.js

@@ -0,0 +1,11 @@
+import { registerFeatureRoutes } from './features.js';
+import { registerConfigRoutes } from './config.js';
+import { registerLogRoutes } from './logs.js';
+import { registerConstantsRoutes } from './constants.js';
+
+export function registerApiRoutes(router, root) {
+  registerFeatureRoutes(router);
+  registerConfigRoutes(router);
+  registerLogRoutes(router);
+  registerConstantsRoutes(router);
+}

package/src/ui/api/logs.js

@@ -0,0 +1,15 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import { AIA_DIR } from '../../constants.js';
+import { json } from '../router.js';
+
+export function registerLogRoutes(router) {
+  router.get('/api/logs', async (req, res, { root }) => {
+    const logPath = path.join(root, AIA_DIR, 'logs', 'execution.log');
+    if (!(await fs.pathExists(logPath))) {
+      return json(res, { content: '' });
+    }
+    const content = await fs.readFile(logPath, 'utf-8');
+    json(res, { content });
+  });
+}