chati-dev 3.2.4 → 3.3.0

package/src/orchestrator/intent-classifier.js

@@ -16,6 +16,8 @@ export const INTENT_TYPES = {
   STATUS: 'status',
   RESUME: 'resume',
   HELP: 'help',
+  QUICK_FLOW: 'quick_flow',
+  STANDARD_FLOW: 'standard_flow',
 };
 
 /**
@@ -68,6 +70,16 @@ const INTENT_KEYWORDS = {
     medium: ['how to', 'what is', 'explain', 'confused'],
     low: ['support', 'assist', 'info'],
   },
+  [INTENT_TYPES.QUICK_FLOW]: {
+    high: ['quick fix', 'hotfix', 'bug fix', 'small change', 'just fix', 'just do it'],
+    medium: ['fix', 'tweak', 'config', 'patch', 'simple'],
+    low: ['change', 'adjust', 'small', 'update'],
+  },
+  [INTENT_TYPES.STANDARD_FLOW]: {
+    high: ['standard flow', 'standard pipeline', 'medium project', 'moderate scope'],
+    medium: ['feature', 'integration', 'enhancement', 'module', 'component'],
+    low: ['project', 'application', 'service', 'system'],
+  },
 };
 
 /**
@@ -215,6 +227,8 @@ export function getIntentPhase(intent) {
     [INTENT_TYPES.STATUS]: null, // no phase change
     [INTENT_TYPES.RESUME]: null, // uses current phase
     [INTENT_TYPES.HELP]: null, // no phase change
+    [INTENT_TYPES.QUICK_FLOW]: 'discover', // starts with quick brief
+    [INTENT_TYPES.STANDARD_FLOW]: 'discover', // starts with brief
   };
 
   return phaseMap[intent];
@@ -266,3 +280,171 @@ export function checkModeAlignment(intent, currentMode) {
     reason: `Intent requires ${targetPhase} mode (backward transition - deviation protocol)`,
   };
 }
+
+/**
+ * Quick Flow trigger and disqualifier keywords.
+ */
+const QUICK_FLOW_TRIGGERS = [
+  'quick fix', 'hotfix', 'bug fix', 'small change', 'just fix',
+  'just do it', 'simple fix', 'patch', 'config change',
+];
+
+const QUICK_FLOW_DISQUALIFIERS = [
+  'architecture', 'design system', 'database schema', 'auth',
+  'authentication', 'multiple services', 'microservices', 'enterprise',
+  'compliance', 'full pipeline', 'full process',
+];
+
+/**
+ * Detect if a message qualifies for Quick Flow (fast-track pipeline).
+ * Quick Flow skips Detail, Architect, UX, Phases, Tasks, QA-Planning.
+ *
+ * @param {string} message - User's raw input
+ * @param {object} [sessionContext] - { mode, currentAgent, isGreenfield, hasExistingCodebase }
+ * @returns {{ isQuickFlow: boolean, confidence: number, reason: string }}
+ */
+export function detectQuickFlow(message, sessionContext = {}) {
+  const normalized = message.toLowerCase().trim();
+
+  // Check for disqualifiers first (they override triggers)
+  for (const disqualifier of QUICK_FLOW_DISQUALIFIERS) {
+    if (normalized.includes(disqualifier)) {
+      return {
+        isQuickFlow: false,
+        confidence: 0.9,
+        reason: `Disqualified: message contains "${disqualifier}"`,
+      };
+    }
+  }
+
+  // Complex greenfield projects (multiple requirements, architecture needed) are disqualified
+  // But simple greenfield (single-purpose tool, fun project, prototype) are allowed
+  const sentenceCount = normalized.split(/[.!?]+/).filter((s) => s.trim().length > 0).length;
+  const requirementSignals = (normalized.match(/\band\b|\balso\b|\bplus\b|\badditionally\b/g) || []).length;
+
+  if (sessionContext.isGreenfield && (sentenceCount > 3 || requirementSignals > 2)) {
+    return {
+      isQuickFlow: false,
+      confidence: 0.7,
+      reason: 'Greenfield with multiple requirements detected',
+    };
+  }
+
+  // Check for trigger keywords
+  let triggerScore = 0;
+  const matchedTriggers = [];
+
+  for (const trigger of QUICK_FLOW_TRIGGERS) {
+    if (normalized.includes(trigger)) {
+      triggerScore += 3;
+      matchedTriggers.push(trigger);
+    }
+  }
+
+  // Single-sentence requests are a signal for quick flow
+  if (sentenceCount <= 1 && normalized.length < 200) {
+    triggerScore += 2;
+  }
+
+  // Calculate confidence
+  const confidence = Math.min(triggerScore / 5, 1.0);
+
+  if (confidence >= 0.8) {
+    return {
+      isQuickFlow: true,
+      confidence,
+      reason: `Quick flow triggers matched: ${matchedTriggers.join(', ') || 'short single-requirement message'}`,
+    };
+  }
+
+  return {
+    isQuickFlow: false,
+    confidence,
+    reason: `Confidence ${confidence.toFixed(2)} below threshold 0.8`,
+  };
+}
+
+/**
+ * Standard Flow trigger and disqualifier keywords.
+ */
+const STANDARD_FLOW_TRIGGERS = [
+  'standard flow', 'standard pipeline', 'medium project',
+  'new feature', 'integration', 'enhancement', 'module',
+];
+
+const STANDARD_FLOW_DISQUALIFIERS = [
+  'quick fix', 'hotfix', 'just fix', 'simple fix',
+  'full pipeline', 'full process', 'enterprise', 'compliance',
+];
+
+/**
+ * Detect if a message qualifies for Standard Flow (mid-tier pipeline).
+ * Standard Flow uses 8 agents (between Quick 4 and Full 12).
+ *
+ * @param {string} message - User's raw input
+ * @param {object} [sessionContext] - { mode, currentAgent, isGreenfield, hasExistingCodebase }
+ * @returns {{ isStandardFlow: boolean, confidence: number, reason: string }}
+ */
+export function detectStandardFlow(message, sessionContext = {}) {
+  const normalized = message.toLowerCase().trim();
+
+  // Check for disqualifiers first
+  for (const disqualifier of STANDARD_FLOW_DISQUALIFIERS) {
+    if (normalized.includes(disqualifier)) {
+      return {
+        isStandardFlow: false,
+        confidence: 0.9,
+        reason: `Disqualified: message contains "${disqualifier}"`,
+      };
+    }
+  }
+
+  // Count requirement signals
+  const sentenceCount = normalized.split(/[.!?]+/).filter(s => s.trim().length > 0).length;
+  const requirementSignals = (normalized.match(/\band\b|\balso\b|\bplus\b|\badditionally\b/g) || []).length;
+
+  // Heuristic: 2-5 requirements suggest standard flow (not quick, not full)
+  const requirementCount = sentenceCount + requirementSignals;
+
+  let triggerScore = 0;
+  const matchedTriggers = [];
+
+  // Check for trigger keywords
+  for (const trigger of STANDARD_FLOW_TRIGGERS) {
+    if (normalized.includes(trigger)) {
+      triggerScore += 3;
+      matchedTriggers.push(trigger);
+    }
+  }
+
+  // Requirement count in the sweet spot (2-5)
+  if (requirementCount >= 2 && requirementCount <= 5) {
+    triggerScore += 2;
+  }
+
+  // Brownfield moderate context
+  if (sessionContext.hasExistingCodebase || sessionContext.isGreenfield === false) {
+    triggerScore += 1;
+  }
+
+  // Message length in moderate range (not too short, not too long)
+  if (normalized.length > 100 && normalized.length < 1000) {
+    triggerScore += 1;
+  }
+
+  const confidence = Math.min(triggerScore / 5, 1.0);
+
+  if (confidence >= 0.8) {
+    return {
+      isStandardFlow: true,
+      confidence,
+      reason: `Standard flow triggers matched: ${matchedTriggers.join(', ') || 'moderate requirement count'}`,
+    };
+  }
+
+  return {
+    isStandardFlow: false,
+    confidence,
+    reason: `Confidence ${confidence.toFixed(2)} below threshold 0.8`,
+  };
+}

