monomind 2.7.5 → 2.7.7

package/packages/@monomind/cli/dist/src/mcp-tools/quality/test-generation/tdd-cycle.js

@@ -1,348 +0,0 @@
-/**
- * tdd-cycle.ts - TDD red-green-refactor orchestration MCP tool handler
- *
- * Executes TDD cycles with 7 specialized subagents:
- * 1. requirement-analyzer - Analyzes requirements
- * 2. test-designer - Designs test cases
- * 3. red-phase-executor - Writes failing tests
- * 4. green-phase-implementer - Implements to pass tests
- * 5. refactor-advisor - Suggests refactoring improvements
- * 6. coverage-verifier - Verifies coverage targets
- * 7. cycle-coordinator - Orchestrates the cycle
- */
-import { z } from 'zod';
-// Input schema for tdd-cycle tool
-export const TDDCycleInputSchema = z.object({
-    requirement: z.string().min(1).describe('Requirement/story to implement'),
-    targetPath: z.string().describe('Path to implement in'),
-    style: z
-        .enum(['london', 'chicago'])
-        .default('london')
-        .describe('TDD style - London (outside-in, mocks) or Chicago (inside-out, real objects)'),
-    maxCycles: z.number().min(1).max(50).default(10).describe('Maximum TDD cycles to execute'),
-    framework: z
-        .enum(['vitest', 'jest', 'mocha', 'pytest', 'junit'])
-        .default('vitest')
-        .describe('Test framework'),
-    coverageTarget: z.number().min(0).max(100).default(80).describe('Target coverage percentage'),
-    autoRefactor: z.boolean().default(true).describe('Automatically apply refactoring suggestions'),
-    stopOnGreen: z
-        .boolean()
-        .default(false)
-        .describe('Stop immediately when tests pass (skip refactor phase)'),
-});
-// TDD Subagent definitions
-const TDD_SUBAGENTS = [
-    'requirement-analyzer',
-    'test-designer',
-    'red-phase-executor',
-    'green-phase-implementer',
-    'refactor-advisor',
-    'coverage-verifier',
-    'cycle-coordinator',
-];
-/**
- * MCP Tool Handler for tdd-cycle
- */
-export async function handler(input, context) {
-    const startTime = Date.now();
-    const startedAt = new Date().toISOString();
-    try {
-        // Validate input
-        const validatedInput = TDDCycleInputSchema.parse(input);
-        // Get sandbox and bridge from context
-        const sandbox = context.get('aqe.sandbox');
-        const bridge = context.get('aqe.bridge');
-        // Initialize cycle tracking
-        const cycles = [];
-        const agentContributions = new Map();
-        // Initialize agent contributions
-        for (const agent of TDD_SUBAGENTS) {
-            agentContributions.set(agent, {
-                agentId: `${agent}-${Date.now()}`,
-                agentType: agent,
-                tasksCompleted: 0,
-                contributions: [],
-            });
-        }
-        // Step 1: Analyze requirement
-        const requirementAnalysis = await analyzeRequirement(validatedInput.requirement, agentContributions.get('requirement-analyzer'));
-        // Step 2: Design initial tests
-        const testDesign = await designTests(requirementAnalysis, validatedInput.style, agentContributions.get('test-designer'));
-        // Step 3: Execute TDD cycles
-        let currentCoverage = 0;
-        let cycleNumber = 0;
-        while (cycleNumber < validatedInput.maxCycles &&
-            currentCoverage < validatedInput.coverageTarget) {
-            cycleNumber++;
-            const cycleStartTime = Date.now();
-            // RED phase: Write failing test
-            const redPhaseResult = await executeRedPhase(testDesign, cycleNumber, validatedInput.framework, agentContributions.get('red-phase-executor'));
-            // GREEN phase: Implement to pass
-            const greenPhaseResult = await executeGreenPhase(redPhaseResult.test, validatedInput.targetPath, agentContributions.get('green-phase-implementer'), sandbox);
-            // Verify coverage
-            currentCoverage = await verifyCoverage(validatedInput.targetPath, agentContributions.get('coverage-verifier'));
-            // REFACTOR phase (unless stopOnGreen)
-            let refactorings = [];
-            if (!validatedInput.stopOnGreen && greenPhaseResult.passed) {
-                refactorings = await executeRefactorPhase(validatedInput.targetPath, validatedInput.autoRefactor, agentContributions.get('refactor-advisor'));
-            }
-            // Record cycle result
-            cycles.push({
-                cycleNumber,
-                phase: greenPhaseResult.passed ? 'complete' : 'green',
-                test: redPhaseResult.test,
-                implementation: greenPhaseResult.code,
-                refactoring: refactorings,
-                passed: greenPhaseResult.passed,
-                coverage: currentCoverage,
-                durationMs: Date.now() - cycleStartTime,
-            });
-            // Update cycle coordinator
-            const coordinator = agentContributions.get('cycle-coordinator');
-            coordinator.tasksCompleted++;
-            coordinator.contributions.push(`Completed cycle ${cycleNumber} - coverage: ${currentCoverage}%`);
-        }
-        // Build final result
-        const result = {
-            success: currentCoverage >= validatedInput.coverageTarget,
-            cycles,
-            finalCoverage: currentCoverage,
-            totalCycles: cycleNumber,
-            implementation: {
-                filesCreated: [`${validatedInput.targetPath}/__tests__/*.test.ts`],
-                filesModified: [validatedInput.targetPath],
-                linesOfCode: cycles.reduce((sum, c) => sum + (c.implementation?.split('\n').length || 0), 0),
-                testCount: cycles.filter((c) => c.test).length,
-                coverage: currentCoverage,
-            },
-            agents: Array.from(agentContributions.values()),
-            metadata: {
-                startedAt,
-                completedAt: new Date().toISOString(),
-                totalDurationMs: Date.now() - startTime,
-                style: validatedInput.style,
-                framework: validatedInput.framework,
-                requirement: validatedInput.requirement,
-            },
-        };
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify(result, null, 2),
-                },
-            ],
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: JSON.stringify({
-                        success: false,
-                        error: errorMessage,
-                        cycles: [],
-                        finalCoverage: 0,
-                        totalCycles: 0,
-                        metadata: {
-                            startedAt,
-                            completedAt: new Date().toISOString(),
-                            totalDurationMs: Date.now() - startTime,
-                        },
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-}
-async function analyzeRequirement(requirement, agent) {
-    agent.tasksCompleted++;
-    agent.contributions.push(`Analyzed requirement: ${requirement.substring(0, 50)}...`);
-    // Extract key components from requirement
-    const words = requirement.toLowerCase().split(/\s+/);
-    const components = extractComponents(words);
-    const behaviors = extractBehaviors(requirement);
-    const edgeCases = extractEdgeCases(requirement);
-    return {
-        components,
-        behaviors,
-        edgeCases,
-        dependencies: [],
-    };
-}
-async function designTests(analysis, style, agent) {
-    agent.tasksCompleted++;
-    agent.contributions.push(`Designed ${analysis.behaviors.length} test cases using ${style} style`);
-    const tests = analysis.behaviors.map((behavior, index) => ({
-        name: `should ${behavior}`,
-        description: `Test that the system ${behavior}`,
-        behavior,
-        priority: index + 1,
-    }));
-    // Add edge case tests
-    analysis.edgeCases.forEach((edgeCase, index) => {
-        tests.push({
-            name: `should handle ${edgeCase}`,
-            description: `Edge case: ${edgeCase}`,
-            behavior: edgeCase,
-            priority: analysis.behaviors.length + index + 1,
-        });
-    });
-    return {
-        tests,
-        approach: style === 'london' ? 'outside-in' : 'inside-out',
-    };
-}
-async function executeRedPhase(design, cycleNumber, framework, agent) {
-    agent.tasksCompleted++;
-    const testIndex = Math.min(cycleNumber - 1, design.tests.length - 1);
-    const testSpec = design.tests[testIndex];
-    const test = {
-        name: testSpec.name,
-        description: testSpec.description,
-        code: generateFailingTest(testSpec.name, framework),
-        assertions: [`expect(result).toBeDefined()`, `expect(result).toEqual(expected)`],
-    };
-    agent.contributions.push(`Created failing test: ${test.name}`);
-    return {
-        test,
-        failing: true,
-    };
-}
-async function executeGreenPhase(test, targetPath, agent, sandbox) {
-    agent.tasksCompleted++;
-    // Generate minimal implementation to pass the test
-    const implementation = generateMinimalImplementation(test);
-    agent.contributions.push(`Implemented code to pass: ${test.name}`);
-    // Execute in sandbox if available
-    if (sandbox) {
-        try {
-            await sandbox.execute(async () => {
-                // Simulated test execution
-                return true;
-            });
-        }
-        catch {
-            return { code: implementation, passed: false };
-        }
-    }
-    return {
-        code: implementation,
-        passed: true,
-    };
-}
-async function verifyCoverage(_targetPath, agent) {
-    agent.tasksCompleted++;
-    // Coverage can only be measured by running the test suite with a coverage reporter.
-    // This tool generates the test scaffold; run `npx vitest --coverage` after each cycle
-    // to get real numbers.
-    agent.contributions.push('Coverage check deferred — run test suite with --coverage to measure');
-    return 0;
-}
-async function executeRefactorPhase(targetPath, autoApply, agent) {
-    agent.tasksCompleted++;
-    const suggestions = [
-        {
-            type: 'extract-method',
-            description: 'Extract validation logic to separate method',
-            location: `${targetPath}:15-25`,
-            applied: autoApply,
-        },
-        {
-            type: 'simplify',
-            description: 'Simplify conditional logic',
-            location: `${targetPath}:30-35`,
-            applied: autoApply,
-        },
-    ];
-    agent.contributions.push(`Suggested ${suggestions.length} refactorings, ${autoApply ? 'auto-applied' : 'pending review'}`);
-    return suggestions;
-}
-// Helper functions
-function extractComponents(words) {
-    const componentKeywords = ['service', 'handler', 'controller', 'model', 'repository', 'validator'];
-    return words.filter((w) => componentKeywords.some((k) => w.includes(k)));
-}
-function extractBehaviors(requirement) {
-    const behaviors = [];
-    const shouldMatch = requirement.match(/should\s+([^,.]+)/gi);
-    if (shouldMatch) {
-        behaviors.push(...shouldMatch.map((m) => m.replace(/^should\s+/i, '')));
-    }
-    // Extract verb phrases
-    const verbs = ['create', 'update', 'delete', 'validate', 'process', 'handle', 'return'];
-    verbs.forEach((verb) => {
-        if (requirement.toLowerCase().includes(verb)) {
-            behaviors.push(`${verb} correctly`);
-        }
-    });
-    return behaviors.length > 0 ? behaviors : ['process input correctly'];
-}
-function extractEdgeCases(requirement) {
-    const edgeCases = [];
-    if (requirement.includes('input') || requirement.includes('data')) {
-        edgeCases.push('null input', 'empty input', 'invalid input');
-    }
-    if (requirement.includes('error') || requirement.includes('fail')) {
-        edgeCases.push('error conditions');
-    }
-    return edgeCases;
-}
-function generateFailingTest(testName, framework) {
-    const testTemplates = {
-        vitest: `import { describe, it, expect } from 'vitest';
-import { systemUnderTest } from './index';
-
-describe('${testName}', () => {
-  it('${testName}', () => {
-    // Arrange
-    const input = { /* test data */ };
-
-    // Act
-    const result = systemUnderTest(input);
-
-    // Assert (will fail until implemented)
-    expect(result).toBeDefined();
-    expect(result.success).toBe(true);
-  });
-});`,
-        jest: `describe('${testName}', () => {
-  it('${testName}', () => {
-    // Arrange
-    const input = { /* test data */ };
-
-    // Act
-    const result = systemUnderTest(input);
-
-    // Assert (will fail until implemented)
-    expect(result).toBeDefined();
-    expect(result.success).toBe(true);
-  });
-});`,
-    };
-    return testTemplates[framework] || testTemplates.vitest;
-}
-function generateMinimalImplementation(test) {
-    return `// Minimal implementation to pass: ${test.name}
-export function systemUnderTest(input: unknown): { success: boolean } {
-  // TODO: Implement actual logic
-  if (!input) {
-    throw new Error('Input required');
-  }
-  return { success: true };
-}`;
-}
-// Export tool definition for MCP registration
-export const toolDefinition = {
-    name: 'aqe/tdd-cycle',
-    description: 'Execute TDD red-green-refactor cycle with 7 specialized subagents',
-    category: 'test-generation',
-    version: '3.2.3',
-    inputSchema: TDDCycleInputSchema,
-    handler,
-};
-export default toolDefinition;
-//# sourceMappingURL=tdd-cycle.js.map

package/packages/@monomind/cli/dist/src/mcp-tools/wasm-agent-tools.d.ts

@@ -1,9 +0,0 @@
-/**
- * WASM Agent MCP Tools
- *
- * Exposes @monoes/rvagent-wasm operations via MCP protocol.
- * All tools gracefully degrade when the WASM package is not installed.
- */
-import type { MCPTool } from './types.js';
-export declare const wasmAgentTools: MCPTool[];
-//# sourceMappingURL=wasm-agent-tools.d.ts.map

package/packages/@monomind/cli/dist/src/mcp-tools/wasm-agent-tools.js

@@ -1,230 +0,0 @@
-/**
- * WASM Agent MCP Tools
- *
- * Exposes @monoes/rvagent-wasm operations via MCP protocol.
- * All tools gracefully degrade when the WASM package is not installed.
- */
-async function loadAgentWasm() {
-    const mod = await import('../monovector/agent-wasm.js');
-    return mod;
-}
-export const wasmAgentTools = [
-    {
-        name: 'wasm_agent_create',
-        description: 'Create a sandboxed WASM agent with virtual filesystem (no OS access). Optionally use a gallery template.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                template: { type: 'string', description: 'Gallery template name (coder, researcher, tester, reviewer, security, swarm)' },
-                model: { type: 'string', description: 'Model identifier (default: anthropic:claude-sonnet-4-20250514)' },
-                instructions: { type: 'string', description: 'System instructions for the agent' },
-                maxTurns: { type: 'number', description: 'Max conversation turns (default: 50)' },
-            },
-        },
-        handler: async (args) => {
-            try {
-                const wasm = await loadAgentWasm();
-                if (args.template) {
-                    const info = await wasm.createAgentFromTemplate(args.template);
-                    return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, source: 'gallery' }, null, 2) }] };
-                }
-                const info = await wasm.createWasmAgent({
-                    model: args.model,
-                    instructions: args.instructions,
-                    maxTurns: args.maxTurns,
-                });
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info }, null, 2) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_agent_prompt',
-        description: 'Send a prompt to a WASM agent and get a response.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: { type: 'string', description: 'WASM agent ID' },
-                input: { type: 'string', description: 'User prompt to send' },
-            },
-            required: ['agentId', 'input'],
-        },
-        handler: async (args) => {
-            try {
-                const wasm = await loadAgentWasm();
-                const result = await wasm.promptWasmAgent(args.agentId, args.input);
-                return { content: [{ type: 'text', text: result }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_agent_tool',
-        description: 'Execute a tool on a WASM agent sandbox. Tools: read_file, write_file, edit_file, write_todos, list_files. Use flat format: {tool, path, content, ...}.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: { type: 'string', description: 'WASM agent ID' },
-                toolName: { type: 'string', description: 'Tool name (read_file, write_file, edit_file, write_todos, list_files)' },
-                toolInput: { type: 'object', description: 'Tool parameters (flat: {path, content, old_string, new_string, todos})' },
-            },
-            required: ['agentId', 'toolName'],
-        },
-        handler: async (args) => {
-            try {
-                const wasm = await loadAgentWasm();
-                // Flat format: {tool: 'write_file', path: '...', content: '...'}
-                const toolCall = {
-                    tool: args.toolName,
-                    ...(args.toolInput ?? {}),
-                };
-                const result = await wasm.executeWasmTool(args.agentId, toolCall);
-                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_agent_list',
-        description: 'List all active WASM agents.',
-        inputSchema: { type: 'object', properties: {} },
-        handler: async () => {
-            try {
-                const wasm = await loadAgentWasm();
-                const agents = wasm.listWasmAgents();
-                return { content: [{ type: 'text', text: JSON.stringify({ agents, count: agents.length }, null, 2) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_agent_terminate',
-        description: 'Terminate a WASM agent and free resources.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: { type: 'string', description: 'WASM agent ID' },
-            },
-            required: ['agentId'],
-        },
-        handler: async (args) => {
-            try {
-                const wasm = await loadAgentWasm();
-                const ok = wasm.terminateWasmAgent(args.agentId);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: ok }) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_agent_files',
-        description: 'Get a WASM agent\'s available tools and info.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: { type: 'string', description: 'WASM agent ID' },
-            },
-            required: ['agentId'],
-        },
-        handler: async (args) => {
-            try {
-                const wasm = await loadAgentWasm();
-                const tools = wasm.getWasmAgentTools(args.agentId);
-                const info = wasm.getWasmAgent(args.agentId);
-                return { content: [{ type: 'text', text: JSON.stringify({ tools, fileCount: info?.fileCount ?? 0, turnCount: info?.turnCount ?? 0 }, null, 2) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_agent_export',
-        description: 'Export a WASM agent\'s full state (config, filesystem, conversation) as JSON.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: { type: 'string', description: 'WASM agent ID' },
-            },
-            required: ['agentId'],
-        },
-        handler: async (args) => {
-            try {
-                const wasm = await loadAgentWasm();
-                const state = wasm.exportWasmState(args.agentId);
-                return { content: [{ type: 'text', text: state }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_gallery_list',
-        description: 'List all available WASM agent gallery templates (Coder, Researcher, Tester, Reviewer, Security, Swarm).',
-        inputSchema: { type: 'object', properties: {} },
-        handler: async () => {
-            try {
-                const wasm = await loadAgentWasm();
-                const templates = await wasm.listGalleryTemplates();
-                return { content: [{ type: 'text', text: JSON.stringify({ templates, count: templates.length }, null, 2) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_gallery_search',
-        description: 'Search WASM agent gallery templates by query.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                query: { type: 'string', description: 'Search query' },
-            },
-            required: ['query'],
-        },
-        handler: async (args) => {
-            try {
-                const wasm = await loadAgentWasm();
-                const results = await wasm.searchGalleryTemplates(args.query);
-                return { content: [{ type: 'text', text: JSON.stringify({ results, count: results.length }, null, 2) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-    {
-        name: 'wasm_gallery_create',
-        description: 'Create a WASM agent from a gallery template.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                template: { type: 'string', description: 'Template name (coder, researcher, tester, reviewer, security, swarm)' },
-            },
-            required: ['template'],
-        },
-        handler: async (args) => {
-            try {
-                const wasm = await loadAgentWasm();
-                const info = await wasm.createAgentFromTemplate(args.template);
-                return { content: [{ type: 'text', text: JSON.stringify({ success: true, agent: info, template: args.template }, null, 2) }] };
-            }
-            catch (err) {
-                return { content: [{ type: 'text', text: JSON.stringify({ error: String(err) }) }], isError: true };
-            }
-        },
-    },
-];
-//# sourceMappingURL=wasm-agent-tools.js.map

package/packages/@monomind/cli/dist/src/model/complexity-scorer.d.ts

@@ -1,21 +0,0 @@
-/**
- * Heuristic complexity scorer for task descriptions.
- *
- * Returns a score in [0, 100] that drives automatic model-tier selection.
- * Higher scores indicate tasks that benefit from more capable (and costly)
- * models.
- */
-/**
- * Agent slugs that inherently deal with high-complexity work.
- * When one of these agents is involved the score gets a +20 bonus.
- */
-export declare const HIGH_COMPLEXITY_AGENTS: ReadonlySet<string>;
-/**
- * Score the complexity of a task description.
- *
- * @param taskDescription - Free-text description of the task.
- * @param agentSlug       - Optional agent identifier; certain agents boost the score.
- * @returns A number in [0, 100].
- */
-export declare function scoreComplexity(taskDescription: string, agentSlug?: string): number;
-//# sourceMappingURL=complexity-scorer.d.ts.map