chati-dev 3.3.2 → 4.0.1

package/src/terminal/run-parallel.js

@@ -16,11 +16,12 @@
 
 import { fileURLToPath } from 'url';
 import { buildAgentPrompt } from './prompt-builder.js';
-import { spawnParallelGroup } from './spawner.js';
+import { spawnParallelGroup, spawnTerminal } from './spawner.js';
 import { TerminalMonitor } from './monitor.js';
 import { collectResults, mergeHandoffs, buildConsolidatedHandoff } from './collector.js';
 import { parseAgentOutput } from './handoff-parser.js';
 import { estimateTokens, COST_PER_1K } from './cost-tracker.js';
+import { getRateLimiter } from './rate-limiter.js';
 
 // ---------------------------------------------------------------------------
 // CLI argument parsing
@@ -119,13 +120,29 @@ async function main() {
     }
   }
 
-  // Spawn all terminals in parallel
+  // Check rate limit capacity before spawning
+  const groupProvider = configs[0]?.provider || 'claude';
+  const limiter = getRateLimiter(groupProvider);
+  const rateStats = limiter.getStats();
+  const availableSlots = rateStats.limit - rateStats.used;
+  if (availableSlots < configs.length) {
+    console.error(`[chati] Rate limiter: ${availableSlots} slots available for ${configs.length} agents. Spawns may be throttled.`);
+  }
+
+  // Spawn all terminals in parallel (with sequential fallback)
   let group;
+  let fallbackUsed = false;
   try {
     group = spawnParallelGroup(configs);
   } catch (err) {
-    outputError(`Failed to spawn parallel group: ${err.message}`);
-    process.exit(1);
+    console.error(`[chati] Parallel spawn failed: ${err.message}. Falling back to sequential execution.`);
+    try {
+      group = await sequentialFallback(configs, timeout);
+      fallbackUsed = true;
+    } catch (fallbackErr) {
+      outputError(`Sequential fallback also failed: ${fallbackErr.message}`);
+      process.exit(1);
+    }
   }
 
   // Monitor until completion
@@ -218,6 +235,7 @@ async function main() {
       timeSaved: elapsed * (agents.length - 1),
     },
     costEstimate: costEstimates,
+    fallbackUsed,
   };
 
   process.stdout.write(JSON.stringify(output, null, 2) + '\n');