package/src/orchestrator/pipeline-manager.js

@@ -4,6 +4,10 @@
  */
 
 import { AGENT_PIPELINE, getNextAgent } from './agent-selector.js';
+import { calculateBracket, estimateRemaining } from '../context/bracket-tracker.js';
+import { track as telemetryTrack, flush as telemetryFlush } from '../telemetry/collector.js';
+import { sendEvents } from '../telemetry/sender.js';
+import { getTelemetryConfig } from '../telemetry/config.js';
 
 /**
  * Pipeline phases in order.
@@ -70,13 +74,95 @@ export function initPipeline(options = {}) {
   };
 }
 
+/**
+ * Standard Flow pipeline agents (mid-tier — 8 agents).
+ * Skips: WU, UX, Phases (tasks subsumes phase splitting).
+ */
+const STANDARD_FLOW_AGENTS = [
+  'brief', 'detail', 'architect', 'tasks',
+  'qa-planning', 'dev', 'qa-implementation', 'devops',
+];
+
+/**
+ * Quick Flow pipeline agents (subset of full pipeline).
+ * Skips: WU, Detail, Architect, UX, Phases, Tasks, QA-Planning.
+ */
+const QUICK_FLOW_AGENTS = ['brief', 'dev', 'qa-implementation', 'devops'];
+
+/**
+ * Initialize a Quick Flow pipeline (fast-track for simple tasks).
+ *
+ * @param {object} options - { isGreenfield, mode }
+ * @returns {object} Pipeline state
+ */
+export function initQuickFlowPipeline(options = {}) {
+  const { isGreenfield = false, mode = 'discover' } = options;
+
+  const agents = {};
+  for (const agentName of QUICK_FLOW_AGENTS) {
+    agents[agentName] = {
+      status: AGENT_STATUS.PENDING,
+      score: null,
+      startedAt: null,
+      completedAt: null,
+    };
+  }
+
+  return {
+    phase: mode,
+    isGreenfield,
+    isQuickFlow: true,
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+    agents,
+    completedAgents: [],
+    currentAgent: null,
+    modeTransitions: [],
+    history: [],
+  };
+}
+
+/**
+ * Initialize a Standard Flow pipeline (mid-tier for moderate tasks).
+ * Uses 8 agents — between Quick Flow (4) and Full Flow (12).
+ *
+ * @param {object} options - { isGreenfield, mode }
+ * @returns {object} Pipeline state
+ */
+export function initStandardFlowPipeline(options = {}) {
+  const { isGreenfield = false, mode = 'discover' } = options;
+
+  const agents = {};
+  for (const agentName of STANDARD_FLOW_AGENTS) {
+    agents[agentName] = {
+      status: AGENT_STATUS.PENDING,
+      score: null,
+      startedAt: null,
+      completedAt: null,
+    };
+  }
+
+  return {
+    phase: mode,
+    isGreenfield,
+    isStandardFlow: true,
+    startedAt: new Date().toISOString(),
+    completedAt: null,
+    agents,
+    completedAgents: [],
+    currentAgent: null,
+    modeTransitions: [],
+    history: [],
+  };
+}
+
 /**
  * Advance the pipeline after an agent completes.
  *
  * @param {object} pipelineState - Current state
  * @param {string} completedAgent - Agent that just finished
  * @param {object} [results] - Agent results (score, outputs)
- * @returns {{ state: object, nextAction: string, nextAgent: string|null, needsModeSwitch: boolean }}
+ * @returns {{ state: object, nextAction: string, nextAgent: string|null, needsModeSwitch: boolean, contextBracket: object }}
  */
 export function advancePipeline(pipelineState, completedAgent, results = {}) {
   const newState = { ...pipelineState };
@@ -98,6 +184,12 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
     newState.completedAgents.push(completedAgent);
   }
 
