@bamptee/aia-code 2.0.1 → 2.0.3

package/README.md

@@ -162,7 +162,58 @@ Required templates (one per step you want to run):
 .aia/prompts/review.md
 ```
 
-### 6. Configure models
+### 6. Configuration (user + project)
+
+AIA uses two configuration files:
+
+| File | Scope | Content |
+|------|-------|---------|
+| `~/.aia/config.yaml` | **User (global)** | user_name, communication_language |
+| `.aia/config.yaml` | **Project** | projectName, document_output_language, models, knowledge_default, context_files |
+
+When you run AIA, both configs are merged (user preferences + project config).
+
+#### User config (`~/.aia/config.yaml`)
+
+Your personal preferences, created automatically on first use:
+
+```yaml
+# ~/.aia/config.yaml
+user_name: John Doe
+communication_language: French
+```
+
+- **user_name**: Your name (shown to the AI for context)
+- **communication_language**: Language for AI responses and questions
+
+These are stored outside the project, so they're never committed to git.
+
+#### Project config (`.aia/config.yaml`)
+
+Shared project settings:
+
+```yaml
+# .aia/config.yaml
+projectName: My Project
+document_output_language: English
+models:
+  # ...
+```
+
+- **document_output_language**: Language for generated documents (specs, plans, etc.) - shared by the whole team
+
+#### .gitignore recommendation
+
+User preferences are stored in `~/.aia/config.yaml` (outside the project), so nothing extra is needed in `.gitignore`.
+
+If you want to ignore local project overrides, add to your `.gitignore`:
+
+```gitignore
+# AIA - ignore local overrides
+.aia/local.yaml
+```
+
+### 7. Configure models (project config)
 
 In `config.yaml`, assign models to steps with probability weights:
 
@@ -210,7 +261,7 @@ Use aliases to delegate to the CLI's default model:
 | `gpt-*`, `o[0-9]*` | `codex exec` | `gpt-4.1`, `o3`, `o4-mini` |
 | `gemini-*` | `gemini` | `gemini-2.5-pro`, `gemini-2.5-flash` |
 
-### 7. Run the feature pipeline
+### 8. Run the feature pipeline
 
 #### Step by step
 
@@ -315,7 +366,7 @@ The `init.md` file serves as the sole input context for the dev-plan step. Verbo
 aia quick add-rate-limit "Add rate limiting to the /api/upload endpoint" -v
 ```
 
-### 8. Print mode vs Agent mode
+### 9. Print mode vs Agent mode
 
 By default, AIA runs in **print mode** -- the AI generates text (specs, plans, reviews) saved to `.md` files.
 
@@ -341,7 +392,7 @@ The `implement` step always runs in agent mode automatically.
 
 Idle timeout resets every time the CLI produces output, so long-running steps that stream continuously won't time out.
 
