@polymorphism-tech/morph-spec 4.9.0 → 4.10.1

package/src/lib/orchestration/team-orchestrator.js

@@ -1,404 +0,0 @@
-/**
- * @fileoverview Hierarchical Agent Teams Orchestrator
- *
- * Builds Agent Teams using flattened 2-tier hierarchy:
- * - Lead: standards-architect (in delegate mode, quality gate)
- * - Teammates: Tier-2 domain leaders (each with specialists in their spawn prompt)
- *
- * NOTE: Agent Teams does NOT support nested teams (a teammate cannot spawn
- * teammates). Therefore Tier-3 specialists are described in domain leader
- * spawn prompts, not as separate teammates.
- *
- * @module team-orchestrator
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * Load agents.json with hierarchical structure
- * @param {string} projectPath - Root path of the project
- * @returns {Promise<Object>} Parsed agents configuration
- */
-async function loadAgentsConfig(projectPath) {
-  const agentsPath = path.join(projectPath, '.morph/framework/agents.json');
-  const content = await fs.readFile(agentsPath, 'utf8');
-  return JSON.parse(content);
-}
-
-/**
- * Detect whether Agent Teams, subagents, or a single session should be used.
- *
- * Returns one of three modes:
- * - 'agent-teams': complexity=critical OR (multiDomain AND estimatedFiles>=15)
- * - 'subagents': shouldDispatch=true but below agent-teams threshold
- * - 'single': trivial/low complexity or no parallelization benefit
- *
- * @param {Object} options
- * @param {string[]} options.activeAgents - Agent IDs detected for feature
- * @param {string} options.complexity - Complexity level (trivial|low|medium|high|critical)
- * @param {number} options.estimatedFiles - Estimated files to modify
- * @param {boolean} options.multiDomain - Does feature span multiple domains?
- * @returns {{ mode: 'single'|'subagents'|'agent-teams', reason: string }}
- */
-export function shouldSpawnAgentTeam(options) {
-  const { activeAgents = [], complexity, estimatedFiles = 0, multiDomain = false } = options;
-
-  // Never parallelize for trivial/low complexity
-  if (complexity === 'trivial' || complexity === 'low') {
-    return {
-      mode: 'single',
-      reason: 'Complexity too low — single session sufficient',
-    };
-  }
-
-  // Agent Teams for critical complexity (max parallelization needed)
-  if (complexity === 'critical') {
-    return {
-      mode: 'agent-teams',
-      reason: 'Critical complexity — Agent Teams with plan approval essential',
-    };
-  }
-
-  // Agent Teams for large multi-domain features (backend + frontend need contract coordination)
-  if (multiDomain && estimatedFiles >= 15) {
-    return {
-      mode: 'agent-teams',
-      reason: `Multi-domain feature with ${estimatedFiles}+ files — Agent Teams for contract coordination`,
-    };
-  }
-
-  // Subagents for multi-domain below agent-teams threshold
-  if (multiDomain) {
-    return {
-      mode: 'subagents',
-      reason: 'Multi-domain feature — parallel subagents recommended',
-    };
-  }
-
-  // Subagents for high file count
-  if (estimatedFiles >= 15) {
-    return {
-      mode: 'subagents',
-      reason: `High file count (${estimatedFiles}) — parallel subagents recommended`,
-    };
-  }
-
-  // Subagents when 5+ specialists are active
-  if (activeAgents.length >= 5) {
-    return {
-      mode: 'subagents',
-      reason: `${activeAgents.length} specialists active — subagents beneficial`,
-    };
-  }
-
-  // Default: single session for medium complexity
-  return {
-    mode: 'single',
-    reason: 'Medium complexity — single session with subagents OK',
-  };
-}
-
-/**
- * Build hierarchical team structure from active agents.
- * Flattened to 2 tiers for Agent Teams compatibility:
- * - Lead: standards-architect
- * - Teammates: Tier-2 domain leaders (specialists are in their spawn prompts)
- *
- * @param {string[]} activeAgentIds - Agent IDs to include in team
- * @param {Object} agentsConfig - Loaded agents.json
- * @returns {Object} Team structure with lead, domain leaders, specialists, validators
- */
-export function buildTeamHierarchy(activeAgentIds, agentsConfig) {
-  const agents = agentsConfig.agents;
-  const activeAgents = activeAgentIds
-    .filter(id => !id.startsWith('_comment') && agents[id])
-    .map(id => ({ id, ...agents[id] }));
-
-  // Tier 1: Orchestrator (Team Lead)
-  const orchestrators = activeAgents.filter(a => a.tier === 1 && a.role === 'orchestrator');
-  const teamLead = orchestrators.find(a => a.id === 'standards-architect') || orchestrators[0];
-
-  // Tier 2: Domain Leaders (direct teammates in Agent Teams)
-  const domainLeaders = activeAgents.filter(a => a.tier === 2 && a.role === 'domain-leader');
-
-  // Tier 3: Specialists (grouped under domain leaders, NOT separate teammates)
-  const specialists = activeAgents.filter(a => a.tier === 3 && a.role === 'specialist');
-
-  // Tier 4: Validators (run in hooks, NOT teammates)
-  const validators = activeAgents.filter(a => a.tier === 4 && a.role === 'validator');
-
-  // Group specialists under their Domain Leaders for spawn prompt inclusion
-  const squads = {};
-  domainLeaders.forEach(leader => {
-    const squadMembers = specialists.filter(specialist => {
-      return specialist.relationships?.reports_to === leader.id;
-    });
-
-    squads[leader.id] = {
-      leader,
-      members: squadMembers,
-    };
-  });
-
-  return {
-    teamLead,
-    squads,
-    validators, // Run as hooks, not teammates
-    // Teammates = lead + domain leaders only (not tier-3 specialists)
-    totalTeammates: 1 + domainLeaders.length,
-  };
-}
-
-/**
- * Generate natural-language Agent Team creation prompt.
- *
- * Returns a string ready to be sent to Claude as instructions to create
- * an agent team. Domain leaders are teammates; their tier-3 specialists
- * are described within each leader's spawn context.
- *
- * @param {Object} teamHierarchy - Output from buildTeamHierarchy
- * @param {string} featureName - Feature name
- * @param {string} phase - Current MORPH phase
- * @returns {string} Natural language team creation instructions
- */
-export function generateAgentTeamPrompt(teamHierarchy, featureName, phase) {
-  const { teamLead, squads } = teamHierarchy;
-  const squadEntries = Object.entries(squads);
-
-  if (squadEntries.length === 0) {
-    return `No multi-domain squad found for feature '${featureName}'. Use single session or subagents instead.`;
-  }
-
-  const teammateCount = squadEntries.length + 1; // domain leaders + quality lead
-  const lines = [
-    `Create an agent team to implement feature '${featureName}' with ${teammateCount} teammates:`,
-    '',
-  ];
-
-  for (const [leaderId, squad] of squadEntries) {
-    const leader = squad.leader;
-    const domain = leader.domains?.[0] || leaderId;
-    const specialistList = squad.members.length > 0
-      ? squad.members.map(m => m.title || m.id).join(', ')
-      : 'none';
-
-    lines.push(`- ${leader.title || leaderId} teammate (${leaderId}): Implement ${domain} tasks.`);
-    lines.push(`  Context: spec.md, contracts.cs, standards/${domain}/`);
-    if (squad.members.length > 0) {
-      lines.push(`  Specialists to coordinate (in your spawn prompt): ${specialistList}`);
-    }
-    lines.push(`  Restriction: Modify ONLY files in the ${domain} domain.`);
-    lines.push('');
-  }
-
-  const leadId = teamLead?.id || 'standards-architect';
-  lines.push(`- Quality teammate (${leadId}): Review each teammate's output and run validate-feature.`);
-  lines.push('  Require plan approval before implementing. Only approve plans that match contracts.cs.');
-  lines.push('');
-  lines.push('Coordination protocol:');
-  lines.push('  - Backend must signal when contracts.cs/DTOs are stable before frontend implements API calls.');
-  lines.push('  - If teammates need to share interfaces, send a direct message to coordinate first.');
-  lines.push('  - Escalate contract conflicts to the quality teammate to resolve.');
-
-  return lines.join('\n');
-}
-
-/**
- * Generate team instructions as natural language (renamed from generateSpawnCommand).
- * Use this for Agent Teams mode.
- *
- * @param {Object} teamHierarchy - Output from buildTeamHierarchy
- * @param {string} featureName - Feature name
- * @param {string} phase - Current MORPH phase
- * @returns {string} Natural language team creation instructions
- */
-export function generateTeamInstructions(teamHierarchy, featureName, phase) {
-  return generateAgentTeamPrompt(teamHierarchy, featureName, phase);
-}
-
-/**
- * Generate teammate spawn configs for subagent dispatch (unchanged from v1).
- * Use this for 'subagents' mode (not Agent Teams).
- *
- * @param {Object} teamHierarchy - Output from buildTeamHierarchy
- * @param {string} featureName - Feature name
- * @param {string} phase - Current MORPH phase
- * @returns {Object[]} Array of teammate configs for Task tool subagents
- */
-export function generateTeammateConfigs(teamHierarchy, featureName, phase) {
-  const teammates = [];
-  const { teamLead, squads } = teamHierarchy;
-
-  // Add Team Lead (standards-architect in delegate mode)
-  if (teamLead && teamLead.teammate) {
-    teammates.push({
-      id: teamLead.id,
-      tier: teamLead.tier,
-      role: teamLead.teammate.role,
-      icon: teamLead.teammate.icon,
-      spawnPrompt: `${teamLead.teammate.spawn_prompt}
-
-Feature: ${featureName}
-Phase: ${phase}
-
-Your Domain Leaders:
-${Object.values(squads).map(s => `- ${s.leader.title} (${s.leader.id})`).join('\n')}
-
-DO NOT implement code yourself. Coordinate Domain Leaders, resolve conflicts, synthesize results.`
-    });
-  }
-
-  // Add Domain Leaders + their squad members
-  Object.entries(squads).forEach(([leaderId, squad]) => {
-    const leader = squad.leader;
-
-    if (leader.teammate) {
-      teammates.push({
-        id: leader.id,
-        tier: leader.tier,
-        role: leader.teammate.role,
-        icon: leader.teammate.icon,
-        spawnPrompt: `${leader.teammate.spawn_prompt}
-
-Feature: ${featureName}
-Phase: ${phase}
-
-Your Squad (${squad.members.length} specialists):
-${squad.members.map(m => `- ${m.title} (${m.id})`).join('\n')}
-
-Coordinate your specialists. Escalate conflicts to ${leader.relationships.escalates_to}.`
-      });
-    }
-
-    squad.members.forEach(specialist => {
-      if (specialist.teammate) {
-        teammates.push({
-          id: specialist.id,
-          tier: specialist.tier,
-          role: specialist.teammate.role,
-          icon: specialist.teammate.icon,
-          spawnPrompt: `${specialist.teammate.spawn_prompt}
-
-Feature: ${featureName}
-Phase: ${phase}
-
-Reports to: ${specialist.relationships.reports_to}
-Escalate to: ${specialist.relationships.escalates_to}
-
-${specialist.relationships.collaborates_with ?
-  `Collaborate with: ${specialist.relationships.collaborates_with.join(', ')}` : ''}`
-        });
-      }
-    });
-  });
-
-  return teammates;
-}
-
-/**
- * @deprecated Use generateTeamInstructions() instead.
- * Kept for backward compatibility — will be removed in a future version.
- */
-export function generateSpawnCommand(teammates, _displayMode = 'auto') {
-  // Returns legacy JSON format for any code still calling the old signature.
-  // New code should call generateTeamInstructions(teamHierarchy, featureName, phase).
-  return JSON.stringify({
-    _deprecated: true,
-    _message: 'Use generateTeamInstructions() for Agent Teams mode.',
-    teammates: teammates.map(t => ({ id: t.id, role: t.role })),
-  }, null, 2);
-}
-
-/**
- * Main orchestration function — decides if/when to use Agent Teams vs subagents.
- *
- * @param {Object} options
- * @param {string} options.projectPath - Project root path
- * @param {string} options.featureName - Feature name
- * @param {string} options.phase - MORPH phase
- * @param {string[]} options.activeAgents - Active agent IDs
- * @param {string} options.complexity - Complexity level
- * @param {number} options.estimatedFiles - Estimated file count
- * @param {boolean} options.multiDomain - Multi-domain feature?
- * @returns {Promise<Object>} Team orchestration result
- */
-export async function orchestrateTeam(options) {
-  const {
-    projectPath,
-    featureName,
-    phase,
-    activeAgents = [],
-    complexity,
-    estimatedFiles = 0,
-    multiDomain = false,
-  } = options;
-
-  // Step 1: Decide mode
-  const modeDecision = shouldSpawnAgentTeam({
-    activeAgents,
-    complexity,
-    estimatedFiles,
-    multiDomain,
-  });
-
-  if (modeDecision.mode === 'single') {
-    return {
-      mode: 'single',
-      reason: modeDecision.reason,
-      recommendation: 'Use single session — sequential implementation',
-    };
-  }
-
-  // Step 2: Load agents config and build hierarchy
-  const agentsConfig = await loadAgentsConfig(projectPath);
-  const teamHierarchy = buildTeamHierarchy(activeAgents, agentsConfig);
-
-  if (modeDecision.mode === 'agent-teams') {
-    // Step 3a: Generate natural language Agent Teams instructions
-    const teamInstructions = generateTeamInstructions(teamHierarchy, featureName, phase);
-
-    return {
-      mode: 'agent-teams',
-      reason: modeDecision.reason,
-      teamHierarchy: {
-        teamLead: teamHierarchy.teamLead?.id,
-        squads: Object.keys(teamHierarchy.squads),
-        totalTeammates: teamHierarchy.totalTeammates,
-        validators: teamHierarchy.validators.map(v => v.id),
-      },
-      teamInstructions,
-      recommendation: `Create Agent Team with ${teamHierarchy.totalTeammates} teammates (lead + domain leaders). Require plan approval before implementation.`,
-    };
-  }
-
-  // mode === 'subagents'
-  // Step 3b: Generate Task tool subagent configs
-  const teammates = generateTeammateConfigs(teamHierarchy, featureName, phase);
-
-  return {
-    mode: 'subagents',
-    reason: modeDecision.reason,
-    teamHierarchy: {
-      teamLead: teamHierarchy.teamLead?.id,
-      squads: Object.keys(teamHierarchy.squads),
-      totalTeammates: teamHierarchy.totalTeammates,
-      validators: teamHierarchy.validators.map(v => v.id),
-    },
-    teammates,
-    recommendation: `Dispatch ${teammates.length} Task subagents in parallel`,
-  };
-}
-
-/**
- * Get agent squad assignments (for informational purposes)
- * @param {Object} agentsConfig - Loaded agents.json
- * @returns {Object} Squad information
- */
-export function getSquadInfo(agentsConfig) {
-  return agentsConfig.squads || {};
-}