@@ -228,6 +246,60 @@ async function main() {
 // Helpers
 // ---------------------------------------------------------------------------
 
+/**
+ * Sequential fallback: spawn agents one at a time when parallel spawning fails.
+ * Produces the same group structure as spawnParallelGroup for transparent handling.
+ *
+ * @param {object[]} configs - Agent spawn configurations
+ * @param {number} timeout - Per-agent timeout in ms
+ * @returns {Promise<{ groupId: string, terminals: object[] }>}
+ */
+async function sequentialFallback(configs, timeout) {
+  const groupId = `seq-fallback-${Date.now()}`;
+  const terminals = [];
+
+  for (let i = 0; i < configs.length; i++) {
+    const cfg = configs[i];
+    const terminal = spawnTerminal({
+      agent: cfg.agent,
+      taskId: cfg.taskId,
+      model: cfg.model,
+      provider: cfg.provider,
+      prompt: cfg.prompt,
+      workingDir: cfg.workingDir,
+      timeout: cfg.timeout || timeout,
+    });
+
+    // Wait for this terminal to finish before spawning the next
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        terminal.kill?.();
+        resolve();
+      }, (cfg.timeout || timeout) + 5_000);
+
+      terminal.onExit?.(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+
+      // If terminal doesn't have onExit, resolve after a short poll
+      if (!terminal.onExit) {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+
+    terminals.push(terminal);
+
+    // Small delay between spawns to avoid rate limit pressure
+    if (i < configs.length - 1) {
+      await new Promise(r => setTimeout(r, 500));
+    }
+  }
+
+  return { groupId, terminals };
+}
+
 /**
  * Determine the next sequential agent after a parallel group.
  * GROUP 1 (detail+architect+ux) → phases
@@ -256,4 +328,4 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
   });
 }
 
-export { parseArgs, determineNextAgent };
+export { parseArgs, determineNextAgent, sequentialFallback };

package/src/terminal/spawner.js

@@ -10,6 +10,7 @@
 import { spawn } from 'child_process';
 import { validateWriteScopes, buildIsolationEnv } from './isolation.js';
 import { getProvider } from './cli-registry.js';
+import { getRateLimiter } from './rate-limiter.js';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -234,6 +235,10 @@ export function spawnTerminal(config) {
     timeout,
   };
 
+  // Record spawn in rate limiter for throttling
+  const providerForRate = config.provider || 'claude';
+  getRateLimiter(providerForRate).recordSpawn();
+
   // Capture output (capped at ~10MB to prevent unbounded memory growth)
   const MAX_BUFFER_CHUNKS = 10_000;
   if (child.stdout) {
@@ -297,6 +302,14 @@ export function spawnParallelGroup(configs) {
     throw new Error(`Write scope conflicts detected: ${details}`);
   }
 
+  // Preemptive rate limit capacity check
+  const groupProvider = configs[0]?.provider || 'claude';
+  const limiter = getRateLimiter(groupProvider);
+  const stats = limiter.getStats();
+  if (stats.used + configs.length > stats.limit) {
+    console.error(`[chati] Rate limit warning: ${stats.used}/${stats.limit} slots used, requesting ${configs.length} more`);
+  }
+
   const groupId = `group-${Date.now()}`;
   const terminals = configs.map(cfg => spawnTerminal(cfg));
 

package/src/utils/feature-flags.js

@@ -0,0 +1,106 @@
+/**
+ * @fileoverview Feature flag reader for chati.dev framework.
+ *
+ * Reads the `features:` section from config.yaml and returns boolean
+ * values for each feature toggle. All features default to false when
+ * not explicitly set.
+ *
+ * Uses lightweight regex-based parsing consistent with config-parser.js.
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * All known feature flags with their default values.
+ * New features start as false (opt-in).
+ */
+const DEFAULTS = {
+  hybrid_budget: false,
+  anti_dash: false,
+  rate_limiter_integration: false,
+  l5_keywords: false,
+  prompt_size_guard: false,
+  ids_decision_engine: false,
+  surface_criteria: false,
+  parallel_fallback: false,
+  tool_mesh: false,
+  tech_presets: false,
+  doctor_autofix: false,
+  brandbook: false,
+};
+
+/**
+ * Check if a specific feature is enabled.
+ *
+ * @param {string} projectDir - Project root directory (contains chati.dev/)
+ * @param {string} featureName - Feature flag name (e.g., 'hybrid_budget')
+ * @returns {boolean} True if feature is enabled, false otherwise
+ */
+export function isFeatureEnabled(projectDir, featureName) {
+  const features = getEnabledFeatures(projectDir);
+  return features[featureName] ?? DEFAULTS[featureName] ?? false;
+}
+
+/**
+ * Get all feature flags with their current values.
+ *
+ * @param {string} projectDir - Project root directory (contains chati.dev/)
+ * @returns {Record<string, boolean>} Map of feature name to enabled status
+ */
+export function getEnabledFeatures(projectDir) {
+  const configPath = join(projectDir, 'chati.dev', 'config.yaml');
+  if (!existsSync(configPath)) {
+    return { ...DEFAULTS };
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  return parseFeaturesSection(raw);
+}
+
+/**
+ * Parse the features section from raw config.yaml content.
+ *
+ * @param {string} raw - Raw YAML content
+ * @returns {Record<string, boolean>} Parsed feature flags merged with defaults
+ */
+export function parseFeaturesSection(raw) {
+  const result = { ...DEFAULTS };
+
+  // Find the features: block
+  const featuresMatch = raw.match(/^features:\s*\n((?:\s+\w[\w]*:\s*.+\n?)*)/m);
+  if (!featuresMatch) return result;
+
+  const block = featuresMatch[1];
+
+  // Extract each key: value pair
+  const linePattern = /^\s+(\w[\w]*):\s*(true|false)\s*$/gm;
+  let match;
+  while ((match = linePattern.exec(block)) !== null) {
+    const key = match[1];
+    const value = match[2] === 'true';
+    if (key in result) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get the list of known feature flag names.
+ *
+ * @returns {string[]} Array of feature flag names
+ */
+export function getFeatureNames() {
+  return Object.keys(DEFAULTS);
+}
+
+/**
+ * Get default values for all feature flags.
+ *
+ * @returns {Record<string, boolean>} Default feature flag values
+ */
+export function getDefaults() {
+  return { ...DEFAULTS };
+}