+  // Calculate context bracket from pipeline progress
+  const totalAgents = Object.keys(newState.agents).length;
+  const completedCount = newState.completedAgents.length;
+  const remaining = estimateRemaining(completedCount, totalAgents);
+  const contextBracket = calculateBracket(remaining);
+
   // Add to history
   newState.history.push({
     agent: completedAgent,
@@ -120,6 +212,7 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
           nextAction: 'user_preview',
           nextAgent: null,
           needsModeSwitch: false,
+          contextBracket,
           previewContext: {
             qaScore: newState.agents['qa-implementation'].score,
           },
@@ -146,16 +239,30 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
           nextAction: 'advance_phase',
           nextAgent: getFirstAgentInPhase(newState, nextPhase),
           needsModeSwitch: true,
+          contextBracket,
         };
       }
 
       // Pipeline complete
       newState.completedAt = new Date().toISOString();
+      telemetryTrack('pipeline_completed', {
+        pipelineType: newState.isQuickFlow ? 'quick-flow' : newState.isStandardFlow ? 'standard' : 'full',
+        totalDuration: Date.now() - new Date(newState.startedAt).getTime(),
+        agentsRun: newState.completedAgents.length,
+        finalStatus: 'completed',
+        deviationCount: (newState.modeTransitions || []).length,
+      });
+      const flushedEvents = telemetryFlush();
+      if (flushedEvents.length > 0) {
+        const tConfig = getTelemetryConfig(newState.targetDir || process.cwd());
+        sendEvents(flushedEvents, { ...tConfig, version: newState.chatiVersion || 'unknown' });
+      }
       return {
         state: newState,
         nextAction: 'complete',
         nextAgent: null,
         needsModeSwitch: false,
+        contextBracket,
       };
     } else {
       // QA failed - wait for issues to be fixed
@@ -164,6 +271,7 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
         nextAction: 'wait',
         nextAgent: null,
         needsModeSwitch: false,
+        contextBracket,
       };
     }
   }
