codymaster 4.1.0

package/dist/parallel-quality.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMiniGatePrompt = generateMiniGatePrompt;
+exports.compositeAgentPrompt = compositeAgentPrompt;
+exports.getQualityContractForTask = getQualityContractForTask;
+exports.validateAgentReport = validateAgentReport;
+// ─── TRIZ #3: Local Quality — Per-Agent Mini Gate ──────────────────────────
+/**
+ * Generates a lightweight quality gate prompt that each agent must run
+ * on its own modified files. Only checks syntax (Layer 1) and business
+ * logic (Layer 3) — skips full suite for speed.
+ *
+ * TRIZ Principle #3 (Local Quality): Each part of the system should
+ * perform the function that is most useful locally.
+ */
+function generateMiniGatePrompt(task, contract) {
+    const checks = [];
+    if (contract.mustPassSyntax) {
+        checks.push(`1. **Syntax Validation**: Ensure all modified files parse without errors.
+   For TypeScript/JavaScript files, run: \`npx tsc --noEmit\` or use acorn parser.
+   Modified files to check: ${task.affectedFiles.join(', ') || 'all changed files'}`);
+    }
+    if (contract.mustPassTests) {
+        checks.push(`2. **Test Execution**: Run tests relevant to your changes.
+   Command: \`npm run test:gate\` OR run only tests related to modified files.
+   If you created new functionality, write at least 1 test for it.`);
+    }
+    if (contract.mustSelfReview) {
+        checks.push(`3. **Self-Review Checklist**:
+   - [ ] No console.log/debug statements left
+   - [ ] No hardcoded values that should be configurable
+   - [ ] No TODO comments without associated task IDs
+   - [ ] Error handling is present for all async operations
+   - [ ] Types are properly defined (no \`any\` unless justified)`);
+    }
+    return `
+## ⚡ Quality Contract (TRIZ #3 Local Quality)
+
+Before reporting task completion, you MUST pass these quality checks:
+
+${checks.join('\n\n')}
+
+### Constraints
+- Maximum modified files: ${contract.maxModifiedFiles}
+- Timeout: ${Math.round(contract.timeoutMs / 1000)}s
+
+### Report Format
+After completing quality checks, report:
+\`\`\`json
+{
+  "taskId": "${task.id}",
+  "passed": true/false,
+  "modifiedFiles": ["file1.ts", "file2.ts"],
+  "testsPassed": 0,
+  "testsFailed": 0,
+  "issues": []
+}
+\`\`\`
+`;
+}
+// ─── TRIZ #40: Composite — Agent = Implementer + Tester + Reviewer ────────
+/**
+ * Generates a composite agent prompt that instructs the agent to perform
+ * all three roles: implement, test, and review.
+ *
+ * TRIZ Principle #40 (Composite Materials): Change from uniform to composite.
+ * Each agent is not just an implementer — it's a composite of three roles.
+ */
+function compositeAgentPrompt(task, project, batchInfo) {
+    const qualityGate = generateMiniGatePrompt(task, task.qualityContract);
+    return `# Parallel Task: ${task.title}
+
+## 🔧 Context
+| Field | Value |
+|-------|-------|
+| Project | ${project.name} |
+| Workspace | \`${project.path}\` |
+| Batch | ${batchInfo.batchId} (task ${batchInfo.position + 1}/${batchInfo.batchSize}) |
+| Skill | ${task.skill || 'None'} |
+| Priority | ${task.priority} |
+
+## 📝 Description
+
+${task.description || 'No additional description provided.'}
+
+## 🎭 Your Three Roles (TRIZ #40 Composite)
+
+### Role 1: IMPLEMENTER
+Implement the task as described above. Follow existing code patterns and conventions.
+${task.skill ? `Use skill \`${task.skill}\` for guidance.` : ''}
+
+### Role 2: TESTER
+After implementing, write or update tests for your changes:
+- At minimum, 1 test per new function
+- Run existing tests to ensure no regressions
+- If TDD applies, write tests FIRST (cm-tdd)
+
+### Role 3: REVIEWER
+Before reporting completion, review your own work:
+- Read your diff critically
+- Check for edge cases you may have missed
+- Verify error handling completeness
+
+${qualityGate}
+
+## ⚠️ Parallel Execution Rules
+
+1. **ONLY modify these files**: ${task.affectedFiles.length > 0 ? task.affectedFiles.map(f => `\`${f}\``).join(', ') : 'Files as needed for this task'}
+2. **DO NOT modify files outside your scope** — other agents are working in parallel
+3. **Report your actual modified files** after completion for conflict detection
+4. **If you need to modify a shared file**, STOP and report the conflict instead of proceeding
+`;
+}
+// ─── Quality Contract Presets ───────────────────────────────────────────────
+/**
+ * Returns a quality contract tuned for the task type.
+ */
+function getQualityContractForTask(task) {
+    // High-priority or urgent tasks get stricter contracts
+    if (task.priority === 'urgent' || task.priority === 'high') {
+        return {
+            mustPassSyntax: true,
+            mustPassTests: true,
+            mustSelfReview: true,
+            maxModifiedFiles: 5,
+            timeoutMs: 180000, // 3 min — tighter deadline
+        };
+    }
+    // Standard contract
+    return {
+        mustPassSyntax: true,
+        mustPassTests: true,
+        mustSelfReview: true,
+        maxModifiedFiles: 10,
+        timeoutMs: 300000, // 5 min
+    };
+}
+// ─── Validate Agent Report ──────────────────────────────────────────────────
+/**
+ * Validates an agent's self-reported quality gate result.
+ * Returns a structured result with pass/fail details.
+ */
+function validateAgentReport(report, contract) {
+    const checks = [];
+    // Check file count constraint
+    checks.push({
+        name: 'Modified files within limit',
+        passed: report.modifiedFiles.length <= contract.maxModifiedFiles,
+        details: `${report.modifiedFiles.length}/${contract.maxModifiedFiles} files`,
+    });
+    // Check test results
+    if (contract.mustPassTests) {
+        checks.push({
+            name: 'Tests passing',
+            passed: report.testsFailed === 0,
+            details: `${report.testsPassed} passed, ${report.testsFailed} failed`,
+        });
+    }
+    // Check self-reported pass status
+    checks.push({
+        name: 'Agent self-assessment',
+        passed: report.passed,
+        details: report.issues.length > 0 ? report.issues.join('; ') : 'No issues reported',
+    });
+    const allPassed = checks.every(c => c.passed);
+    return {
+        passed: allPassed,
+        taskId: report.taskId,
+        checks,
+        timestamp: new Date().toISOString(),
+    };
+}

package/dist/skill-chain.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchChain = matchChain;
+exports.listChains = listChains;
+exports.findChain = findChain;
+exports.createChainExecution = createChainExecution;
+exports.advanceChain = advanceChain;
+exports.skipChainStep = skipChainStep;
+exports.abortChain = abortChain;
+exports.failChainStep = failChainStep;
+exports.formatChainProgress = formatChainProgress;
+exports.formatChainProgressBar = formatChainProgressBar;
+exports.getCurrentSkill = getCurrentSkill;
+const crypto_1 = __importDefault(require("crypto"));
+const builtin_1 = require("./chains/builtin");
+// ─── Chain Matching ─────────────────────────────────────────────────────────
+// TRIZ #10: Preliminary Action — analyze task BEFORE dispatching
+/**
+ * Auto-detect the best chain for a task title using keyword matching.
+ * Returns the best matching chain, or undefined if no match.
+ */
+function matchChain(taskTitle) {
+    const title = taskTitle.toLowerCase();
+    const chains = (0, builtin_1.getBuiltinChains)();
+    let bestMatch;
+    let bestScore = 0;
+    for (const chain of chains) {
+        let score = 0;
+        for (const trigger of chain.triggers) {
+            if (title.includes(trigger.toLowerCase())) {
+                // Longer triggers get higher scores (more specific = better match)
+                score += trigger.length;
+            }
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            bestMatch = chain;
+        }
+    }
+    return bestMatch;
+}
+/**
+ * List all available chains (built-in + user-defined in the future).
+ */
+function listChains() {
+    return (0, builtin_1.getBuiltinChains)();
+}
+/**
+ * Find a chain by ID.
+ */
+function findChain(chainId) {
+    return (0, builtin_1.getChainById)(chainId);
+}
+// ─── Chain Execution Management ─────────────────────────────────────────────
+// TRIZ #40: Composite Materials — skills compose into pipelines
+/**
+ * Create a new chain execution from a chain definition.
+ */
+function createChainExecution(chain, projectId, taskTitle, agent) {
+    const now = new Date().toISOString();
+    const steps = chain.steps.map((step, index) => ({
+        index,
+        skill: step.skill,
+        description: step.description,
+        condition: step.condition,
+        optional: step.optional || false,
+        status: 'pending',
+    }));
+    // First step starts immediately
+    if (steps.length > 0) {
+        steps[0].status = 'running';
+        steps[0].startedAt = now;
+    }
+    return {
+        id: crypto_1.default.randomUUID(),
+        chainId: chain.id,
+        chainName: chain.name,
+        projectId,
+        taskTitle,
+        agent,
+        status: 'running',
+        currentStepIndex: 0,
+        steps,
+        startedAt: now,
+        updatedAt: now,
+    };
+}
+/**
+ * Advance the chain to the next step. Marks current step as completed.
+ * Returns the next step's skill name, or null if chain is complete.
+ */
+function advanceChain(execution, output) {
+    const now = new Date().toISOString();
+    const currentStep = execution.steps[execution.currentStepIndex];
+    if (!currentStep) {
+        return { nextSkill: null, completed: true };
+    }
+    // Mark current step as completed
+    currentStep.status = 'completed';
+    currentStep.completedAt = now;
+    if (output)
+        currentStep.output = output;
+    execution.updatedAt = now;
+    // Find next non-skipped step
+    let nextIndex = execution.currentStepIndex + 1;
+    while (nextIndex < execution.steps.length) {
+        const nextStep = execution.steps[nextIndex];
+        // Skip optional steps with conditions that aren't met
+        if (nextStep.optional && nextStep.condition !== 'always') {
+            nextStep.status = 'skipped';
+            nextStep.completedAt = now;
+            nextIndex++;
+            continue;
+        }
+        break;
+    }
+    if (nextIndex >= execution.steps.length) {
+        // Chain completed!
+        execution.status = 'completed';
+        execution.completedAt = now;
+        execution.currentStepIndex = execution.steps.length;
+        return { nextSkill: null, completed: true };
+    }
+    // Start next step
+    execution.currentStepIndex = nextIndex;
+    const nextStep = execution.steps[nextIndex];
+    nextStep.status = 'running';
+    nextStep.startedAt = now;
+    return { nextSkill: nextStep.skill, completed: false };
+}
+/**
+ * Skip the current step in the chain.
+ */
+function skipChainStep(execution, reason) {
+    const now = new Date().toISOString();
+    const currentStep = execution.steps[execution.currentStepIndex];
+    if (!currentStep) {
+        return { nextSkill: null, completed: true };
+    }
+    currentStep.status = 'skipped';
+    currentStep.completedAt = now;
+    if (reason)
+        currentStep.output = `Skipped: ${reason}`;
+    execution.updatedAt = now;
+    // Find next step
+    let nextIndex = execution.currentStepIndex + 1;
+    if (nextIndex >= execution.steps.length) {
+        execution.status = 'completed';
+        execution.completedAt = now;
+        execution.currentStepIndex = execution.steps.length;
+        return { nextSkill: null, completed: true };
+    }
+    execution.currentStepIndex = nextIndex;
+    const nextStep = execution.steps[nextIndex];
+    nextStep.status = 'running';
+    nextStep.startedAt = now;
+    return { nextSkill: nextStep.skill, completed: false };
+}
+/**
+ * Abort the entire chain.
+ */
+function abortChain(execution, reason) {
+    const now = new Date().toISOString();
+    execution.status = 'aborted';
+    execution.completedAt = now;
+    execution.updatedAt = now;
+    // Mark remaining pending steps as skipped
+    for (const step of execution.steps) {
+        if (step.status === 'pending' || step.status === 'running') {
+            step.status = 'skipped';
+            step.completedAt = now;
+            if (reason)
+                step.output = `Aborted: ${reason}`;
+        }
+    }
+}
+/**
+ * Mark the current step as failed.
+ */
+function failChainStep(execution, error) {
+    const now = new Date().toISOString();
+    const currentStep = execution.steps[execution.currentStepIndex];
+    if (currentStep) {
+        currentStep.status = 'failed';
+        currentStep.completedAt = now;
+        currentStep.error = error;
+    }
+    execution.status = 'failed';
+    execution.updatedAt = now;
+}
+// ─── Display Helpers ────────────────────────────────────────────────────────
+const STEP_ICONS = {
+    pending: '⚪',
+    running: '🔵',
+    skipped: '⏭️',
+    completed: '✅',
+    failed: '❌',
+};
+const STATUS_ICONS = {
+    pending: '⚪',
+    running: '🔵',
+    paused: '⏸️',
+    completed: '✅',
+    failed: '❌',
+    aborted: '🛑',
+};
+/**
+ * Format chain progress for CLI display.
+ */
+function formatChainProgress(execution) {
+    const lines = [];
+    const statusIcon = STATUS_ICONS[execution.status] || '❓';
+    lines.push(`${statusIcon} Chain: ${execution.chainName} — "${execution.taskTitle}"`);
+    lines.push(`   Status: ${execution.status} | Agent: ${execution.agent}`);
+    lines.push(`   Progress: ${getCompletedCount(execution)}/${execution.steps.length} steps`);
+    lines.push('');
+    for (const step of execution.steps) {
+        const icon = STEP_ICONS[step.status] || '❓';
+        const current = step.index === execution.currentStepIndex && execution.status === 'running' ? ' ◄ CURRENT' : '';
+        lines.push(`   ${icon} ${step.index + 1}. ${step.skill} — ${step.description}${current}`);
+        if (step.error)
+            lines.push(`      ⚠️  Error: ${step.error}`);
+        if (step.output && step.status !== 'skipped')
+            lines.push(`      📝 ${step.output}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format a compact chain progress bar.
+ */
+function formatChainProgressBar(execution) {
+    const parts = execution.steps.map(step => {
+        switch (step.status) {
+            case 'completed': return '█';
+            case 'running': return '▓';
+            case 'skipped': return '░';
+            case 'failed': return '✗';
+            default: return '░';
+        }
+    });
+    const pct = Math.round((getCompletedCount(execution) / execution.steps.length) * 100);
+    return `[${parts.join('')}] ${pct}%`;
+}
+function getCompletedCount(execution) {
+    return execution.steps.filter(s => s.status === 'completed' || s.status === 'skipped').length;
+}
+/**
+ * Get the current step's skill name.
+ */
+function getCurrentSkill(execution) {
+    var _a;
+    if (execution.currentStepIndex >= execution.steps.length)
+        return null;
+    return ((_a = execution.steps[execution.currentStepIndex]) === null || _a === void 0 ? void 0 : _a.skill) || null;
+}