package/src/sanitizer/context-sanitizer.js

@@ -1,221 +0,0 @@
-/**
- * @fileoverview ContextSanitizer - Sanitizes project context before sending to LLM
- * @module morph-spec/sanitizer/context-sanitizer
- */
-
-import { minimatch } from 'minimatch';
-import {
-  WHITELIST_FILES,
-  BLACKLIST_DIRECTORIES,
-  BLACKLIST_FILES,
-  SECRET_PATTERNS,
-  MAX_FILE_SIZE,
-  MAX_SUMMARY_LENGTH
-} from './patterns.js';
-
-/**
- * @typedef {import('../types/index.js').ProjectContext} ProjectContext
- * @typedef {import('../types/index.js').SanitizedContext} SanitizedContext
- */
-
-/**
- * ContextSanitizer - Removes secrets and sensitive data before LLM analysis
- * Implements hybrid whitelist/blacklist approach per ADR-004
- * @class
- */
-export class ContextSanitizer {
-  /**
-   * Sanitize project context (remove secrets, truncate files)
-   * @param {ProjectContext} context - Raw project context
-   * @returns {SanitizedContext}
-   */
-  sanitize(context) {
-    // Sanitize package.json (remove private fields, redact secrets)
-    const sanitizedPackageJson = this.sanitizePackageJson(context.packageJson);
-
-    // Extract only filenames from .csproj paths (not full content)
-    const csprojFilenames = context.csprojFiles.map(path => path.split('/').pop());
-
-    // Truncate README and CLAUDE.md to first 500 chars
-    const readmeSummary = context.readme
-      ? this.truncateText(context.readme, MAX_SUMMARY_LENGTH)
-      : null;
-
-    const claudeMdSummary = context.claudeMd
-      ? this.truncateText(context.claudeMd, MAX_SUMMARY_LENGTH)
-      : null;
-
-    // Sanitize infrastructure summary (remove secrets, just count files)
-    const infraSummary = {
-      dockerfilesCount: context.infraFiles.dockerfiles.length,
-      dockerComposeCount: context.infraFiles.dockerComposeFiles.length,
-      bicepFilesCount: context.infraFiles.bicepFiles.length,
-      pipelinesCount: context.infraFiles.pipelines.length,
-      hasAzure: context.infraFiles.hasAzure,
-      hasDocker: context.infraFiles.hasDocker,
-      hasDevOps: context.infraFiles.hasDevOps
-    };
-
-    // Extract git remote domain only (not full URL with credentials)
-    const gitRemoteDomain = context.gitRemote
-      ? this.extractDomain(context.gitRemote)
-      : null;
-
-    // Estimate total files (approximate)
-    const totalFiles = context.structure.topLevelDirs.length * 10; // rough estimate
-
-    return {
-      packageJson: sanitizedPackageJson,
-      csprojFilenames,
-      hasSolution: context.solutionFile !== null,
-      readmeSummary,
-      claudeMdSummary,
-      structure: context.structure,
-      infraSummary,
-      gitRemoteDomain,
-      totalFiles
-    };
-  }
-
-  /**
-   * Sanitize package.json - remove private fields and redact secrets
-   * @param {Object|null} packageJson - Raw package.json
-   * @returns {Object}
-   */
-  sanitizePackageJson(packageJson) {
-    if (!packageJson) {
-      return {};
-    }
-
-    // Keep only safe fields
-    const safe = {
-      name: packageJson.name || 'unknown',
-      version: packageJson.version,
-      description: packageJson.description,
-      type: packageJson.type,
-      engines: packageJson.engines
-    };
-
-    // Include dependencies (names only, no versions for simplicity)
-    if (packageJson.dependencies) {
-      safe.dependencies = Object.keys(packageJson.dependencies);
-    }
-
-    if (packageJson.devDependencies) {
-      safe.devDependencies = Object.keys(packageJson.devDependencies);
-    }
-
-    // Include scripts (but redact any that might contain secrets)
-    if (packageJson.scripts) {
-      safe.scripts = {};
-      for (const [key, value] of Object.entries(packageJson.scripts)) {
-        safe.scripts[key] = this.redactSecrets(value);
-      }
-    }
-
-    return safe;
-  }
-
-  /**
-   * Detect and redact secrets from text
-   * @param {string} text - Text to sanitize
-   * @returns {string} Sanitized text
-   */
-  redactSecrets(text) {
-    if (!text || typeof text !== 'string') {
-      return text;
-    }
-
-    let sanitized = text;
-
-    // Apply all secret patterns
-    for (const pattern of SECRET_PATTERNS) {
-      sanitized = sanitized.replace(pattern.regex, pattern.replacement);
-    }
-
-    return sanitized;
-  }
-
-  /**
-   * Check if file should be excluded from LLM analysis
-   * @param {string} filepath - File path (relative or absolute)
-   * @returns {boolean} True if file should be excluded
-   */
-  shouldExcludeFile(filepath) {
-    const normalizedPath = filepath.replace(/\\/g, '/');
-
-    // Check if path contains blacklisted directory
-    for (const blacklistDir of BLACKLIST_DIRECTORIES) {
-      if (normalizedPath.includes(`/${blacklistDir}/`) || normalizedPath.startsWith(`${blacklistDir}/`)) {
-        return true;
-      }
-    }
-
-    // Check if filename matches blacklist pattern
-    const filename = normalizedPath.split('/').pop();
-    for (const pattern of BLACKLIST_FILES) {
-      if (minimatch(filename, pattern, { nocase: true })) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Check if file is whitelisted for reading
-   * @param {string} filepath - File path
-   * @returns {boolean} True if file is whitelisted
-   */
-  isWhitelisted(filepath) {
-    const normalizedPath = filepath.replace(/\\/g, '/');
-    const filename = normalizedPath.split('/').pop();
-
-    for (const pattern of WHITELIST_FILES) {
-      if (minimatch(filename, pattern, { nocase: true })) {
-        return true;
-      }
-      // Also check full path for patterns like ".github/workflows/*.yml"
-      if (minimatch(normalizedPath, pattern, { nocase: true })) {
-        return true;
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Truncate text to maximum length
-   * @param {string} text - Text to truncate
-   * @param {number} maxLength - Maximum length
-   * @returns {string} Truncated text
-   */
-  truncateText(text, maxLength) {
-    if (!text || text.length <= maxLength) {
-      return text;
-    }
-
-    return text.substring(0, maxLength) + '... [truncated]';
-  }
-
-  /**
-   * Extract domain from git remote URL
-   * @param {string} url - Git remote URL
-   * @returns {string|null} Domain only (e.g., "github.com")
-   */
-  extractDomain(url) {
-    try {
-      // Handle SSH format: git@github.com:user/repo.git
-      if (url.startsWith('git@')) {
-        const match = url.match(/git@([^:]+):/);
-        return match ? match[1] : null;
-      }
-
-      // Handle HTTPS format: https://github.com/user/repo.git
-      const urlObj = new URL(url);
-      return urlObj.hostname;
-    } catch (error) {
-      return null;
-    }
-  }
-}