@@ -192,16 +300,30 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
         nextAction: 'advance_phase',
         nextAgent: getFirstAgentInPhase(newState, nextPhase),
         needsModeSwitch: true,
+        contextBracket,
       };
     }
 
     // Pipeline complete
     newState.completedAt = new Date().toISOString();
+    telemetryTrack('pipeline_completed', {
+      pipelineType: newState.isQuickFlow ? 'quick-flow' : newState.isStandardFlow ? 'standard' : 'full',
+      totalDuration: Date.now() - new Date(newState.startedAt).getTime(),
+      agentsRun: newState.completedAgents.length,
+      finalStatus: 'completed',
+      deviationCount: (newState.modeTransitions || []).length,
+    });
+    const flushedEvents2 = telemetryFlush();
+    if (flushedEvents2.length > 0) {
+      const tConfig2 = getTelemetryConfig(newState.targetDir || process.cwd());
+      sendEvents(flushedEvents2, { ...tConfig2, version: newState.chatiVersion || 'unknown' });
+    }
     return {
       state: newState,
       nextAction: 'complete',
       nextAgent: null,
       needsModeSwitch: false,
+      contextBracket,
     };
   }
 
@@ -220,6 +342,7 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
       nextAction: 'continue',
       nextAgent: nextInfo.next,
       needsModeSwitch: false,
+      contextBracket,
     };
   }
 
@@ -229,6 +352,7 @@ export function advancePipeline(pipelineState, completedAgent, results = {}) {
     nextAction: 'wait',
     nextAgent: null,
     needsModeSwitch: false,
+    contextBracket,
   };
 }
 

package/src/orchestrator/session-manager.js

@@ -14,7 +14,10 @@ const SESSION_FILE = '.chati/session.yaml';
 /**
  * Default session template.
  */
+const CURRENT_SCHEMA_VERSION = '1.0';
+
 const DEFAULT_SESSION = {
+  schema_version: CURRENT_SCHEMA_VERSION,
   version: '1.0',
   mode: 'discover',
   project: { name: '', type: 'greenfield', state: 'discover' },
@@ -102,10 +105,38 @@ export function initSession(projectDir, options = {}) {
   }
 }
 
