@polymorphism-tech/morph-spec 7.2.0 → 7.4.0

package/src/core/workflows/workflow-detector.js

@@ -1,586 +0,0 @@
-/**
- * @fileoverview Workflow Detection Engine
- *
- * Analyzes user requests to automatically select the appropriate workflow based on:
- * - Keyword matching
- * - Complexity estimation
- * - Workflow criteria
- *
- * @module workflow-detector
- */
-
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, dirname, basename } from 'path';
-import { fileURLToPath } from 'url';
-import { getPhaseSequence } from '../state/phase-state-machine.js';
-
-/**
- * Load the canonical phase id set from framework/phases.json.
- * Falls back to getPhaseSequence() if the file is unavailable.
- * @returns {Set<string>}
- */
-function getValidPhaseIds() {
-  try {
-    const phasesPath = join(__dirname, '..', '..', '..', 'framework', 'phases.json');
-    const { phases } = JSON.parse(readFileSync(phasesPath, 'utf8'));
-    return new Set(Object.keys(phases));
-  } catch {
-    // Graceful fallback to state machine list
-    return new Set(getPhaseSequence());
-  }
-}
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-/**
- * Get framework root directory
- * @param {string} projectPath - Project path
- * @returns {string} Framework root path
- */
-function getFrameworkRoot(projectPath) {
-  // Try npm-installed package first (only if it has the workflow configs)
-  const npmPath = join(projectPath, 'node_modules/@polymorphism-tech/morph-spec');
-  if (existsSync(npmPath) && existsSync(join(npmPath, 'framework/workflows/configs'))) {
-    return npmPath;
-  }
-
-  // Fallback to local development path (from src/core/workflows/ → root)
-  return join(__dirname, '..', '..', '..');
-}
-
-/**
- * Load all workflow configurations
- * @param {string} projectPath - Project path
- * @returns {Array<Object>} Array of workflow configs
- */
-function loadWorkflowConfigs(projectPath) {
-  const frameworkRoot = getFrameworkRoot(projectPath);
-  const configsDir = join(frameworkRoot, 'framework/workflows/configs');
-
-  if (!existsSync(configsDir)) {
-    return [];
-  }
-
-  const configFiles = readdirSync(configsDir).filter(f => f.endsWith('.json'));
-  const configs = [];
-
-  for (const file of configFiles) {
-    try {
-      const configPath = join(configsDir, file);
-      const content = readFileSync(configPath, 'utf8');
-      configs.push(JSON.parse(content));
-    } catch (err) {
-      // Skip invalid configs
-      continue;
-    }
-  }
-
-  return configs;
-}
-
-/**
- * Match keywords in user request
- * @param {string} userRequest - User request text
- * @param {Array<string>} keywords - Workflow keywords
- * @returns {{matched: Array<string>, score: number}}
- */
-function matchKeywords(userRequest, keywords) {
-  const requestLower = userRequest.toLowerCase();
-  const matched = [];
-
-  for (const keyword of keywords) {
-    const keywordLower = keyword.toLowerCase();
-
-    // Check for partial matches (e.g., "paginação" matches "pagination")
-    if (requestLower.includes(keywordLower)) {
-      matched.push(keyword);
-    }
-  }
-
-  // Score: percentage of keywords matched
-  const score = matched.length > 0 ? matched.length / keywords.length : 0;
-
-  return { matched, score };
-}
-
-/**
- * Estimate complexity from user request
- * @param {string} userRequest - User request text
- * @returns {{files: number, lines: number, components: number, hasInfra: boolean}}
- */
-function estimateComplexity(userRequest) {
-  const requestLower = userRequest.toLowerCase();
-
-  // Scope indicators
-  const scopeIndicators = {
-    trivial: ['button', 'cor', 'color', 'css', 'fix', 'typo', 'edge case', 'one'],
-    small: ['add', 'create', 'single', 'simple', 'quick'],
-    medium: ['feature', 'pagination', 'filter', 'export', 'refactor', 'optimize'],
-    large: ['system', 'complete', 'all', 'multiple', 'integration', 'architecture'],
-    huge: ['platform', 'infrastructure', 'subsystem', 'migrate', 'rebuild']
-  };
-
-  // Infrastructure indicators
-  const infraKeywords = ['bicep', 'azure', 'deploy', 'docker', 'kubernetes', 'infrastructure', 'terraform'];
-  const hasInfra = infraKeywords.some(kw => requestLower.includes(kw));
-
-  // Component indicators
-  const componentKeywords = ['component', 'page', 'screen', 'form', 'table', 'chart', 'modal'];
-  const componentMatches = componentKeywords.filter(kw => requestLower.includes(kw)).length;
-
-  // Entity indicators
-  const entityKeywords = ['user', 'order', 'product', 'customer', 'invoice', 'report'];
-  const entityMatches = entityKeywords.filter(kw => requestLower.includes(kw)).length;
-
-  // Determine scope
-  let scope = 'medium';
-  for (const [level, indicators] of Object.entries(scopeIndicators)) {
-    if (indicators.some(indicator => requestLower.includes(indicator))) {
-      scope = level;
-      break;
-    }
-  }
-
-  // Estimate based on scope
-  const estimates = {
-    trivial: { files: 1, lines: 30, components: 0 },
-    small: { files: 2, lines: 100, components: 1 },
-    medium: { files: 5, lines: 200, components: 1 },
-    large: { files: 12, lines: 800, components: 3 },
-    huge: { files: 25, lines: 2000, components: 5 }
-  };
-
-  const base = estimates[scope] || estimates.medium;
-
-  // Adjust based on entities and components mentioned
-  const files = base.files + entityMatches + componentMatches;
-  const lines = base.lines + (entityMatches * 50) + (componentMatches * 100);
-  const components = base.components + componentMatches;
-
-  return {
-    files,
-    lines,
-    components,
-    hasInfra
-  };
-}
-
-/**
- * Check if complexity matches workflow criteria
- * @param {Object} complexity - Estimated complexity
- * @param {Object} criteria - Workflow criteria
- * @returns {{matches: boolean, score: number}}
- */
-function matchComplexity(complexity, criteria) {
-  let matches = 0;
-  let total = 0;
-
-  // File count
-  if (criteria.maxFiles !== undefined) {
-    total++;
-    if (complexity.files <= criteria.maxFiles) matches++;
-  }
-  if (criteria.minFiles !== undefined) {
-    total++;
-    if (complexity.files >= criteria.minFiles) matches++;
-  }
-
-  // Line count
-  if (criteria.maxLines !== undefined) {
-    total++;
-    if (complexity.lines <= criteria.maxLines) matches++;
-  }
-  if (criteria.minLines !== undefined) {
-    total++;
-    if (complexity.lines >= criteria.minLines) matches++;
-  }
-
-  // Component count
-  if (criteria.maxComponents !== undefined) {
-    total++;
-    if (complexity.components <= criteria.maxComponents) matches++;
-  }
-  if (criteria.minComponents !== undefined) {
-    total++;
-    if (complexity.components >= criteria.minComponents) matches++;
-  }
-
-  // Infrastructure
-  if (criteria.noInfrastructure !== undefined) {
-    total++;
-    if (criteria.noInfrastructure === !complexity.hasInfra) matches++;
-  }
-  if (criteria.infrastructure !== undefined) {
-    total++;
-    if (criteria.infrastructure === complexity.hasInfra) matches++;
-  }
-
-  const score = total > 0 ? matches / total : 0.5;
-  const meetsAll = total > 0 && matches === total;
-
-  return { matches: meetsAll, score };
-}
-
-// Directories to skip during codebase scanning
-const SCAN_SKIP_DIRS = new Set([
-  'node_modules', '.git', '.morph', 'dist', 'out', '.next',
-  'obj', 'bin', '.worktrees', '.vs', '.vscode', 'coverage'
-]);
-
-/**
- * Quick codebase scan to estimate change complexity from actual files.
- * Reads only filenames (not content). Capped at 2000 files.
- *
- * @param {string} projectPath - Project root
- * @param {string[]} keywords - Keywords extracted from user request
- * @returns {{ affectedFiles: number, hasSharedInfra: boolean, hasTests: boolean, score: number }}
- */
-export function quickCodebaseScan(projectPath, keywords) {
-  if (!projectPath || projectPath === '.' || !existsSync(projectPath)) {
-    return { affectedFiles: 0, hasSharedInfra: false, hasTests: false, score: 0.5 };
-  }
-
-  const infraPatterns = ['dockerfile', 'docker-compose', '.bicep', '.tf', 'appsettings.json', 'terraform'];
-  const testPatterns = ['.test.', '.spec.', '__tests__'];
-  const keywordsLower = keywords.map(k => k.toLowerCase());
-
-  let filesExamined = 0;
-  let affectedFiles = 0;
-  let hasSharedInfra = false;
-  let hasTests = false;
-  const MAX_FILES = 2000;
-
-  function walk(dir) {
-    if (filesExamined >= MAX_FILES) return;
-    let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
-
-    for (const entry of entries) {
-      if (filesExamined >= MAX_FILES) return;
-      if (entry.isDirectory()) {
-        if (!SCAN_SKIP_DIRS.has(entry.name)) walk(join(dir, entry.name));
-        continue;
-      }
-      filesExamined++;
-      const nameLower = entry.name.toLowerCase();
-
-      if (infraPatterns.some(p => nameLower.includes(p))) hasSharedInfra = true;
-      if (testPatterns.some(p => nameLower.includes(p))) hasTests = true;
-      if (keywordsLower.some(k => k.length >= 3 && nameLower.includes(k))) affectedFiles++;
-    }
-  }
-
-  walk(projectPath);
-
-  // Score: more affected files = higher complexity
-  let score = 0.5;
-  if (affectedFiles === 0) score = 0.3;
-  else if (affectedFiles <= 3) score = 0.4;
-  else if (affectedFiles <= 8) score = 0.6;
-  else if (affectedFiles <= 15) score = 0.75;
-  else score = 0.9;
-
-  if (hasSharedInfra) score = Math.min(1, score + 0.1);
-
-  return { affectedFiles, hasSharedInfra, hasTests, score };
-}
-
-/**
- * Find completed features similar to the current description.
- * Uses Jaccard similarity on tokenized keywords.
- *
- * @param {string} userRequest - Current feature description
- * @param {string} projectPath - Project root (for loading state)
- * @returns {{ similarFeatures: Array<{name: string, workflow: string, similarity: number}>, suggestedWorkflow: string|null, score: number }}
- */
-export function findSimilarFeatures(userRequest, projectPath) {
-  const neutral = { similarFeatures: [], suggestedWorkflow: null, score: 0.5 };
-
-  let state;
-  try {
-    const statePath = join(projectPath, '.morph', 'state.json');
-    if (!existsSync(statePath)) return neutral;
-    state = JSON.parse(readFileSync(statePath, 'utf8'));
-  } catch { return neutral; }
-
-  if (!state?.features) return neutral;
-
-  const requestTokens = new Set(
-    userRequest.toLowerCase().split(/[\s\-_.,;:!?]+/).filter(t => t.length >= 3)
-  );
-  if (requestTokens.size === 0) return neutral;
-
-  const candidates = [];
-
-  for (const [name, feature] of Object.entries(state.features)) {
-    if (feature.status !== 'completed') continue;
-    if (!feature.workflow || feature.workflow === 'auto') continue;
-
-    // Build token set from feature name + matched keywords
-    const featureTokens = new Set(
-      name.toLowerCase().split(/[\s\-_.,;:!?]+/).filter(t => t.length >= 3)
-    );
-    if (feature.workflowDetection?.matchedKeywords) {
-      for (const kw of feature.workflowDetection.matchedKeywords) {
-        kw.toLowerCase().split(/[\s\-_]+/).filter(t => t.length >= 3).forEach(t => featureTokens.add(t));
-      }
-    }
-
-    // Jaccard similarity
-    const intersection = [...requestTokens].filter(t => featureTokens.has(t)).length;
-    const union = new Set([...requestTokens, ...featureTokens]).size;
-    const similarity = union > 0 ? intersection / union : 0;
-
-    if (similarity > 0.3) {
-      candidates.push({ name, workflow: feature.workflow, similarity });
-    }
-  }
-
-  if (candidates.length === 0) return neutral;
-
-  candidates.sort((a, b) => b.similarity - a.similarity);
-  const top = candidates.slice(0, 3);
-
-  // Suggest the workflow used by the most similar feature
-  const suggestedWorkflow = top[0].workflow;
-
-  // Score: higher similarity = more confidence in the suggestion
-  const score = Math.min(1, top[0].similarity + 0.2);
-
-  return { similarFeatures: top, suggestedWorkflow, score };
-}
-
-/**
- * Score based on description length and structure.
- * Short descriptions suggest simple tasks, long ones suggest complex.
- *
- * @param {string} userRequest
- * @returns {number} 0-1 score where higher = more complex
- */
-export function scoreDescriptionLength(userRequest) {
-  const len = userRequest.trim().length;
-  const sentences = userRequest.split(/[.!?]+/).filter(s => s.trim().length > 0).length;
-
-  if (len < 30) return 0.2;
-  if (len < 80) return 0.35;
-  if (len < 150) return 0.5;
-  if (len < 300 && sentences <= 3) return 0.65;
-  return 0.8;
-}
-
-/**
- * Detect workflow for a feature request
- * @param {Object} options - Detection options
- * @param {string} options.userRequest - User's feature request
- * @param {string} [options.projectPath='.'] - Project path
- * @param {string} [options.featureName] - Feature name (optional)
- * @returns {Object} Detection result
- */
-export async function detectWorkflow(options) {
-  const { userRequest, projectPath = '.', featureName } = options;
-
-  if (!userRequest || userRequest.trim().length === 0) {
-    throw new Error('userRequest is required');
-  }
-
-  // Load all workflow configs
-  const workflows = loadWorkflowConfigs(projectPath);
-
-  if (workflows.length === 0) {
-    // Fallback if no configs found
-    return {
-      workflowId: 'standard',
-      confidence: 0.5,
-      matchedKeywords: [],
-      estimatedComplexity: { files: 0, lines: 0, components: 0, hasInfra: false },
-      reasoning: 'No workflow configs found - using standard as fallback',
-      alternativeWorkflows: []
-    };
-  }
-
-  // Estimate complexity
-  const complexity = estimateComplexity(userRequest);
-
-  // New signals: codebase scan + feature history + description length
-  const codebaseScan = quickCodebaseScan(projectPath, complexity.hasInfra
-    ? [...userRequest.toLowerCase().split(/\s+/).filter(w => w.length >= 3)]
-    : userRequest.toLowerCase().split(/\s+/).filter(w => w.length >= 3)
-  );
-  const featureHistory = findSimilarFeatures(userRequest, projectPath);
-  const descriptionScore = scoreDescriptionLength(userRequest);
-
-  // Score each workflow
-  const scores = [];
-
-  for (const workflow of workflows) {
-    const keywordMatch = matchKeywords(userRequest, workflow.keywords || []);
-    const complexityMatch = matchComplexity(complexity, workflow.criteria || {});
-
-    // Enhanced weighted scoring (6 signals)
-    const weights = {
-      keywords: 0.25,
-      complexity: 0.20,
-      codebaseAnalysis: 0.20,
-      featureHistory: 0.15,
-      priority: 0.10,
-      descriptionLength: 0.10,
-    };
-
-    // Priority score (lower number = higher priority = higher score)
-    const priorityScore = workflow.priority ? (4 - workflow.priority) / 3 : 0.5;
-
-    // Codebase analysis score: align scan results with workflow expectations
-    let codebaseScore = codebaseScan.score;
-    if (workflow.criteria?.noInfrastructure && codebaseScan.hasSharedInfra) {
-      codebaseScore *= 0.5; // Penalize simple workflows when infra detected
-    }
-    if (workflow.criteria?.minFiles && codebaseScan.affectedFiles >= workflow.criteria.minFiles) {
-      codebaseScore = Math.min(1, codebaseScore + 0.2);
-    }
-
-    // Feature history score: boost if similar features used this workflow
-    let historyScore = featureHistory.score;
-    if (featureHistory.suggestedWorkflow === workflow.id) {
-      historyScore = Math.min(1, historyScore + 0.3);
-    } else if (featureHistory.suggestedWorkflow && featureHistory.suggestedWorkflow !== workflow.id) {
-      historyScore *= 0.6;
-    }
-
-    // Description length score: align with workflow complexity expectations
-    let descScore = descriptionScore;
-    if (workflow.priority === 1 && descriptionScore > 0.6) {
-      descScore *= 0.7; // Long descriptions less likely to be fast-track
-    }
-    if (workflow.priority === 3 && descriptionScore < 0.4) {
-      descScore *= 0.7; // Short descriptions less likely to be full
-    }
-
-    // Calculate total score
-    let totalScore =
-      (keywordMatch.score * weights.keywords) +
-      (complexityMatch.score * weights.complexity) +
-      (codebaseScore * weights.codebaseAnalysis) +
-      (historyScore * weights.featureHistory) +
-      (priorityScore * weights.priority) +
-      (descScore * weights.descriptionLength);
-
-    // Penalty for workflows with no keyword matches
-    if (keywordMatch.matched.length === 0) {
-      totalScore *= 0.5; // 50% penalty for no keyword match
-    }
-
-    // Boost for strong keyword matches (3+ keywords matched)
-    if (keywordMatch.matched.length >= 3) {
-      totalScore *= 1.2; // 20% boost
-    }
-
-    scores.push({
-      workflowId: workflow.id,
-      workflowName: workflow.name,
-      score: totalScore,
-      keywordMatch: keywordMatch.matched,
-      complexityMatch: complexityMatch.matches,
-      reasoning: []
-    });
-  }
-
-  // Sort by score (highest first)
-  scores.sort((a, b) => b.score - a.score);
-
-  // Get top result
-  const topResult = scores[0];
-  const confidence = topResult.score;
-
-  // Build reasoning
-  const reasoning = [];
-  if (topResult.keywordMatch.length > 0) {
-    reasoning.push(`Matched keyword${topResult.keywordMatch.length > 1 ? 's' : ''}: ${topResult.keywordMatch.join(', ')}`);
-  }
-  reasoning.push(`Estimated ${complexity.files} files, ~${complexity.lines} lines`);
-  if (complexity.hasInfra) {
-    reasoning.push('Infrastructure keywords detected');
-  }
-  if (topResult.complexityMatch) {
-    reasoning.push('Meets all complexity criteria');
-  }
-
-  // Get alternatives (next 2 workflows with score > 0.2)
-  const alternatives = scores.slice(1, 3)
-    .filter(w => w.score > 0.2)
-    .map(w => ({
-      workflowId: w.workflowId,
-      confidence: w.score,
-      reason: `${w.workflowName} (${Math.round(w.score * 100)}% match)`
-    }));
-
-  // Warnings for low confidence or ambiguous results
-  const warnings = [];
-  if (confidence < 0.4) {
-    warnings.push('Low confidence — consider specifying workflow explicitly with --workflow');
-  }
-  if (alternatives.length > 0 && alternatives[0].confidence > confidence * 0.8) {
-    warnings.push(`Close alternative: ${alternatives[0].workflowId} (${Math.round(alternatives[0].confidence * 100)}%) — verify recommendation`);
-  }
-  if (featureHistory.similarFeatures.length > 0 && featureHistory.suggestedWorkflow !== topResult.workflowId) {
-    warnings.push(`Similar features used ${featureHistory.suggestedWorkflow} workflow`);
-  }
-
-  return {
-    workflowId: topResult.workflowId,
-    confidence,
-    matchedKeywords: topResult.keywordMatch,
-    estimatedComplexity: complexity,
-    reasoning: reasoning.join(' + '),
-    alternativeWorkflows: alternatives,
-    warnings
-  };
-}
-
-/**
- * Get workflow configuration by ID
- * @param {string} workflowId - Workflow ID
- * @param {string} [projectPath='.'] - Project path
- * @returns {Object|null} Workflow config or null
- */
-export function getWorkflowConfig(workflowId, projectPath = '.') {
-  const workflows = loadWorkflowConfigs(projectPath);
-  const config = workflows.find(w => w.id === workflowId) || null;
-
-  if (config) {
-    const validPhases = getValidPhaseIds();
-    const declaredPhases = config.phases?.run || [];
-    for (const phase of declaredPhases) {
-      if (!validPhases.has(phase)) {
-        console.warn(`[workflow] Warning: workflow "${workflowId}" declares unknown phase "${phase}" — ignored`);
-      }
-    }
-  }
-
-  return config;
-}
-
-/**
- * List all available workflows
- * @param {string} [projectPath='.'] - Project path
- * @returns {Array<{id: string, name: string, description: string}>}
- */
-export function listWorkflows(projectPath = '.') {
-  const workflows = loadWorkflowConfigs(projectPath);
-  return workflows.map(w => ({
-    id: w.id,
-    name: w.name,
-    description: w.description
-  }));
-}
-
-/**
- * Check zero-touch eligibility for a feature (requires trust-manager)
- * @param {string} feature
- * @returns {Promise<boolean>}
- */
-export async function checkZeroTouchEligibility(/* feature */) {
-  // v5: trust manager removed. The autonomy contract (MORPH.md) replaces it —
-  // Claude advances autonomously between gates. Returning false keeps any
-  // legacy callers happy without granting unintended privileges.
-  return false;
-}