chati-dev 2.0.9 → 2.1.2

package/src/preview/launcher.js

@@ -0,0 +1,235 @@
+/**
+ * @fileoverview Preview server lifecycle management.
+ * Spawns dev servers, finds available ports, health-checks, and opens browsers.
+ * NEVER kills existing processes — only manages servers it spawns.
+ */
+
+import net from 'net';
+import http from 'http';
+import { spawn } from 'child_process';
+import { platform } from 'os';
+import { LogBuffer } from './log-buffer.js';
+
+/**
+ * Test if a port is available (not in use by another process).
+ * Uses net.createServer to probe — never kills existing services.
+ *
+ * @param {number} port
+ * @returns {Promise<boolean>}
+ */
+function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port);
+  });
+}
+
+/**
+ * Find an available port starting from a given number.
+ * Scans sequentially — NEVER kills existing processes on occupied ports.
+ *
+ * @param {number} [startPort=3000] - Port to start scanning from
+ * @param {number} [maxAttempts=20] - Maximum ports to try
+ * @returns {Promise<number>} Available port number
+ * @throws {Error} If no port is available within range
+ */
+export async function findAvailablePort(startPort = 3000, maxAttempts = 20) {
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const port = startPort + attempt;
+    const available = await isPortAvailable(port);
+    if (available) return port;
+  }
+
+  throw new Error(
+    `No available port found in range ${startPort}-${startPort + maxAttempts - 1}`,
+  );
+}
+
+/**
+ * Wait for an HTTP server to respond on the given URL.
+ * Polls with exponential backoff until the server is ready.
+ *
+ * @param {string} url - URL to check (e.g., "http://localhost:3000")
+ * @param {number} [timeout=30000] - Max wait time in ms
+ * @returns {Promise<void>}
+ * @throws {Error} If server doesn't respond within timeout
+ */
+export function waitForServer(url, timeout = 30000) {
+  const startTime = Date.now();
+  let delay = 500;
+
+  return new Promise((resolve, reject) => {
+    function attempt() {
+      if (Date.now() - startTime > timeout) {
+        reject(new Error(`Server at ${url} did not respond within ${timeout}ms`));
+        return;
+      }
+
+      const req = http.get(url, (res) => {
+        // Any response (even 404) means server is up
+        res.resume();
+        resolve();
+      });
+
+      req.on('error', () => {
+        // Server not ready yet — retry with backoff
+        delay = Math.min(delay * 1.5, 3000);
+        setTimeout(attempt, delay);
+      });
+
+      req.setTimeout(2000, () => {
+        req.destroy();
+        setTimeout(attempt, delay);
+      });
+    }
+
+    attempt();
+  });
+}
+
+/**
+ * Open a URL in the system's default browser.
+ *
+ * @param {string} url - URL to open
+ * @returns {void}
+ */
+export function openBrowser(url) {
+  const os = platform();
+  let command;
+  let args;
+
+  if (os === 'darwin') {
+    command = 'open';
+    args = [url];
+  } else if (os === 'win32') {
+    command = 'cmd';
+    args = ['/c', 'start', url];
+  } else {
+    command = 'xdg-open';
+    args = [url];
+  }
+
+  const proc = spawn(command, args, { stdio: 'ignore', detached: true });
+  proc.unref();
+}
+
+/**
+ * Gracefully kill a child process.
+ * Sends SIGTERM, waits 3s, then SIGKILL if still alive.
+ *
+ * @param {import('child_process').ChildProcess} proc
+ * @returns {Promise<void>}
+ */
+function killProcess(proc) {
+  return new Promise((resolve) => {
+    if (!proc || proc.killed || proc.exitCode !== null) {
+      resolve();
+      return;
+    }
+
+    const forceKillTimer = setTimeout(() => {
+      try {
+        proc.kill('SIGKILL');
+      } catch {
+        // Already dead
+      }
+      resolve();
+    }, 3000);
+
+    proc.once('exit', () => {
+      clearTimeout(forceKillTimer);
+      resolve();
+    });
+
+    try {
+      proc.kill('SIGTERM');
+    } catch {
+      clearTimeout(forceKillTimer);
+      resolve();
+    }
+  });
+}
+
+/**
+ * Launch a preview server for the project.
+ *
+ * @param {string} projectDir - Absolute path to project root
+ * @param {object} options
+ * @param {string} options.command - Command to run (e.g., "npm")
+ * @param {string[]} options.args - Command arguments (e.g., ["run", "dev"])
+ * @param {number} options.port - Port to use
+ * @param {string} [options.framework='unknown'] - Detected framework name
+ * @param {boolean} [options.openBrowser=true] - Open browser after server is ready
+ * @param {number} [options.timeout=30000] - Health check timeout in ms
+ * @returns {Promise<{ url: string, port: number, pid: number, framework: string, logs: LogBuffer, kill: () => Promise<void> }>}
+ */
+export async function launchPreview(projectDir, options) {
+  const {
+    command,
+    args,
+    port,
+    framework = 'unknown',
+    openBrowser: shouldOpenBrowser = true,
+    timeout = 30000,
+  } = options;
+
+  const logs = new LogBuffer();
+  const url = `http://localhost:${port}`;
+
+  // Spawn the dev server
+  const proc = spawn(command, args, {
+    cwd: projectDir,
+    env: { ...process.env, PORT: String(port) },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  // Capture stdout
+  if (proc.stdout) {
+    proc.stdout.on('data', (data) => {
+      for (const line of data.toString().split('\n')) {
+        if (line.trim()) logs.append(line, 'stdout');
+      }
+    });
+  }
+
+  // Capture stderr
+  if (proc.stderr) {
+    proc.stderr.on('data', (data) => {
+      for (const line of data.toString().split('\n')) {
+        if (line.trim()) logs.append(line, 'stderr');
+      }
+    });
+  }
+
+  // Handle spawn errors
+  const spawnError = await new Promise((resolve) => {
+    proc.once('error', (err) => resolve(err));
+    // Give it a moment to fail or succeed
+    setTimeout(() => resolve(null), 500);
+  });
+
+  if (spawnError) {
+    throw new Error(`Failed to start dev server: ${spawnError.message}`);
+  }
+
+  // Wait for the server to be ready
+  await waitForServer(url, timeout);
+
+  // Open browser
+  if (shouldOpenBrowser) {
+    openBrowser(url);
+  }
+
+  return {
+    url,
+    port,
+    pid: proc.pid,
+    framework,
+    logs,
+    kill: () => killProcess(proc),
+  };
+}

package/src/preview/log-buffer.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Circular log buffer for capturing server output.
+ * Used by the preview launcher to collect stdout/stderr from dev servers.
+ * Provides filtered views (errors, recent) for Dev agent context.
+ */
+
+/**
+ * Circular buffer that captures server logs with metadata.
+ * Automatically evicts oldest entries when capacity is reached.
+ */
+export class LogBuffer {
+  #lines = [];
+  #maxLines;
+
+  /**
+   * @param {number} [maxLines=200] - Maximum lines to retain
+   */
+  constructor(maxLines = 200) {
+    this.#maxLines = maxLines;
+  }
+
+  /**
+   * Append a log line.
+   * @param {string} line - Raw output line
+   * @param {'stdout'|'stderr'} [stream='stdout'] - Source stream
+   */
+  append(line, stream = 'stdout') {
+    if (typeof line !== 'string') return;
+
+    this.#lines.push({
+      line: line.trim(),
+      stream,
+      timestamp: Date.now(),
+    });
+
+    // Evict oldest when over capacity
+    if (this.#lines.length > this.#maxLines) {
+      this.#lines.shift();
+    }
+  }
+
+  /**
+   * Get all buffered lines.
+   * @returns {Array<{ line: string, stream: string, timestamp: number }>}
+   */
+  getAll() {
+    return [...this.#lines];
+  }
+
+  /**
+   * Get lines that look like errors or warnings.
+   * Includes all stderr lines + stdout lines matching error patterns.
+   * @returns {Array<{ line: string, stream: string, timestamp: number }>}
+   */
+  getErrors() {
+    return this.#lines.filter(
+      (l) =>
+        l.stream === 'stderr' ||
+        /(error|warn(ing)?|exception|failed|fatal|panic|unhandled)/i.test(l.line),
+    );
+  }
+
+  /**
+   * Get the N most recent lines.
+   * @param {number} [n=50] - Number of lines
+   * @returns {Array<{ line: string, stream: string, timestamp: number }>}
+   */
+  getRecent(n = 50) {
+    return this.#lines.slice(-n);
+  }
+
+  /**
+   * Get total number of buffered lines.
+   * @returns {number}
+   */
+  get size() {
+    return this.#lines.length;
+  }
+
+  /**
+   * Clear all buffered lines.
+   */
+  clear() {
+    this.#lines = [];
+  }
+
+  /**
+   * Format logs as structured context for the Dev agent.
+   * Includes error summary + recent output for debugging.
+   * @returns {{ totalLines: number, errorCount: number, errors: string[], recentOutput: string[] }}
+   */
+  toContext() {
+    const errors = this.getErrors();
+    const recent = this.getRecent(50);
+
+    return {
+      totalLines: this.#lines.length,
+      errorCount: errors.length,
+      errors: errors.map((e) => e.line),
+      recentOutput: recent.map((l) => `[${l.stream}] ${l.line}`),
+    };
+  }
+}

