chati-dev 2.0.8 → 2.1.0

package/src/orchestrator/agent-selector.js

@@ -9,15 +9,15 @@ import { INTENT_TYPES } from './intent-classifier.js';
  * The complete agent pipeline in execution order.
  */
 export const AGENT_PIPELINE = [
-  { name: 'greenfield-wu', phase: 'planning', group: 'wu', parallel: false },
-  { name: 'brownfield-wu', phase: 'planning', group: 'wu', parallel: false },
-  { name: 'brief', phase: 'planning', group: 'planning', parallel: false },
-  { name: 'detail', phase: 'planning', group: 'planning-parallel', parallel: true },
-  { name: 'architect', phase: 'planning', group: 'planning-parallel', parallel: true },
-  { name: 'ux', phase: 'planning', group: 'planning-parallel', parallel: true },
-  { name: 'phases', phase: 'planning', group: 'planning', parallel: false },
-  { name: 'tasks', phase: 'planning', group: 'planning', parallel: false },
-  { name: 'qa-planning', phase: 'planning', group: 'quality', parallel: false },
+  { name: 'greenfield-wu', phase: 'discover', group: 'wu', parallel: false },
+  { name: 'brownfield-wu', phase: 'discover', group: 'wu', parallel: false },
+  { name: 'brief', phase: 'discover', group: 'discover', parallel: false },
+  { name: 'detail', phase: 'plan', group: 'plan-parallel', parallel: true },
+  { name: 'architect', phase: 'plan', group: 'plan-parallel', parallel: true },
+  { name: 'ux', phase: 'plan', group: 'plan-parallel', parallel: true },
+  { name: 'phases', phase: 'plan', group: 'plan', parallel: false },
+  { name: 'tasks', phase: 'plan', group: 'plan', parallel: false },
+  { name: 'qa-planning', phase: 'plan', group: 'quality', parallel: false },
   { name: 'dev', phase: 'build', group: 'build', parallel: false },
   { name: 'qa-implementation', phase: 'build', group: 'quality', parallel: false },
   { name: 'devops', phase: 'deploy', group: 'deploy', parallel: false },
@@ -58,7 +58,7 @@ function getAgentsByGroup(group) {
  *
  * @param {object} context
  * @param {string} context.intent - Classified intent
- * @param {string} context.mode - Current mode (planning/build/deploy)
+ * @param {string} context.mode - Current mode (discover/plan/build/deploy)
  * @param {string} [context.currentAgent] - Currently active agent
  * @param {string[]} [context.completedAgents] - Already completed agents
  * @param {boolean} [context.isGreenfield] - true for new projects, false for existing
@@ -88,7 +88,7 @@ export function selectAgent(context) {
   // If starting fresh with no completed agents
   if (completedAgents.length === 0) {
     // Planning intent starts with WU
-    if (intent === INTENT_TYPES.PLANNING) {
+    if (intent === INTENT_TYPES.DISCOVER) {
       const wuAgent = isGreenfield ? 'greenfield-wu' : 'brownfield-wu';
       return {
         agent: wuAgent,

package/src/orchestrator/intent-classifier.js

@@ -7,7 +7,7 @@
  * Intent categories the classifier can identify.
  */
 export const INTENT_TYPES = {
-  PLANNING: 'planning',
+  DISCOVER: 'discover',
   IMPLEMENTATION: 'implementation',
   REVIEW: 'review',
   DEPLOY: 'deploy',
@@ -23,7 +23,7 @@ export const INTENT_TYPES = {
  * Higher weight = stronger signal for that intent.
  */
 const INTENT_KEYWORDS = {
-  [INTENT_TYPES.PLANNING]: {
+  [INTENT_TYPES.DISCOVER]: {
     high: ['plan', 'design', 'architecture', 'structure', 'requirements', 'spec', 'specification'],
     medium: ['define', 'outline', 'organize', 'prepare', 'brief', 'draft'],
     low: ['think', 'consider', 'analyze', 'brainstorm'],
@@ -83,14 +83,18 @@ const WEIGHTS = {
  * Context boost multipliers based on current mode.
  */
 const MODE_CONTEXT_BOOST = {
-  planning: {
-    [INTENT_TYPES.PLANNING]: 1.5,
+  discover: {
+    [INTENT_TYPES.DISCOVER]: 1.5,
+    [INTENT_TYPES.IMPLEMENTATION]: 0.5,
+  },
+  plan: {
+    [INTENT_TYPES.DISCOVER]: 1.2,
     [INTENT_TYPES.IMPLEMENTATION]: 0.5,
   },
   build: {
     [INTENT_TYPES.IMPLEMENTATION]: 1.5,
     [INTENT_TYPES.REVIEW]: 1.2,
-    [INTENT_TYPES.PLANNING]: 0.5,
+    [INTENT_TYPES.DISCOVER]: 0.5,
   },
   deploy: {
     [INTENT_TYPES.DEPLOY]: 1.5,
@@ -198,11 +202,11 @@ function buildReasoning(intent, keywords, context) {
  * Get intent-to-phase mapping.
  *
  * @param {string} intent
- * @returns {string} Target phase (planning, build, deploy)
+ * @returns {string} Target phase (discover, plan, build, deploy)
  */
 export function getIntentPhase(intent) {
   const phaseMap = {
-    [INTENT_TYPES.PLANNING]: 'planning',
+    [INTENT_TYPES.DISCOVER]: 'discover',
     [INTENT_TYPES.IMPLEMENTATION]: 'build',
     [INTENT_TYPES.REVIEW]: 'build',
     [INTENT_TYPES.DEPLOY]: 'deploy',
@@ -243,7 +247,7 @@ export function checkModeAlignment(intent, currentMode) {
   }
 
   // Check if mode change is allowed
-  const modeOrder = ['planning', 'build', 'deploy'];
+  const modeOrder = ['discover', 'plan', 'build', 'deploy'];
   const currentIndex = modeOrder.indexOf(currentMode);
   const targetIndex = modeOrder.indexOf(targetPhase);
 

package/src/orchestrator/pipeline-manager.js

@@ -8,7 +8,7 @@ import { AGENT_PIPELINE, getNextAgent } from './agent-selector.js';
 /**
  * Pipeline phases in order.
  */
-export const PIPELINE_PHASES = ['planning', 'build', 'deploy'];
+export const PIPELINE_PHASES = ['discover', 'plan', 'build', 'deploy'];
 
 /**
  * Agent status values.
@@ -35,7 +35,7 @@ const QA_IMPLEMENTATION_THRESHOLD = 95;
  * @returns {object} Pipeline state
  */
 export function initPipeline(options = {}) {
-  const { isGreenfield = true, mode = 'planning' } = options;
+  const { isGreenfield = true, mode = 'discover' } = options;
 
   const agents = {};
   for (const agentDef of AGENT_PIPELINE) {
@@ -112,6 +112,20 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
     const transitionCheck = checkPhaseTransition(newState);
 
     if (transitionCheck.canAdvance) {
+      // User Preview gate: when QA-Implementation passes in build phase,
+      // don't advance to deploy yet — let user preview first.
+      if (completedAgent === 'qa-implementation' && newState.phase === 'build') {
+        return {
+          state: newState,
+          nextAction: 'user_preview',
+          nextAgent: null,
+          needsModeSwitch: false,
+          previewContext: {
+            qaScore: newState.agents['qa-implementation'].score,
+          },
+        };
+      }
+
       // QA passed - advance to next phase
       const currentPhaseIndex = PIPELINE_PHASES.indexOf(newState.phase);
       if (currentPhaseIndex < PIPELINE_PHASES.length - 1) {
@@ -257,7 +271,17 @@ export function checkPhaseTransition(pipelineState) {
   const { phase, agents } = pipelineState;
 
   // Check based on current phase
-  if (phase === 'planning') {
+  if (phase === 'discover') {
+    // DISCOVER -> PLAN transition: all discover agents must be completed
+    // (brief must be done to advance to plan)
+    return {
+      canAdvance: true,
+      reason: 'Discover phase agents completed',
+      requiredScore: null,
+    };
+  }
+
+  if (phase === 'plan') {
     // Need QA-Planning to be completed with score >= 95
     const qaPlanning = agents['qa-planning'];
     if (!qaPlanning) {
@@ -490,3 +514,76 @@ export function markAgentInProgress(pipelineState, agentName) {
 
   return newState;
 }
+
+/**
+ * Confirm user preview decision and advance pipeline accordingly.
+ * Called by the orchestrator after the user evaluates the local preview.
+ *
+ * @param {object} pipelineState - Current state (phase must be 'build')
+ * @param {'approve_keep'|'approve_kill'|'adjust'|'rethink'} decision
+ * @returns {{ state: object, nextAction: string, nextAgent: string|null, needsModeSwitch: boolean, serverAction?: string }}
+ */
+export function confirmPreview(pipelineState, decision) {
+  const newState = { ...pipelineState };
+
+  if (decision === 'approve_keep' || decision === 'approve_kill') {
+    const nextPhase = 'deploy';
+
+    newState.modeTransitions.push({
+      from: 'build',
+      to: nextPhase,
+      trigger: 'user_preview_approved',
+      timestamp: new Date().toISOString(),
+      reason: `User approved preview (server: ${decision === 'approve_keep' ? 'kept alive' : 'killed'})`,
+    });
+
+    newState.phase = nextPhase;
+
+    newState.history.push({
+      agent: 'orchestrator',
+      action: 'preview_approved',
+      timestamp: new Date().toISOString(),
+      decision,
+    });
+
+    return {
+      state: newState,
+      nextAction: 'advance_phase',
+      nextAgent: getFirstAgentInPhase(newState, nextPhase),
+      needsModeSwitch: true,
+      serverAction: decision === 'approve_kill' ? 'kill' : 'keep',
+    };
+  }
+
+  if (decision === 'adjust') {
+    newState.history.push({
+      agent: 'orchestrator',
+      action: 'preview_adjust',
+      timestamp: new Date().toISOString(),
+    });
+
+    return {
+      state: newState,
+      nextAction: 'continue',
+      nextAgent: 'dev',
+      needsModeSwitch: false,
+    };
+  }
+
+  if (decision === 'rethink') {
+    newState.history.push({
+      agent: 'orchestrator',
+      action: 'preview_rethink',
+      timestamp: new Date().toISOString(),
+    });
+
+    return {
+      state: newState,
+      nextAction: 'deviation',
+      nextAgent: null,
+      needsModeSwitch: false,
+    };
+  }
+
+  throw new Error(`Invalid preview decision: ${decision}`);
+}

package/src/orchestrator/pipeline-state.js

@@ -44,7 +44,7 @@ export function loadPipelineState(projectDir) {
 
     // Extract pipeline-relevant fields
     const state = {
-      phase: session.mode || 'planning',
+      phase: session.mode || 'discover',
       isGreenfield: session.project_type === 'greenfield',
       startedAt: session.started_at || null,
       completedAt: session.completed_at || null,

package/src/orchestrator/session-manager.js

@@ -16,7 +16,8 @@ const SESSION_FILE = '.chati/session.yaml';
  */
 const DEFAULT_SESSION = {
   version: '1.0',
-  mode: 'planning',
+  mode: 'discover',
+  project: { name: '', type: 'greenfield', state: 'discover' },
   language: 'en',
   project_type: 'greenfield',
   started_at: null,
@@ -65,7 +66,12 @@ export function initSession(projectDir, options = {}) {
 
   const session = {
     ...DEFAULT_SESSION,
-    mode: options.mode || 'planning',
+    mode: options.mode || 'discover',
+    project: {
+      name: options.projectName || '',
+      type: options.isGreenfield === false ? 'brownfield' : 'greenfield',
+      state: options.mode || 'discover',
+    },
     language: options.language || 'en',
     project_type: options.isGreenfield === false ? 'brownfield' : 'greenfield',
     started_at: new Date().toISOString(),
@@ -220,8 +226,11 @@ export function recordModeTransition(projectDir, transition) {
     timestamp: new Date().toISOString(),
   });
 
-  // Update current mode
+  // Update current mode (both flat and nested for compatibility)
   session.mode = transition.to;
+  if (session.project) {
+    session.project.state = transition.to;
+  }
 
   return updateSession(projectDir, session);
 }
@@ -383,7 +392,7 @@ export function validateSession(projectDir) {
   }
 
   // Validate mode
-  const validModes = ['planning', 'build', 'validate', 'deploy', 'completed'];
+  const validModes = ['discover', 'plan', 'build', 'validate', 'deploy', 'completed'];
   if (!validModes.includes(session.mode)) {
     return {
       exists: true,

package/src/preview/detector.js

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview Framework and dev command detection for User Preview.
+ * Analyzes the project directory to determine what dev server to run.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Framework detection rules (checked in priority order).
+ * Framework-specific config files take precedence over generic package.json scripts.
+ */
+const FRAMEWORK_DETECTORS = [
+  {
+    files: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
+    framework: 'nextjs',
+    defaultPort: 3000,
+    kind: 'fullstack',
+  },
+  {
+    files: ['nuxt.config.js', 'nuxt.config.ts'],
+    framework: 'nuxt',
+    defaultPort: 3000,
+    kind: 'fullstack',
+  },
+  {
+    files: ['vite.config.js', 'vite.config.ts', 'vite.config.mjs'],
+    framework: 'vite',
+    defaultPort: 5173,
+    kind: 'frontend',
+  },
+  {
+    files: ['angular.json'],
+    framework: 'angular',
+    defaultPort: 4200,
+    kind: 'frontend',
+  },
+  {
+    files: ['svelte.config.js'],
+    framework: 'sveltekit',
+    defaultPort: 5173,
+    kind: 'frontend',
+  },
+  {
+    files: ['astro.config.mjs', 'astro.config.ts'],
+    framework: 'astro',
+    defaultPort: 4321,
+    kind: 'frontend',
+  },
+  {
+    files: ['manage.py'],
+    framework: 'django',
+    defaultPort: 8000,
+    kind: 'fullstack',
+  },
+];
+
+/**
+ * API framework packages — if found in dependencies, the project is an API.
+ */
+const API_PACKAGES = ['express', 'fastify', 'koa', 'hapi', 'nest', '@nestjs/core', 'restify'];
+
+/**
+ * Preferred npm script names in priority order.
+ */
+const SCRIPT_PRIORITY = ['dev', 'start', 'serve', 'preview'];
+
+/**
+ * Detect the dev command for a project.
+ *
+ * Detection priority:
+ *   1. Framework-specific config files (next.config.*, vite.config.*, etc.)
+ *   2. package.json scripts (dev > start > serve > preview)
+ *   3. Static index.html fallback (npx serve .)
+ *   4. null if nothing detected (CLI tools, libraries)
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {{ command: string, args: string[], description: string, framework: string, defaultPort: number } | null}
+ */
+export function detectDevCommand(projectDir) {
+  // 1. Framework-specific config files
+  for (const detector of FRAMEWORK_DETECTORS) {
+    if (detector.files.some((f) => existsSync(join(projectDir, f)))) {
+      return resolveFrameworkCommand(projectDir, detector);
+    }
+  }
+
+  // 2. package.json scripts
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      const scripts = pkg.scripts || {};
+
+      for (const script of SCRIPT_PRIORITY) {
+        if (scripts[script]) {
+          const defaultPort = 3000;
+          const command = script === 'start' ? 'npm' : 'npm';
+          const args = script === 'start' ? ['start'] : ['run', script];
+
+          return {
+            command,
+            args,
+            description: script === 'start' ? 'npm start' : `npm run ${script}`,
+            framework: 'node',
+            defaultPort,
+          };
+        }
+      }
+    } catch {
+      // Invalid package.json — skip
+    }
+  }
+
+  // 3. Static index.html fallback
+  if (existsSync(join(projectDir, 'index.html'))) {
+    return {
+      command: 'npx',
+      args: ['serve', '.'],
+      description: 'Static file server (npx serve)',
+      framework: 'static',
+      defaultPort: 3000,
+    };
+  }
+
+  // 4. Nothing detected
+  return null;
+}
+
+/**
+ * Detect the kind of project for UX messaging.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {'frontend'|'api'|'fullstack'|'cli'|'library'|'static'}
+ */
+export function detectProjectKind(projectDir) {
+  // Check framework-specific configs first
+  for (const detector of FRAMEWORK_DETECTORS) {
+    if (detector.files.some((f) => existsSync(join(projectDir, f)))) {
+      return detector.kind;
+    }
+  }
+
+  // Check package.json for API framework deps
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      const allDeps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies,
+      };
+
+      if (API_PACKAGES.some((p) => allDeps[p])) {
+        return 'api';
+      }
+
+      // Has bin field → CLI tool
+      if (pkg.bin) {
+        return 'cli';
+      }
+
+      // Has main/exports but no scripts → library
+      if ((pkg.main || pkg.exports) && !pkg.scripts?.dev && !pkg.scripts?.start) {
+        return 'library';
+      }
+    } catch {
+      // Invalid package.json
+    }
+  }
+
+  // Static HTML
+  if (existsSync(join(projectDir, 'index.html'))) {
+    return 'static';
+  }
+
+  // Python projects
+  if (existsSync(join(projectDir, 'manage.py'))) {
+    return 'fullstack';
+  }
+
+  // Default: assume library/CLI (no preview server)
+  return 'library';
+}
+
+/**
+ * Resolve the dev command for a known framework.
+ *
+ * @param {string} projectDir
+ * @param {object} detector - Framework detector entry
+ * @returns {{ command: string, args: string[], description: string, framework: string, defaultPort: number }}
+ */
+function resolveFrameworkCommand(projectDir, detector) {
+  const { framework, defaultPort, kind } = detector;
+
+  // Django has its own command
+  if (framework === 'django') {
+    return {
+      command: 'python',
+      args: ['manage.py', 'runserver'],
+      description: 'Django dev server',
+      framework,
+      defaultPort,
+    };
+  }
+
+  // Node-based frameworks: prefer package.json scripts
+  const pkgPath = join(projectDir, 'package.json');
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+      const scripts = pkg.scripts || {};
+
+      for (const script of SCRIPT_PRIORITY) {
+        if (scripts[script]) {
+          return {
+            command: 'npm',
+            args: script === 'start' ? ['start'] : ['run', script],
+            description: `${framework} (npm ${script === 'start' ? 'start' : `run ${script}`})`,
+            framework,
+            defaultPort,
+          };
+        }
+      }
+    } catch {
+      // Fall through to default
+    }
+  }
+
+  // Fallback for Node frameworks without scripts
+  return {
+    command: 'npm',
+    args: ['run', 'dev'],
+    description: `${framework} dev server`,
+    framework,
+    defaultPort,
+  };
+}

package/src/preview/index.js

@@ -0,0 +1,20 @@
+/**
+ * @fileoverview User Preview module — local server for pre-deploy validation.
+ *
+ * Detects the project's framework, spawns a dev server on an available port,
+ * captures logs for Dev agent context, and manages server lifecycle.
+ *
+ * Usage:
+ *   import { detectDevCommand, findAvailablePort, launchPreview } from './preview/index.js';
+ *
+ *   const devCmd = detectDevCommand(projectDir);
+ *   const port = await findAvailablePort(devCmd.defaultPort);
+ *   const handle = await launchPreview(projectDir, { ...devCmd, port });
+ *   // ... user validates ...
+ *   // handle.logs.toContext() → send to Dev agent
+ *   // await handle.kill() → when user decides to stop
+ */
+
+export { detectDevCommand, detectProjectKind } from './detector.js';
+export { findAvailablePort, launchPreview, waitForServer, openBrowser } from './launcher.js';
+export { LogBuffer } from './log-buffer.js';