@polymorphism-tech/morph-spec 4.8.19 → 4.10.0

package/src/lib/agents/micro-agent-factory.js

@@ -1,161 +0,0 @@
-/**
- * Micro Agent Factory — Create ultra-specialized agents
- *
- * Micro-agents are stripped-down versions of base agents with:
- * - Only the standards they need (1-3 files max)
- * - A single focused mission
- * - Minimal context overhead (~2-5K tokens vs 20-50K for full agent)
- *
- * Saved to: .morph/micro-agents/{name}.json
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
-import { join } from 'path';
-
-const MICRO_AGENTS_DIR = join(process.cwd(), '.morph/micro-agents');
-const AGENTS_CONFIG = join(process.cwd(), '.morph/framework/agents.json');
-
-// ============================================================================
-// Agent Creation
-// ============================================================================
-
-/**
- * Create a micro-agent from a base agent with a standards subset
- * @param {Object} opts
- * @param {string} opts.name - Micro-agent name (e.g., 'jwt-validator')
- * @param {string} opts.baseAgent - Base agent ID (e.g., 'security-expert')
- * @param {string[]} opts.standards - Relevant standards file paths (1-3 files)
- * @param {string} opts.mission - Focused mission description
- * @param {string[]} [opts.tools] - Tools this micro-agent uses (default: minimal set)
- * @param {Object} [opts.constraints] - Additional constraints
- * @returns {Object} Micro-agent config object
- */
-export function createMicroAgent({ name, baseAgent, standards, mission, tools = null, constraints = {} }) {
-  if (!name || !baseAgent || !mission) {
-    throw new Error('name, baseAgent, and mission are required');
-  }
-
-  if (standards && standards.length > 5) {
-    throw new Error('Micro-agents should load at most 5 standards files (ideally 1-3)');
-  }
-
-  const baseAgentConfig = loadBaseAgent(baseAgent);
-
-  const microAgent = {
-    id: name,
-    type: 'micro-agent',
-    baseAgent,
-    createdAt: new Date().toISOString(),
-    mission,
-    tier: (baseAgentConfig?.tier || 3) + 1, // micro-agents are tier+1 (more specialized)
-    domain: baseAgentConfig?.domain || 'general',
-    standards: standards || [],
-    tools: tools || ['Read', 'Write', 'Edit'],
-    constraints: {
-      maxStandards: 3,
-      maxFiles: 10,
-      focusOnly: mission,
-      ...constraints
-    },
-    contextEstimate: {
-      standards: (standards || []).length * 2000,
-      overhead: 1500,
-      total: ((standards || []).length * 2000) + 1500
-    },
-    prompt: generateMicroAgentPrompt({ name, baseAgent, standards, mission, constraints, baseAgentConfig })
-  };
-
-  return microAgent;
-}
-
-/**
- * Save a micro-agent to disk
- * @param {Object} microAgent - Micro-agent config (from createMicroAgent)
- * @returns {string} Path to saved file
- */
-export function saveMicroAgent(microAgent) {
-  if (!existsSync(MICRO_AGENTS_DIR)) {
-    mkdirSync(MICRO_AGENTS_DIR, { recursive: true });
-  }
-
-  const filePath = join(MICRO_AGENTS_DIR, `${microAgent.id}.json`);
-  writeFileSync(filePath, JSON.stringify(microAgent, null, 2), 'utf8');
-  return filePath;
-}
-
-/**
- * List all micro-agents
- * @returns {Array} Array of micro-agent summaries
- */
-export function listMicroAgents() {
-  if (!existsSync(MICRO_AGENTS_DIR)) return [];
-
-  return readdirSync(MICRO_AGENTS_DIR)
-    .filter(f => f.endsWith('.json'))
-    .map(f => {
-      try {
-        const agent = JSON.parse(readFileSync(join(MICRO_AGENTS_DIR, f), 'utf8'));
-        return {
-          id: agent.id,
-          baseAgent: agent.baseAgent,
-          mission: agent.mission,
-          standards: agent.standards?.length || 0,
-          contextEstimate: agent.contextEstimate?.total || 0,
-          createdAt: agent.createdAt
-        };
-      } catch {
-        return null;
-      }
-    })
-    .filter(Boolean);
-}
-
-/**
- * Get a specific micro-agent
- * @param {string} name - Micro-agent name
- * @returns {Object|null} Micro-agent config or null
- */
-export function getMicroAgent(name) {
-  const filePath = join(MICRO_AGENTS_DIR, `${name}.json`);
-  if (!existsSync(filePath)) return null;
-  try {
-    return JSON.parse(readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-// ============================================================================
-// Helpers
-// ============================================================================
-
-function loadBaseAgent(agentId) {
-  if (!existsSync(AGENTS_CONFIG)) return null;
-  try {
-    const config = JSON.parse(readFileSync(AGENTS_CONFIG, 'utf8'));
-    return config.agents?.find(a => a.id === agentId) || null;
-  } catch {
-    return null;
-  }
-}
-
-function generateMicroAgentPrompt({ name, baseAgent, standards, mission, constraints, baseAgentConfig }) {
-  const standardsList = standards?.map(s => `- framework/standards/${s}`).join('\n') || '(none)';
-
-  return `You are a MICRO-AGENT: ${name}
-Base: ${baseAgent} (${baseAgentConfig?.description || 'specialist'})
-
-MISSION (single focus):
-${mission}
-
-STANDARDS TO LOAD (${standards?.length || 0} files):
-${standardsList}
-
-CONSTRAINTS:
-- Focus ONLY on your mission above
-- Do NOT load additional standards or context
-- Maximum ${constraints.maxFiles || 10} files to read/write
-- Report completion when done — do NOT start new tasks
-
-This is a minimal-context agent. Stay focused.`;
-}

package/src/lib/analysis/complexity-analyzer.js

@@ -1,441 +0,0 @@
-/**
- * MORPH-SPEC Complexity Analyzer Library
- *
- * Analyzes user requests and classifies them into workflows:
- * - fast-track: Trivial changes (bug fixes, small adjustments)
- * - standard: Medium features (simple additions, improvements)
- * - full-morph: Complex features (new subsystems, architecture)
- *
- * Used both by CLI commands and internal automation.
- */
-
-// ============================================================================
-// COMPLEXITY THRESHOLDS
-// ============================================================================
-
-export const COMPLEXITY_THRESHOLDS = {
-  'fast-track': {
-    maxFiles: 3,
-    maxLines: 50,
-    maxComponents: 0,
-    requiresInfrastructure: false,
-    requiresArchitecturalDecisions: false,
-    description: 'Bug fixes, small adjustments, edge cases, hotfixes'
-  },
-  'standard': {
-    maxFiles: 10,
-    maxLines: 500,
-    maxComponents: 2,
-    requiresInfrastructure: false,
-    requiresArchitecturalDecisions: false, // Only tactical decisions
-    description: 'Simple features, refactorings, incremental improvements'
-  },
-  'full-morph': {
-    maxFiles: Infinity,
-    maxLines: Infinity,
-    maxComponents: Infinity,
-    requiresInfrastructure: true, // Can have infrastructure
-    requiresArchitecturalDecisions: true, // Strategic decisions
-    description: 'Complex features, new subsystems, architectural changes'
-  }
-};
-
-// ============================================================================
-// KEYWORD DETECTION
-// ============================================================================
-
-/**
- * Keywords that indicate different complexity levels
- */
-const COMPLEXITY_KEYWORDS = {
-  trivial: [
-    'bug', 'fix', 'corrigir', 'ajustar', 'typo', 'correção',
-    'edge case', 'hotfix', 'urgente', 'rápido', 'quick',
-    'cor', 'color', 'texto', 'text', 'label', 'validação',
-    'mensagem', 'message', 'css', 'style', 'espaçamento'
-  ],
-
-  infrastructure: [
-    'azure', 'bicep', 'deploy', 'infra', 'infrastructure',
-    'container', 'kubernetes', 'k8s', 'database', 'sql',
-    'storage', 'queue', 'service bus', 'redis', 'cosmos'
-  ],
-
-  architectural: [
-    'sistema', 'system', 'arquitetura', 'architecture',
-    'pattern', 'cqrs', 'event sourcing', 'microservice',
-    'subsistema', 'subsystem', 'integração', 'integration',
-    'autenticação', 'authentication', 'autorização', 'authorization'
-  ],
-
-  newComponents: [
-    'novo', 'new', 'criar', 'create', 'adicionar', 'add',
-    'implementar', 'implement', 'desenvolver', 'develop',
-    'componente', 'component', 'serviço', 'service',
-    'tela', 'screen', 'página', 'page', 'formulário', 'form'
-  ],
-
-  // UI Refresh workflow - visual only changes
-  uiRefresh: [
-    'redesign', 'redesenhar', 'bonito', 'bonitas', 'visual',
-    'estetica', 'aesthetics', 'modernizar', 'modernize',
-    'melhorar visual', 'mais bonito', 'prettier', 'beautiful',
-    'refresh', 'design system'
-  ],
-
-  // Design Implementation workflow - prototype to code
-  designImplementation: [
-    'prototipo', 'prototype', 'figma', 'html para',
-    'converter design', 'replicar', 'from design',
-    'based on mockup', 'mockup', 'wireframe', 'implementar tela'
-  ]
-};
-
-/**
- * Hidden complexity indicators for Blazor Server
- * These keyword combinations indicate complexity that isn't obvious at first glance.
- * When detected together, they should force full-morph workflow.
- *
- * See: framework/standards/backend/database/ef-core.md, frontend/blazor/state.md
- */
-const HIDDEN_COMPLEXITY_INDICATORS = {
-  // Session + Blazor = complex circuit/state management
-  session: {
-    primary: ['session', 'sessão', 'estado', 'state'],
-    context: ['blazor', 'persist', 'persistir', 'circuit', 'scoped']
-  },
-  // Background operations = DbContext concurrency issues
-  background: {
-    primary: ['task.run', 'background', 'segundo plano', 'job', 'hangfire'],
-    context: ['concurrent', 'concorrente', 'async', 'parallel', 'paralelo', 'dbcontext', 'ef core']
-  },
-  // Navigation = potential state loss
-  navigation: {
-    primary: ['redirect', 'navigate', 'navegar', 'navegação'],
-    context: ['circuit', 'signalr', 'forceload', 'refresh', 'reload']
-  }
-};
-
-// ============================================================================
-// ANALYSIS FUNCTIONS
-// ============================================================================
-
-/**
- * Detect keywords in user input
- * @param {string} userInput - User request
- * @param {Array<string>} keywords - Keywords to search for
- * @returns {number} Count of keyword matches
- */
-function detectKeywords(userInput, keywords) {
-  const lowerInput = userInput.toLowerCase();
-  return keywords.filter(keyword => lowerInput.includes(keyword)).length;
-}
-
-/**
- * Estimate code impact from user input
- * @param {string} userInput - User request
- * @returns {Object} Estimated impact
- */
-export function estimateCodeImpact(userInput) {
-  const lowerInput = userInput.toLowerCase();
-
-  // Trivial indicators
-  const trivialCount = detectKeywords(lowerInput, COMPLEXITY_KEYWORDS.trivial);
-  if (trivialCount > 0) {
-    return {
-      estimatedFiles: 1,
-      estimatedLines: 10,
-      estimatedComponents: 0,
-      confidence: 'high'
-    };
-  }
-
-  // Count indicators of new components
-  const newComponentCount = detectKeywords(lowerInput, COMPLEXITY_KEYWORDS.newComponents);
-
-  // Multiple components/features mentioned (separated by "e", "and", or commas)
-  const separators = [' e ', ' and ', ','];
-  const hasSeparator = separators.some(sep => lowerInput.includes(sep));
-
-  if (hasSeparator) {
-    // Split by any separator
-    let parts = [lowerInput];
-    for (const sep of separators) {
-      parts = parts.flatMap(part => part.split(sep));
-    }
-    parts = parts.filter(p => p.trim().length > 0);
-
-    // If we found multiple parts, estimate high complexity
-    if (parts.length > 1) {
-      return {
-        estimatedFiles: Math.min(parts.length * 3, 15),
-        estimatedLines: Math.min(parts.length * 200, 1000),
-        estimatedComponents: Math.min(parts.length, 5),
-        confidence: 'medium'
-      };
-    }
-  }
-
-  // New component indicators
-  if (newComponentCount > 0) {
-    return {
-      estimatedFiles: 5,
-      estimatedLines: 200,
-      estimatedComponents: 1,
-      confidence: 'medium'
-    };
-  }
-
-  // Default to standard complexity
-  return {
-    estimatedFiles: 5,
-    estimatedLines: 150,
-    estimatedComponents: 1,
-    confidence: 'low'
-  };
-}
-
-/**
- * Detect if request involves infrastructure
- * @param {string} userInput - User request
- * @returns {boolean} True if infrastructure is involved
- */
-export function detectInfrastructure(userInput) {
-  const infraCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.infrastructure);
-  return infraCount > 0;
-}
-
-/**
- * Detect if request involves architectural decisions
- * @param {string} userInput - User request
- * @returns {boolean} True if architectural decisions are involved
- */
-export function detectArchitecturalDecisions(userInput) {
-  const archCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.architectural);
-  return archCount > 0;
-}
-
-/**
- * Detect if request is a UI refresh (visual redesign only)
- * @param {string} userInput - User request
- * @returns {boolean} True if UI refresh is detected
- */
-export function detectUiRefresh(userInput) {
-  const refreshCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.uiRefresh);
-  // Need at least one refresh keyword AND no infrastructure/architectural keywords
-  const hasInfra = detectKeywords(userInput, COMPLEXITY_KEYWORDS.infrastructure) > 0;
-  const hasArch = detectKeywords(userInput, COMPLEXITY_KEYWORDS.architectural) > 0;
-  return refreshCount > 0 && !hasInfra && !hasArch;
-}
-
-/**
- * Detect if request is a design implementation (prototype to code)
- * @param {string} userInput - User request
- * @returns {boolean} True if design implementation is detected
- */
-export function detectDesignImplementation(userInput) {
-  const designCount = detectKeywords(userInput, COMPLEXITY_KEYWORDS.designImplementation);
-  return designCount > 0;
-}
-
-/**
- * Detect hidden complexity in Blazor Server requests
- * These are keyword combinations that indicate non-obvious complexity.
- * @param {string} userInput - User request
- * @returns {Object} Detection result with matched indicators
- */
-export function detectHiddenComplexity(userInput) {
-  const lowerInput = userInput.toLowerCase();
-  const matchedIndicators = [];
-
-  for (const [indicatorName, indicator] of Object.entries(HIDDEN_COMPLEXITY_INDICATORS)) {
-    const hasPrimary = indicator.primary.some(keyword => lowerInput.includes(keyword));
-    const hasContext = indicator.context.some(keyword => lowerInput.includes(keyword));
-
-    if (hasPrimary && hasContext) {
-      matchedIndicators.push({
-        name: indicatorName,
-        reason: `Detected ${indicatorName} complexity: primary keywords + context keywords found`
-      });
-    }
-  }
-
-  return {
-    hasHiddenComplexity: matchedIndicators.length > 0,
-    indicators: matchedIndicators
-  };
-}
-
-/**
- * Classify workflow based on analysis
- * @param {Object} impact - Code impact estimation
- * @param {boolean} hasInfrastructure - Has infrastructure
- * @param {boolean} hasArchitecturalDecisions - Has architectural decisions
- * @returns {string} Workflow type: "fast-track" | "standard" | "full-morph"
- */
-export function classifyWorkflow(impact, hasInfrastructure, hasArchitecturalDecisions) {
-  const { estimatedFiles, estimatedLines, estimatedComponents } = impact;
-
-  // Full MORPH: Infrastructure or architectural decisions
-  if (hasInfrastructure || hasArchitecturalDecisions) {
-    return 'full-morph';
-  }
-
-  // Full MORPH: Large code impact
-  if (estimatedFiles > COMPLEXITY_THRESHOLDS.standard.maxFiles ||
-      estimatedLines > COMPLEXITY_THRESHOLDS.standard.maxLines ||
-      estimatedComponents > COMPLEXITY_THRESHOLDS.standard.maxComponents) {
-    return 'full-morph';
-  }
-
-  // Fast Track: Trivial changes
-  if (estimatedFiles <= COMPLEXITY_THRESHOLDS['fast-track'].maxFiles &&
-      estimatedLines <= COMPLEXITY_THRESHOLDS['fast-track'].maxLines &&
-      estimatedComponents <= COMPLEXITY_THRESHOLDS['fast-track'].maxComponents) {
-    return 'fast-track';
-  }
-
-  // Default: Standard workflow
-  return 'standard';
-}
-
-/**
- * Analyze request complexity - Main entry point
- * @param {string} userInput - User request
- * @param {Object} options - Options
- * @param {string} options.forceWorkflow - Force specific workflow
- * @returns {Object} Complete analysis
- */
-export function analyzeRequestComplexity(userInput, options = {}) {
-  // Check for forced workflow
-  if (options.forceWorkflow) {
-    return {
-      workflow: options.forceWorkflow,
-      forced: true,
-      reason: 'Manually overridden by user'
-    };
-  }
-
-  // Check for special workflows first (UI Refresh, Design Implementation)
-  const isUiRefresh = detectUiRefresh(userInput);
-  const isDesignImplementation = detectDesignImplementation(userInput);
-
-  if (isUiRefresh) {
-    return {
-      workflow: 'ui-refresh',
-      forced: false,
-      impact: { estimatedFiles: 5, estimatedLines: 200, estimatedComponents: 0 },
-      hasInfrastructure: false,
-      hasArchitecturalDecisions: false,
-      hasHiddenComplexity: false,
-      hiddenComplexityIndicators: [],
-      confidence: 'high',
-      reason: 'UI refresh detected: visual-only changes, no infrastructure or architecture',
-      thresholds: COMPLEXITY_THRESHOLDS.standard // Uses standard thresholds
-    };
-  }
-
-  if (isDesignImplementation) {
-    return {
-      workflow: 'design-implementation',
-      forced: false,
-      impact: { estimatedFiles: 8, estimatedLines: 400, estimatedComponents: 2 },
-      hasInfrastructure: false,
-      hasArchitecturalDecisions: false,
-      hasHiddenComplexity: false,
-      hiddenComplexityIndicators: [],
-      confidence: 'high',
-      reason: 'Design implementation detected: prototype to code conversion',
-      thresholds: COMPLEXITY_THRESHOLDS.standard // Uses standard thresholds
-    };
-  }
-
-  // Analyze request
-  const impact = estimateCodeImpact(userInput);
-  const hasInfrastructure = detectInfrastructure(userInput);
-  const hasArchitecturalDecisions = detectArchitecturalDecisions(userInput);
-  const hiddenComplexity = detectHiddenComplexity(userInput);
-
-  // Hidden complexity forces full-morph (Blazor Server specific concerns)
-  let workflow;
-  if (hiddenComplexity.hasHiddenComplexity) {
-    workflow = 'full-morph';
-  } else {
-    workflow = classifyWorkflow(impact, hasInfrastructure, hasArchitecturalDecisions);
-  }
-
-  // Build reason
-  let reason = `Estimated ${impact.estimatedFiles} files, ${impact.estimatedLines} lines, ${impact.estimatedComponents} components`;
-  if (hasInfrastructure) reason += ', requires infrastructure';
-  if (hasArchitecturalDecisions) reason += ', requires architectural decisions';
-  if (hiddenComplexity.hasHiddenComplexity) {
-    reason += `, hidden complexity detected: ${hiddenComplexity.indicators.map(i => i.name).join(', ')}`;
-  }
-
-  return {
-    workflow,
-    forced: false,
-    impact,
-    hasInfrastructure,
-    hasArchitecturalDecisions,
-    hasHiddenComplexity: hiddenComplexity.hasHiddenComplexity,
-    hiddenComplexityIndicators: hiddenComplexity.indicators,
-    confidence: impact.confidence,
-    reason,
-    thresholds: COMPLEXITY_THRESHOLDS[workflow]
-  };
-}
-
-/**
- * Get workflow phases
- * @param {string} workflow - Workflow type
- * @returns {Array<string>} List of phases to execute
- */
-export function getWorkflowPhases(workflow) {
-  switch (workflow) {
-    case 'fast-track':
-      return ['quick-analysis', 'implement'];
-
-    case 'standard':
-      return ['proposal', 'design', 'tasks', 'implement'];
-
-    case 'full-morph':
-      return ['context', 'proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
-
-    case 'ui-refresh':
-      return ['visual-analysis', 'design-system', 'implement'];
-
-    case 'design-implementation':
-      return ['prototype-analysis', 'tasks', 'implement'];
-
-    default:
-      return ['context', 'proposal', 'setup', 'uiux', 'design', 'clarify', 'tasks', 'implement', 'sync'];
-  }
-}
-
-/**
- * Get workflow description
- * @param {string} workflow - Workflow type
- * @returns {string} Human-readable description
- */
-export function getWorkflowDescription(workflow) {
-  switch (workflow) {
-    case 'fast-track':
-      return 'Fast Track: Quick fixes without formal spec (1 pause, no outputs)';
-
-    case 'standard':
-      return 'Standard: Medium complexity with simplified workflow (2-3 pauses, minimal outputs)';
-
-    case 'full-morph':
-      return 'Full MORPH: Complete 8-phase workflow with all outputs';
-
-    case 'ui-refresh':
-      return 'UI Refresh: Visual redesign only (3 phases: Visual Analysis → Design System → Implement)';
-
-    case 'design-implementation':
-      return 'Design Implementation: Prototype to code conversion (3 phases: Prototype Analysis → Tasks → Implement)';
-
-    default:
-      return 'Unknown workflow';
-  }
-}

package/src/lib/analysis/index.js

@@ -1,7 +0,0 @@
-/**
- * Analysis Utilities
- *
- * Tools for analyzing code complexity, feature scope, and project metrics.
- */
-
-export * from './complexity-analyzer.js';