-### 9. Scan your repo
+### 10. Scan your repo
 
 ```bash
 aia repo scan

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamptee/aia-code",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "AI Architecture Assistant - orchestrate AI-assisted development workflows via CLI tools (Claude, Codex, Gemini)",
   "type": "module",
   "license": "MIT",
@@ -33,9 +33,15 @@
     "start": "node bin/aia.js"
   },
   "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "busboy": "^1.6.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "fs-extra": "^11.2.0",
+    "node-pty": "^1.0.0",
+    "ws": "^8.18.0",
+    "xterm": "^5.3.0",
+    "xterm-addon-fit": "^0.8.0",
     "yaml": "^2.7.0"
   }
 }

package/src/commands/init.js

@@ -1,8 +1,9 @@
 import chalk from 'chalk';
 import { createAiaStructure } from '../services/scaffold.js';
-import { writeDefaultConfig } from '../services/config.js';
+import { writeDefaultConfig, isGlobalConfigured, updateGlobalConfig } from '../services/config.js';
 import { writeDefaultPrompts } from '../services/prompts.js';
 import { AIA_DIR } from '../constants.js';
+import { ask, askRequired, isInteractive } from '../utils/prompt.js';
 
 export function registerInitCommand(program) {
   program
@@ -10,6 +11,15 @@ export function registerInitCommand(program) {
     .description('Initialize .aia folder structure, default config, and prompt templates')
     .action(async () => {
       try {
+        // First-time user setup
+        if (!(await isGlobalConfigured()) && isInteractive()) {
+          console.log(chalk.cyan('First time setup - let\'s configure your preferences.\n'));
+          const name = await askRequired('Your name');
+          const lang = await ask('Communication language', 'English');
+          await updateGlobalConfig({ user_name: name, communication_language: lang });
+          console.log(chalk.green('\nUser preferences saved to ~/.aia/config.yaml\n'));
+        }
+
         await createAiaStructure();
         await writeDefaultConfig();
         await writeDefaultPrompts();

package/src/models.js

@@ -3,6 +3,7 @@ import fs from 'fs-extra';
 import yaml from 'yaml';
 import chalk from 'chalk';
 import { AIA_DIR } from './constants.js';
+import { loadGlobalConfig } from './services/config.js';
 
 export async function loadConfig(root = process.cwd()) {
   const configPath = path.join(root, AIA_DIR, 'config.yaml');
@@ -12,13 +13,29 @@ export async function loadConfig(root = process.cwd()) {
   }
 
   const raw = await fs.readFile(configPath, 'utf-8');
-  const config = yaml.parse(raw);
+  const projectConfig = yaml.parse(raw);
 
-  validateConfig(config, configPath);
+  validateConfig(projectConfig, configPath);
+
+  // Merge with global user config
+  const globalConfig = await loadGlobalConfig();
+  const config = { ...globalConfig, ...projectConfig };
 
   return config;
 }
 
+// Load only project config (without global merge)
+export async function loadProjectConfig(root = process.cwd()) {
+  const configPath = path.join(root, AIA_DIR, 'config.yaml');
+
+  if (!(await fs.pathExists(configPath))) {
+    throw new Error(`Config not found: ${configPath}`);
+  }
+
+  const raw = await fs.readFile(configPath, 'utf-8');
+  return yaml.parse(raw);
+}
+
 function validateConfig(config, configPath) {
   if (!config || typeof config !== 'object') {
     throw new Error(`Invalid config: ${configPath} must be a YAML object.`);

package/src/prompt-builder.js

@@ -77,7 +77,7 @@ async function loadPromptTemplate(step, root) {
   return content;
 }
 
-export async function buildPrompt(feature, step, { description, instructions, root = process.cwd() } = {}) {
+export async function buildPrompt(feature, step, { description, instructions, history, attachments, root = process.cwd() } = {}) {
   const config = await loadConfig(root);
 
   const [context, knowledgeCategories, initSpecs, featureContent, previousOutput, task] = await Promise.all([
@@ -95,12 +95,41 @@ export async function buildPrompt(feature, step, { description, instructions, ro
 
   parts.push('IMPORTANT: You are working on a feature development pipeline. Everything you need is provided below in this prompt. Do NOT attempt to read, search for, or reference any external files. Do NOT say files are missing. Work exclusively with the content given below.\n');
 
+  // Inject user preferences - document language is the ONLY thing that matters for output
+  const docLang = config.document_output_language || 'English';
+
+  parts.push('=== OUTPUT LANGUAGE ===\n');
+  parts.push(`Write ALL your output in ${docLang}. This is mandatory and non-negotiable.`);
+  parts.push(`Do NOT use any other language for the document content.\n`);
+
+  // Add conversation history if present (for multi-turn)
+  if (history && history.length > 0) {
+    parts.push('=== CONVERSATION HISTORY ===\n');
+    for (const msg of history) {
+      const prefix = msg.role === 'user' ? 'User' : 'Agent';
+      parts.push(`${prefix}: ${msg.content}`);
+    }
+    parts.push('');
+  }
+
   if (description) {
     parts.push('=== DESCRIPTION ===\n');
     parts.push(description);
     parts.push('');
   }
 
+  if (attachments && attachments.length > 0) {
+    parts.push('=== ATTACHMENTS ===\n');
+    parts.push('The user has attached the following files. Use the Read tool to view them:\n');
+    for (const a of attachments) {
+      // F11: Sanitize filename to prevent prompt injection
+      const safeFilename = String(a.filename || 'unknown').replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 255);
+      const safePath = String(a.path || '').slice(0, 1000);
+      parts.push(`- ${safeFilename}: ${safePath}`);
+    }
+    parts.push('');
+  }
+
   if (context) {
     parts.push('=== CONTEXT ===\n');
     parts.push(context);
@@ -136,5 +165,8 @@ export async function buildPrompt(feature, step, { description, instructions, ro
   parts.push('\n\n=== TASK ===\n');
   parts.push(task);
 
+  // Add language reminder at the end (always, to reinforce)
+  parts.push(`\n\n---\nREMINDER: Your entire output MUST be written in ${docLang}.`);
+
   return parts.join('\n');
 }

package/src/providers/anthropic.js

@@ -6,7 +6,7 @@ export async function generate(prompt, model, { verbose = false, apply = false,
     args.push('--model', model);
   }
   if (apply) {
-    args.push('--allowedTools', 'Edit', 'Write', 'Bash', 'Read', 'Glob', 'Grep');
+    args.push('--allowedTools', 'Edit,Write,Bash,Read,Glob,Grep');
   }
   if (verbose || apply) {
     args.push('--verbose');

package/src/providers/cli-runner.js

@@ -9,9 +9,10 @@ export function runCli(command, args, { stdin: stdinData, verbose = false, apply
     idleTimeoutMs = apply ? AGENT_IDLE_TIMEOUT_MS : DEFAULT_IDLE_TIMEOUT_MS;
   }
   return new Promise((resolve, reject) => {
+    const { CLAUDECODE, ...cleanEnv } = process.env;
     const child = spawn(command, args, {
       stdio: ['pipe', 'pipe', 'pipe'],
-      env: { ...process.env, FORCE_COLOR: '0' },
+      env: { ...cleanEnv, FORCE_COLOR: '0' },
     });
 
     const chunks = [];

package/src/services/config.js

@@ -1,10 +1,17 @@
 import path from 'node:path';
+import os from 'node:os';
 import fs from 'fs-extra';
 import yaml from 'yaml';
 import { AIA_DIR } from '../constants.js';
 
-const DEFAULT_CONFIG = {
+// Global user config directory
+const GLOBAL_AIA_DIR = path.join(os.homedir(), '.aia');
+const GLOBAL_CONFIG_PATH = path.join(GLOBAL_AIA_DIR, 'config.yaml');
+
+// Default config for PROJECT (.aia/config.yaml)
+const DEFAULT_PROJECT_CONFIG = {
   projectName: 'My Project',
+  document_output_language: 'English',
   models: {
     brief: [
       { model: 'claude-default', weight: 1 },
@@ -42,6 +49,12 @@ const DEFAULT_CONFIG = {
   ],
 };
 
+// Default config for USER (~/.aia/config.yaml)
+const DEFAULT_USER_CONFIG = {
+  user_name: '',
+  communication_language: 'English',
+};
+
 export async function writeDefaultConfig(root = process.cwd()) {
   const configPath = path.join(root, AIA_DIR, 'config.yaml');
 
@@ -49,6 +62,44 @@ export async function writeDefaultConfig(root = process.cwd()) {
     return;
   }
 
-  const content = yaml.stringify(DEFAULT_CONFIG);
+  const content = yaml.stringify(DEFAULT_PROJECT_CONFIG);
   await fs.writeFile(configPath, content, 'utf-8');
 }
+
+export async function ensureGlobalConfig() {
+  await fs.ensureDir(GLOBAL_AIA_DIR);
+
+  if (!(await fs.pathExists(GLOBAL_CONFIG_PATH))) {
+    const content = yaml.stringify(DEFAULT_USER_CONFIG);
+    await fs.writeFile(GLOBAL_CONFIG_PATH, content, 'utf-8');
+  }
+}
+
+export async function loadGlobalConfig() {
+  await ensureGlobalConfig();
+
+  const raw = await fs.readFile(GLOBAL_CONFIG_PATH, 'utf-8');
+  return yaml.parse(raw) || {};
+}
+
+export async function saveGlobalConfig(config) {
+  await fs.ensureDir(GLOBAL_AIA_DIR);
+  const content = yaml.stringify(config);
+  await fs.writeFile(GLOBAL_CONFIG_PATH, content, 'utf-8');
+}
+
+export async function isGlobalConfigured() {
+  const config = await loadGlobalConfig();
+  return config && config.user_name && config.user_name.trim() !== '';
+}
+
+export async function updateGlobalConfig(updates) {
+  const existing = await loadGlobalConfig();
+  const merged = { ...existing, ...updates };
+  await saveGlobalConfig(merged);
+  return merged;
+}
+
+export function getGlobalConfigPath() {
+  return GLOBAL_CONFIG_PATH;
+}

package/src/services/flow-analyzer.js

@@ -0,0 +1,32 @@
+const COMPLEXITY_INDICATORS = {
+  simple: ['fix', 'bug', 'typo', 'update', 'small', 'quick', 'minor', 'patch', 'hotfix', 'tweak'],
+  complex: ['refactor', 'architecture', 'migration', 'redesign', 'integration', 'new feature', 'complex', 'rewrite', 'overhaul', 'system']
+};
+
+export function suggestFlowType(description) {
+  if (!description || description.length < 50) {
+    return 'quick';
+  }
+
+  const lower = description.toLowerCase();
+  let simpleScore = 0;
+  let complexScore = 0;
+
+  COMPLEXITY_INDICATORS.simple.forEach(word => {
+    if (lower.includes(word)) simpleScore++;
+  });
+
+  COMPLEXITY_INDICATORS.complex.forEach(word => {
+    if (lower.includes(word)) complexScore++;
+  });
+
+  if (complexScore > simpleScore) {
+    return 'full';
+  }
+
+  if (simpleScore > 0 || description.length < 200) {
+    return 'quick';
+  }
+
+  return 'full';
+}

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, instructions, model: modelOverride, verbose = false, apply = false, root = process.cwd(), onData } = {}) {
+export async function runStep(step, feature, { description, instructions, history, attachments, 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(', ')}`);
   }