+/**
+ * Migrate a session object to the current schema version.
+ *
+ * @param {object} session - Session object (may be missing schema_version)
+ * @returns {{ migrated: boolean, fromVersion: string|null, toVersion: string }}
+ */
+export function migrateSession(session) {
+  if (!session || typeof session !== 'object') {
+    return { migrated: false, fromVersion: null, toVersion: CURRENT_SCHEMA_VERSION };
+  }
+
+  if (session.schema_version === CURRENT_SCHEMA_VERSION) {
+    return { migrated: false, fromVersion: session.schema_version, toVersion: CURRENT_SCHEMA_VERSION };
+  }
+
+  // v0 (no schema_version) → v1.0
+  const fromVersion = session.schema_version || null;
+  session.schema_version = CURRENT_SCHEMA_VERSION;
+
+  // Ensure fields added in v1.0 exist
+  if (!session.completed_agents) session.completed_agents = [];
+  if (!session.agent_results) session.agent_results = {};
+  if (!session.deviations) session.deviations = [];
+  if (!session.mode_transitions) session.mode_transitions = [];
+
+  return { migrated: true, fromVersion, toVersion: CURRENT_SCHEMA_VERSION };
+}
+
 /**
  * Load current session state.
  * @param {string} projectDir
- * @returns {{ loaded: boolean, session: object|null, error: string|null }}
+ * @returns {{ loaded: boolean, session: object|null, error: string|null, migrated?: boolean }}
  */
 export function loadSession(projectDir) {
   const sessionPath = join(projectDir, SESSION_FILE);
@@ -122,10 +153,22 @@ export function loadSession(projectDir) {
     const content = readFileSync(sessionPath, 'utf-8');
     const session = yaml.load(content);
 
+    // Run migration if needed
+    const migration = migrateSession(session);
+    if (migration.migrated) {
+      try {
+        const yamlContent = yaml.dump(session, { lineWidth: -1, noRefs: true });
+        writeFileSync(sessionPath, yamlContent, 'utf-8');
+      } catch {
+        // Migration write failed — continue with migrated in-memory session
+      }
+    }
+
     return {
       loaded: true,
       session,
       error: null,
+      migrated: migration.migrated,
     };
   } catch (err) {
     return {
@@ -351,6 +394,125 @@ export function getSessionSummary(projectDir) {
   };
 }
 
+// ---------------------------------------------------------------------------
+// Team / Concurrent Support
+// ---------------------------------------------------------------------------
+
+/**
+ * Claim session ownership for a user.
+ * Prevents concurrent users from modifying the same session.
+ *
+ * @param {string} projectDir
+ * @param {string} userId - Unique user identifier
+ * @returns {{ claimed: boolean, owner?: string, since?: string, error?: string }}
+ */
+export function claimSession(projectDir, userId) {
+  if (!projectDir || !userId) {
+    return { claimed: false, error: 'projectDir and userId are required' };
+  }
+
+  const loadResult = loadSession(projectDir);
+
+  if (!loadResult.loaded) {
+    return { claimed: false, error: loadResult.error };
+  }
+
+  const session = loadResult.session;
+
+  // Check existing ownership
+  if (session._owner && session._owner.userId && session._owner.userId !== userId) {
+    return {
+      claimed: false,
+      owner: session._owner.userId,
+      since: session._owner.since,
+      error: `Session already claimed by ${session._owner.userId}`,
+    };
+  }
+
+  // Claim it
+  const ownership = {
+    userId,
+    since: new Date().toISOString(),
+    hostname: typeof globalThis !== 'undefined' ? (globalThis.process?.env?.HOSTNAME || 'localhost') : 'localhost',
+    pid: process.pid,
+  };
+
+  const updateResult = updateSession(projectDir, { _owner: ownership });
+
+  if (!updateResult.saved) {
+    return { claimed: false, error: updateResult.error };
+  }
+
+  return { claimed: true, owner: userId, since: ownership.since };
+}
+
+/**
+ * Release session ownership.
+ *
+ * @param {string} projectDir
+ * @param {string} userId - User releasing the session
+ * @returns {{ released: boolean, error?: string }}
+ */
+export function releaseSession(projectDir, userId) {
+  if (!projectDir || !userId) {
+    return { released: false, error: 'projectDir and userId are required' };
+  }
+
+  const loadResult = loadSession(projectDir);
+
+  if (!loadResult.loaded) {
+    return { released: false, error: loadResult.error };
+  }
+
+  const session = loadResult.session;
+
+  // Only the owner can release
+  if (session._owner && session._owner.userId && session._owner.userId !== userId) {
+    return {
+      released: false,
+      error: `Cannot release: session owned by ${session._owner.userId}`,
+    };
+  }
+
+  const updateResult = updateSession(projectDir, { _owner: null });
+
+  if (!updateResult.saved) {
+    return { released: false, error: updateResult.error };
+  }
+
+  return { released: true };
+}
+
+/**
+ * Get current session owner information.
+ *
+ * @param {string} projectDir
+ * @returns {{ owner: string|null, since: string|null, hostname: string|null }}
+ */
+export function getSessionOwner(projectDir) {
+  if (!projectDir) {
+    return { owner: null, since: null, hostname: null };
+  }
+
+  const loadResult = loadSession(projectDir);
+
+  if (!loadResult.loaded || !loadResult.session._owner) {
+    return { owner: null, since: null, hostname: null };
+  }
+
+  const ownership = loadResult.session._owner;
+
+  return {
+    owner: ownership.userId || null,
+    since: ownership.since || null,
+    hostname: ownership.hostname || null,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
 /**
  * Check if a session exists and is valid.
  * @param {string} projectDir
@@ -380,7 +542,7 @@ export function validateSession(projectDir) {
   const session = loadResult.session;
 
   // Validate required fields
-  const requiredFields = ['version', 'mode', 'language', 'project_type', 'agents'];
+  const requiredFields = ['schema_version', 'version', 'mode', 'language', 'project_type', 'agents'];
   for (const field of requiredFields) {
     if (!session[field]) {
       return {