package/src/tasks/executor.js

@@ -186,7 +186,7 @@ function sanitizeSessionState(state) {
   if (!state) return null;
 
   return {
-    mode: state.mode || 'planning',
+    mode: state.mode || 'discover',
     current_agent: state.current_agent || null,
     pipeline_position: state.pipeline_position || null,
     completed_agents: state.completed_agents || [],

package/src/tasks/loader.js

@@ -59,7 +59,7 @@ export function parseTaskContent(content, source = 'unknown') {
         id: meta.id,
         agent: meta.agent,
         trigger: meta.trigger || 'orchestrator',
-        phase: meta.phase || 'planning',
+        phase: meta.phase || 'plan',
         requires_input: meta.requires_input === true || meta.requires_input === 'true',
         parallelizable: meta.parallelizable === true || meta.parallelizable === 'true',
         outputs: parseArray(meta.outputs),

package/src/terminal/prompt-builder.js

@@ -37,14 +37,14 @@ const AGENT_MODELS = {
  * Map of agent names to their definition file paths (relative to project root).
  */
 export const AGENT_FILE_MAP = {
-  'greenfield-wu': 'chati.dev/agents/planning/greenfield-wu.md',
-  'brownfield-wu': 'chati.dev/agents/planning/brownfield-wu.md',
-  brief: 'chati.dev/agents/planning/brief.md',
-  detail: 'chati.dev/agents/planning/detail.md',
-  architect: 'chati.dev/agents/planning/architect.md',
-  ux: 'chati.dev/agents/planning/ux.md',
-  phases: 'chati.dev/agents/planning/phases.md',
-  tasks: 'chati.dev/agents/planning/tasks.md',
+  'greenfield-wu': 'chati.dev/agents/discover/greenfield-wu.md',
+  'brownfield-wu': 'chati.dev/agents/discover/brownfield-wu.md',
+  brief: 'chati.dev/agents/discover/brief.md',
+  detail: 'chati.dev/agents/plan/detail.md',
+  architect: 'chati.dev/agents/plan/architect.md',
+  ux: 'chati.dev/agents/plan/ux.md',
+  phases: 'chati.dev/agents/plan/phases.md',
+  tasks: 'chati.dev/agents/plan/tasks.md',
   'qa-planning': 'chati.dev/agents/quality/qa-planning.md',
   dev: 'chati.dev/agents/build/dev.md',
   'qa-implementation': 'chati.dev/agents/quality/qa-implementation.md',
@@ -158,7 +158,7 @@ function buildPrismSection(config) {
   const result = runPrism({
     domainsDir,
     remainingPercent: 100, // Spawned terminals are always FRESH
-    mode: state.project?.state || 'planning',
+    mode: state.project?.state || 'discover',
     agent: config.agent,
     workflow: config.workflow || null,
     pipelinePosition: config.agent,
@@ -261,7 +261,7 @@ function buildSessionSection(config) {
     '',
     `- **Project**: ${project.name || '(unnamed)'}`,
     `- **Type**: ${project.type || 'greenfield'}`,
-    `- **Mode**: ${project.state || 'planning'}`,
+    `- **Mode**: ${project.state || 'discover'}`,
     `- **Language**: ${state.language || 'en'} (interaction) / English (artifacts)`,
     `- **User Level**: ${state.user_level || 'auto'}`,
     `- **Execution Mode**: ${state.execution_mode || 'autonomous'}`,

package/src/wizard/i18n.js

@@ -21,9 +21,9 @@ const FALLBACK_EN = {
     ides_label: 'IDEs',
     mcps_label: 'MCPs',
     will_install: 'Will install:',
-    agents_count: '13 agent definitions (PLANNING, BUILD, DEPLOY phases)',
-    workflows_count: '5 workflow blueprints',
-    templates_count: '5 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate)',
+    agents_count: '13 agent definitions (DISCOVER, PLAN, BUILD, DEPLOY phases)',
+    workflows_count: '6 workflow blueprints',
+    templates_count: '6 templates (PRD, Brownfield PRD, Architecture, Task, QA Gate, Quick Brief)',
     constitution: 'Constitution (17 Articles + Preamble)',
     session_mgmt: 'Session management system',
     quality_gates: 'Quality gates (4-tier validation)',