swarm-orchestrator 7.0.0-alpha.0

package/dist/src/quick-fix-mode.js

@@ -0,0 +1,302 @@
+"use strict";
+/**
+ * Quick-Fix Mode
+ *
+ * Bypasses full swarm orchestration for simple, single-agent tasks.
+ * Provides faster execution for:
+ * - Single file changes
+ * - Documentation updates
+ * - Bug fixes
+ * - Simple refactoring
+ *
+ * Uses heuristics to determine if a task is "quick-fix eligible"
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuickFixMode = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_loader_1 = require("./config-loader");
+const session_executor_1 = __importDefault(require("./session-executor"));
+const verifier_engine_1 = __importDefault(require("./verifier-engine"));
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)('quick-fix-mode');
+/**
+ * Quick-fix mode for single-agent bypass
+ */
+class QuickFixMode {
+    configLoader;
+    sessionExecutor;
+    verifier;
+    constructor(workingDir) {
+        this.configLoader = new config_loader_1.ConfigLoader();
+        this.sessionExecutor = new session_executor_1.default(workingDir);
+        this.verifier = new verifier_engine_1.default(workingDir);
+    }
+    /**
+     * Determine if a task is eligible for quick-fix mode
+     */
+    isQuickFixEligible(task) {
+        const taskLower = task.toLowerCase();
+        // Indicators that suggest quick-fix is appropriate
+        const quickFixPatterns = [
+            { pattern: /^(fix|update|change|modify)\s+(a|an|the)?\s*single\s+file/i, agent: 'backend_master', reason: 'Single file modification' },
+            { pattern: /^update\s+(readme|documentation|docs?|changelog)/i, agent: 'integrator_finalizer', reason: 'Documentation update' },
+            { pattern: /^fix\s+(typo|spelling|grammar)/i, agent: 'integrator_finalizer', reason: 'Typo fix' },
+            { pattern: /^add\s+(comment|comments|docstring)/i, agent: 'backend_master', reason: 'Adding comments' },
+            { pattern: /^remove\s+(unused|dead)\s+code/i, agent: 'backend_master', reason: 'Code cleanup' },
+            { pattern: /^rename\s+(variable|function|class|file)/i, agent: 'backend_master', reason: 'Renaming' },
+            { pattern: /^fix\s+linting?\s+(error|warning)/i, agent: 'backend_master', reason: 'Linting fix' },
+            { pattern: /^update\s+(dependency|package|version)/i, agent: 'backend_master', reason: 'Dependency update' },
+            { pattern: /^fix\s+simple\s+bug/i, agent: 'backend_master', reason: 'Simple bug fix' }
+        ];
+        for (const { pattern, agent, reason } of quickFixPatterns) {
+            if (pattern.test(task)) {
+                return { eligible: true, reason, suggestedAgent: agent };
+            }
+        }
+        // Indicators that suggest full swarm is needed
+        const fullSwarmPatterns = [
+            { pattern: /\band\b/g, reason: 'Multiple tasks in one request', checkCount: true }, // Check this FIRST
+            { pattern: /multiple\s+(files|components|modules|services)/i, reason: 'Multiple components involved' },
+            { pattern: /\b(architecture|design|refactor|restructure)\b/i, reason: 'Architectural change needed' },
+            { pattern: /\b(implement|build|create)\s+.*(feature|system|module|service)\b/i, reason: 'New feature implementation' },
+            { pattern: /\b(test|testing|e2e|integration)\b.*\b(suite|coverage|framework)\b/i, reason: 'Comprehensive testing needed' },
+            { pattern: /\b(deploy|deployment|ci\/cd|pipeline)\b/i, reason: 'Deployment/infrastructure work' },
+            { pattern: /\b(security|audit|vulnerability)\b.*\b(review|scan|check)\b/i, reason: 'Security review needed' }
+        ];
+        for (const item of fullSwarmPatterns) {
+            const { pattern, reason } = item;
+            if (pattern.test(taskLower)) {
+                // Special case: count "and"s
+                if ('checkCount' in item && item.checkCount) {
+                    const andCount = (taskLower.match(/\band\b/g) || []).length;
+                    if (andCount >= 3) { // 3 or more "and"s means 4+ tasks
+                        return { eligible: false, reason: `Multiple tasks detected (${andCount} "and"s)` };
+                    }
+                    // Otherwise, 1-2 "and"s is ok, continue checking other patterns
+                    continue;
+                }
+                return { eligible: false, reason };
+            }
+        }
+        // Default: if task is short and simple, allow quick-fix
+        if (task.length < 100 && task.split(' ').length < 15) {
+            return {
+                eligible: true,
+                reason: 'Task is short and simple',
+                suggestedAgent: 'backend_master' // default agent
+            };
+        }
+        return {
+            eligible: false,
+            reason: 'Task complexity suggests full swarm orchestration'
+        };
+    }
+    /**
+     * Execute a task in quick-fix mode
+     */
+    async execute(task, options = {}) {
+        const startTime = Date.now();
+        // Check eligibility
+        const eligibility = this.isQuickFixEligible(task);
+        if (!eligibility.eligible) {
+            return {
+                success: false,
+                agentUsed: 'none',
+                output: `⚠️  Quick-fix mode not recommended for this task.\nReason: ${eligibility.reason}\n\nUse full swarm mode instead:\n  swarm plan "${task}"\n  swarm swarm plan.json`,
+                duration: Date.now() - startTime,
+                wasQuickFixEligible: false,
+                reason: eligibility.reason
+            };
+        }
+        // Determine which agent to use
+        const agentName = options.agent || eligibility.suggestedAgent || 'backend_master';
+        let agentProfile;
+        try {
+            const agents = await this.configLoader.loadAllAgents();
+            agentProfile = agents.find((a) => a.name === agentName || config_loader_1.ConfigLoader.normalizeAgentName(a.name) === config_loader_1.ConfigLoader.normalizeAgentName(agentName));
+            if (!agentProfile) {
+                return {
+                    success: false,
+                    agentUsed: agentName,
+                    output: `Agent "${agentName}" not found. Available agents: ${agents.map(a => a.name).join(', ')}`,
+                    duration: Date.now() - startTime,
+                    wasQuickFixEligible: true,
+                    reason: 'Agent not found'
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                agentUsed: agentName,
+                output: `Failed to load agents: ${error instanceof Error ? error.message : String(error)}`,
+                duration: Date.now() - startTime,
+                wasQuickFixEligible: true,
+                reason: error instanceof Error ? error.message : String(error)
+            };
+        }
+        logger.info(`⚡ Quick-fix mode: ${eligibility.reason}`);
+        logger.info(`   Agent: ${agentProfile.name}`);
+        logger.info(`   Task: ${task}\n`);
+        // Build prompt for the agent
+        const prompt = this.buildQuickFixPrompt(task, agentProfile);
+        // Set up session options
+        const workingDir = options.workingDir || process.cwd();
+        const transcriptPath = path.join(workingDir, '.quickfix', `quickfix-${Date.now()}.md`);
+        // Ensure .quickfix directory exists
+        const quickfixDir = path.dirname(transcriptPath);
+        if (!fs.existsSync(quickfixDir)) {
+            fs.mkdirSync(quickfixDir, { recursive: true });
+        }
+        // Only use --agent flag if the agent file exists in the target repo
+        const agentSlug = agentProfile.name.toLowerCase().replace(/\s+/g, '_');
+        const agentFilePath = path.join(workingDir, '.github', 'agents', `${agentSlug}.agent.md`);
+        const agentFileExists = fs.existsSync(agentFilePath);
+        const sessionOptions = {
+            shareToFile: transcriptPath,
+            allowAllTools: true,
+            silent: false,
+            logPrefix: `[${agentProfile.name}]`
+        };
+        // Only pass --agent if the file exists (copilot CLI requires it)
+        if (agentFileExists) {
+            sessionOptions.agent = agentSlug;
+        }
+        if (options.model) {
+            sessionOptions.model = options.model;
+        }
+        // Execute the session
+        let sessionResult;
+        try {
+            sessionResult = await this.sessionExecutor.executeSession(prompt, sessionOptions);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                agentUsed: agentProfile.name,
+                output: `Session execution failed: ${msg}`,
+                duration: Date.now() - startTime,
+                wasQuickFixEligible: true,
+                reason: msg
+            };
+        }
+        // Skip verification if requested
+        if (options.skipVerification) {
+            return {
+                success: sessionResult.success,
+                agentUsed: agentProfile.name,
+                sessionResult,
+                output: sessionResult.output,
+                duration: Date.now() - startTime,
+                wasQuickFixEligible: true,
+                reason: eligibility.reason
+            };
+        }
+        // Verify the work
+        let verificationPassed = false;
+        if (sessionResult.success && sessionResult.transcriptPath) {
+            try {
+                const verificationResult = await this.verifier.verifyStep(1, // Quick-fix is always "step 1"
+                agentProfile.name, sessionResult.transcriptPath, {
+                    requireTests: false, // Don't require tests for quick fixes
+                    requireBuild: false, // Don't require build for quick fixes
+                    requireCommits: true // Do require commits
+                });
+                verificationPassed = verificationResult.passed;
+            }
+            catch (error) {
+                // Verification error - don't fail hard in quick-fix mode
+                logger.warn(`⚠️  Verification skipped: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const duration = Date.now() - startTime;
+        return {
+            success: sessionResult.success,
+            agentUsed: agentProfile.name,
+            sessionResult,
+            verificationPassed,
+            output: sessionResult.output,
+            duration,
+            wasQuickFixEligible: true,
+            reason: eligibility.reason
+        };
+    }
+    /**
+     * Build a prompt for quick-fix mode
+     */
+    buildQuickFixPrompt(task, agent) {
+        const sections = [];
+        sections.push('=== QUICK-FIX MODE ===\n');
+        sections.push('You are executing a simple, focused task that does not require');
+        sections.push('full swarm orchestration. Work quickly and efficiently.\n');
+        sections.push(`Agent: ${agent.name}`);
+        sections.push(`Description: ${agent.description}\n`);
+        sections.push('TASK:');
+        sections.push(task + '\n');
+        sections.push('QUICK-FIX GUIDELINES:');
+        sections.push('- Keep changes minimal and focused');
+        sections.push('- Make 1-3 small commits with clear messages');
+        sections.push('- No need for comprehensive testing unless task requires it');
+        sections.push('- Document changes briefly');
+        sections.push('- Run quick verification (linting, basic tests if applicable)\n');
+        sections.push('Your scope:');
+        agent.scope.forEach(item => {
+            sections.push('- ' + item);
+        });
+        sections.push('');
+        sections.push('Boundaries (do not exceed):');
+        agent.boundaries.forEach(item => {
+            sections.push('- ' + item);
+        });
+        sections.push('');
+        sections.push('Done when:');
+        agent.done_definition.forEach(item => {
+            sections.push('- ' + item);
+        });
+        sections.push('');
+        sections.push('IMPORTANT:');
+        sections.push('Make natural, incremental git commits as you work.');
+        sections.push('Run /share when complete to save transcript.\n');
+        return sections.join('\n');
+    }
+}
+exports.QuickFixMode = QuickFixMode;
+exports.default = QuickFixMode;

package/dist/src/recipe-loader.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRecipe = loadRecipe;
+exports.listRecipes = listRecipes;
+exports.listRecipeDetails = listRecipeDetails;
+exports.parameterizeRecipe = parameterizeRecipe;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const RECIPES_DIR = path.join(__dirname, '..', '..', 'templates', 'recipes');
+/**
+ * Load a recipe by name from the built-in recipes directory.
+ * Throws with available recipe names if the requested recipe is not found.
+ */
+function loadRecipe(name) {
+    const recipePath = path.join(RECIPES_DIR, `${name}.json`);
+    if (!fs.existsSync(recipePath)) {
+        const available = listRecipes();
+        throw new Error(`Unknown recipe "${name}". Available recipes: ${available.join(', ')}`);
+    }
+    const content = fs.readFileSync(recipePath, 'utf8');
+    return JSON.parse(content);
+}
+/**
+ * List all available recipe names (without .json extension).
+ */
+function listRecipes() {
+    if (!fs.existsSync(RECIPES_DIR)) {
+        return [];
+    }
+    return fs.readdirSync(RECIPES_DIR)
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace(/\.json$/, ''))
+        .sort();
+}
+/**
+ * Return full metadata for all available recipes.
+ */
+function listRecipeDetails() {
+    return listRecipes().map(name => loadRecipe(name));
+}
+/**
+ * Substitute {{param}} placeholders in recipe step tasks with provided values.
+ * Missing parameters fall back to the recipe's declared defaults.
+ * Throws if a placeholder has no provided value and no default.
+ */
+function parameterizeRecipe(recipe, params) {
+    const merged = {};
+    // Collect defaults first, then override with user-supplied values
+    for (const [key, def] of Object.entries(recipe.parameters)) {
+        if (params[key] !== undefined) {
+            merged[key] = params[key];
+        }
+        else if (def.default !== undefined) {
+            merged[key] = def.default;
+        }
+    }
+    // Validate: every placeholder in step tasks must be resolvable
+    const placeholderRegex = /\{\{(\w[\w-]*)\}\}/g;
+    const steps = recipe.steps.map(step => {
+        let match;
+        // Reset lastIndex since we reuse the regex
+        placeholderRegex.lastIndex = 0;
+        while ((match = placeholderRegex.exec(step.task)) !== null) {
+            const paramName = match[1];
+            if (merged[paramName] === undefined) {
+                throw new Error(`Recipe "${recipe.name}" step ${step.stepNumber}: parameter "${paramName}" has no value and no default`);
+            }
+        }
+        // Replace all placeholders
+        const task = step.task.replace(placeholderRegex, (_full, paramName) => {
+            return merged[paramName] ?? paramName;
+        });
+        return {
+            stepNumber: step.stepNumber,
+            agentName: step.agentName,
+            task,
+            dependencies: [...step.dependencies],
+            expectedOutputs: [...step.expectedOutputs],
+        };
+    });
+    return {
+        goal: `Recipe: ${recipe.name} (${recipe.description})`,
+        createdAt: new Date().toISOString(),
+        steps,
+        metadata: {
+            totalSteps: steps.length,
+        },
+    };
+}