@@ -27,7 +27,7 @@ export async function runStep(step, feature, { description, instructions, model:
 
   try {
     const model = modelOverride || await resolveModel(step, root);
-    const prompt = await buildPrompt(feature, step, { description, instructions, root });
+    const prompt = await buildPrompt(feature, step, { description, instructions, history, attachments, root });
 
     const start = performance.now();
     const output = await callModel(model, prompt, { verbose, apply: shouldApply, onData });

package/src/services/status.js

@@ -46,6 +46,20 @@ export async function updateStepStatus(feature, step, value, root = process.cwd(
   await fs.writeFile(statusPath(feature, root), content, 'utf-8');
 }
 
+export async function updateFlowType(feature, flowType, root = process.cwd()) {
+  const status = await loadStatus(feature, root);
+  status.flow = flowType; // 'quick' or 'full'
+
+  // Set current_step based on flow type if not already started
+  const allPending = Object.values(status.steps).every(s => s === STEP_STATUS.PENDING);
+  if (allPending) {
+    status.current_step = flowType === 'quick' ? 'dev-plan' : 'brief';
+  }
+
+  const content = yaml.stringify(status);
+  await fs.writeFile(statusPath(feature, root), content, 'utf-8');
+}
+
 export async function resetStep(feature, step, root = process.cwd()) {
   if (!FEATURE_STEPS.includes(step)) {
     throw new Error(`Unknown step "${step}". Valid steps: ${FEATURE_STEPS.join(', ')}`);

package/src/services/suggestions.js

@@ -0,0 +1,166 @@
+const STEP_GUIDANCE = {
+  en: {
+    brief: {
+      summary: 'Product brief completed',
+      next: 'ba-spec',
+      actions: [
+        'Review the brief for completeness',
+        'Run: aia next <feature>',
+      ],
+      tips: ['If too vague, iterate with more context'],
+    },
+    'ba-spec': {
+      summary: 'Business analysis completed',
+      next: 'questions',
+      actions: [
+        'Check requirements are measurable',
+        'Run: aia next <feature>',
+      ],
+      tips: ['Missing acceptance criteria? Iterate.'],
+    },
+    questions: {
+      summary: 'Questions identified',
+      next: 'tech-spec',
+      actions: [
+        'Answer key questions in init.md or as iteration instructions',
+        'Run: aia next <feature>',
+      ],
+      tips: ['Unanswered questions will affect quality of next steps'],
+    },
+    'tech-spec': {
+      summary: 'Technical specification ready',
+      next: 'challenge',
+      actions: [
+        'Review technical choices and constraints',
+        'Run: aia next <feature>',
+      ],
+      tips: ['Consider performance and scalability implications'],
+    },
+    challenge: {
+      summary: 'Challenges identified',
+      next: 'dev-plan',
+      actions: [
+        'Address critical challenges before proceeding',
+        'Run: aia next <feature>',
+      ],
+      tips: ['Unresolved challenges may cause issues during implementation'],
+    },
+    'dev-plan': {
+      summary: 'Development plan ready',
+      next: 'implement',
+      actions: [
+        'Review task breakdown',
+        'Run: aia next <feature> -a (agent mode)',
+      ],
+      tips: ['Implementation will modify your codebase'],
+    },
+    implement: {
+      summary: 'Implementation completed',
+      next: 'review',
+      actions: [
+        'Run tests',
+        'Manual verification',
+        'Run: aia next <feature>',
+      ],
+      tips: ['Check files created/modified'],
+    },
+    review: {
+      summary: 'Feature complete!',
+      next: null,
+      actions: [
+        'Address review comments',
+        'Merge to main branch',
+      ],
+      tips: [],
+    },
+  },
+  fr: {
+    brief: {
+      summary: 'Brief produit terminé',
+      next: 'ba-spec',
+      actions: [
+        'Vérifier que le brief est complet',
+        'Lancer : aia next <feature>',
+      ],
+      tips: ['Si trop vague, itérer avec plus de contexte'],
+    },
+    'ba-spec': {
+      summary: 'Analyse métier terminée',
+      next: 'questions',
+      actions: [
+        'Vérifier que les exigences sont mesurables',
+        'Lancer : aia next <feature>',
+      ],
+      tips: ['Critères d\'acceptation manquants ? Itérer.'],
+    },
+    questions: {
+      summary: 'Questions identifiées',
+      next: 'tech-spec',
+      actions: [
+        'Répondre aux questions clés dans init.md ou via instructions d\'itération',
+        'Lancer : aia next <feature>',
+      ],
+      tips: ['Les questions sans réponse affecteront la qualité des étapes suivantes'],
+    },
+    'tech-spec': {
+      summary: 'Spécification technique prête',
+      next: 'challenge',
+      actions: [
+        'Revoir les choix techniques et contraintes',
+        'Lancer : aia next <feature>',
+      ],
+      tips: ['Considérer les implications de performance et scalabilité'],
+    },
+    challenge: {
+      summary: 'Défis identifiés',
+      next: 'dev-plan',
+      actions: [
+        'Traiter les défis critiques avant de continuer',
+        'Lancer : aia next <feature>',
+      ],
+      tips: ['Les défis non résolus peuvent causer des problèmes lors de l\'implémentation'],
+    },
+    'dev-plan': {
+      summary: 'Plan de développement prêt',
+      next: 'implement',
+      actions: [
+        'Revoir le découpage des tâches',
+        'Lancer : aia next <feature> -a (mode agent)',
+      ],
+      tips: ['L\'implémentation va modifier votre code'],
+    },
+    implement: {
+      summary: 'Implémentation terminée',
+      next: 'review',
+      actions: [
+        'Lancer les tests',
+        'Vérification manuelle',
+        'Lancer : aia next <feature>',
+      ],
+      tips: ['Vérifier les fichiers créés/modifiés'],
+    },
+    review: {
+      summary: 'Feature terminée !',
+      next: null,
+      actions: [
+        'Traiter les commentaires de review',
+        'Merger sur la branche principale',
+      ],
+      tips: [],
+    },
+  },
+};
+
+function getLanguageCode(language) {
+  if (!language) return 'en';
+  const lower = language.toLowerCase();
+  if (lower.includes('french') || lower.includes('français')) return 'fr';
+  if (lower.includes('english') || lower.includes('anglais')) return 'en';
+  return 'en';
+}
+
+export function getGuidance(step, language = 'English') {
+  const langCode = getLanguageCode(language);
+  const guidance = STEP_GUIDANCE[langCode]?.[step] || STEP_GUIDANCE.en[step];
+  return guidance || null;
+}