atlas-pipeline-mcp 1.0.0

package/dist/tools/optimize.js

@@ -0,0 +1,302 @@
+/**
+ * Atlas Server - Optimization Tool
+ *
+ * Takes the best variant and critique, then produces an optimized final output:
+ * - Addresses identified issues
+ * - Applies performance improvements
+ * - Enhances readability and maintainability
+ * - Follows best practices
+ */
+import { getOllamaClient, PromptTemplates } from './ollama.js';
+import { logger } from '../utils.js';
+// ============================================================================
+// Optimization
+// ============================================================================
+/**
+ * Optimize the best variant based on critique feedback
+ */
+export async function optimizeVariant(variant, critique) {
+    logger.debug({
+        variantId: variant.id,
+        qualityScore: critique.qualityScore,
+        issueCount: critique.issues.length
+    }, 'Starting optimization');
+    // If quality is already high and no critical issues, minimal optimization needed
+    if (critique.qualityScore >= 90 && !hasCriticalIssues(critique)) {
+        return createMinimalOptimization(variant, critique);
+    }
+    const client = getOllamaClient();
+    const prompt = buildOptimizationPrompt(variant, critique);
+    const response = await client.generateJson(prompt, {
+        systemPrompt: PromptTemplates.optimization,
+        temperature: 0.4,
+        maxTokens: 4096,
+    });
+    if (response.data) {
+        const optimizations = response.data.optimizations.map((opt) => ({
+            type: normalizeOptimizationType(opt.type),
+            description: opt.description,
+            impact: normalizeImpact(opt.impact),
+        }));
+        // Re-assess the optimized code
+        const finalMetrics = estimateFinalMetrics(critique.assessment, optimizations);
+        return {
+            content: response.data.optimizedContent,
+            optimizationsApplied: optimizations,
+            finalMetrics,
+            explanation: response.data.explanation,
+        };
+    }
+    // Fallback: return variant with minor adjustments
+    logger.warn('Optimization failed, using fallback');
+    return createMinimalOptimization(variant, critique);
+}
+/**
+ * Build the optimization prompt
+ */
+function buildOptimizationPrompt(variant, critique) {
+    const criticalIssues = critique.issues.filter((i) => i.severity === 'critical');
+    const majorIssues = critique.issues.filter((i) => i.severity === 'major');
+    const minorIssues = critique.issues.filter((i) => i.severity === 'minor');
+    return `Optimize this code based on the critique feedback.
+
+## Original Code (Variant ${variant.label})
+\`\`\`
+${variant.content}
+\`\`\`
+
+## Approach
+${variant.approach}
+
+## Quality Assessment
+- Correctness: ${critique.assessment.correctness}/100
+- Performance: ${critique.assessment.performance}/100
+- Maintainability: ${critique.assessment.maintainability}/100
+- Security: ${critique.assessment.security}/100
+- Best Practices: ${critique.assessment.bestPractices}/100
+
+## Issues to Address
+
+${criticalIssues.length > 0 ? `### Critical Issues (MUST FIX)
+${criticalIssues.map((i) => `- ${i.description}${i.suggestedFix ? ` → ${i.suggestedFix}` : ''}`).join('\n')}` : ''}
+
+${majorIssues.length > 0 ? `### Major Issues (Should Fix)
+${majorIssues.map((i) => `- ${i.description}${i.suggestedFix ? ` → ${i.suggestedFix}` : ''}`).join('\n')}` : ''}
+
+${minorIssues.length > 0 ? `### Minor Issues (Nice to Fix)
+${minorIssues.map((i) => `- ${i.description}`).join('\n')}` : ''}
+
+## Suggestions
+${critique.suggestions.map((s) => `- ${s}`).join('\n')}
+
+## Requirements
+1. Fix ALL critical issues
+2. Address major issues where possible
+3. Improve the lowest-scoring assessment areas
+4. Maintain the original functionality
+5. Keep the code clean and readable
+
+## Output Format
+{
+  "optimizedContent": "The complete optimized code",
+  "optimizations": [
+    {
+      "type": "performance|readability|security|simplification|best_practice",
+      "description": "What was changed",
+      "impact": "low|medium|high"
+    }
+  ],
+  "explanation": "Summary of optimizations and why they improve the code"
+}`;
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Check if critique has critical issues
+ */
+function hasCriticalIssues(critique) {
+    return critique.issues.some((i) => i.severity === 'critical');
+}
+/**
+ * Create minimal optimization for already-good code
+ */
+function createMinimalOptimization(variant, critique) {
+    return {
+        content: variant.content,
+        optimizationsApplied: [{
+                type: 'best_practice',
+                description: 'Code quality verified, no significant changes needed',
+                impact: 'low',
+            }],
+        finalMetrics: critique.assessment,
+        explanation: `The solution (Variant ${variant.label}) scored ${critique.qualityScore}/100 and ` +
+            `requires no significant optimization. The approach "${variant.approach}" is solid.`,
+    };
+}
+/**
+ * Normalize optimization type
+ */
+function normalizeOptimizationType(type) {
+    const normalized = type.toLowerCase();
+    if (normalized.includes('perform'))
+        return 'performance';
+    if (normalized.includes('read') || normalized.includes('maintain'))
+        return 'readability';
+    if (normalized.includes('secur'))
+        return 'security';
+    if (normalized.includes('simpl'))
+        return 'simplification';
+    return 'best_practice';
+}
+/**
+ * Normalize impact level
+ */
+function normalizeImpact(impact) {
+    const normalized = impact.toLowerCase();
+    if (normalized === 'high')
+        return 'high';
+    if (normalized === 'medium')
+        return 'medium';
+    return 'low';
+}
+/**
+ * Estimate final metrics after optimizations
+ */
+function estimateFinalMetrics(original, optimizations) {
+    const improved = { ...original };
+    for (const opt of optimizations) {
+        const boost = opt.impact === 'high' ? 10 : opt.impact === 'medium' ? 5 : 2;
+        switch (opt.type) {
+            case 'performance':
+                improved.performance = Math.min(100, improved.performance + boost);
+                break;
+            case 'readability':
+                improved.maintainability = Math.min(100, improved.maintainability + boost);
+                break;
+            case 'security':
+                improved.security = Math.min(100, improved.security + boost);
+                break;
+            case 'simplification':
+                improved.maintainability = Math.min(100, improved.maintainability + boost);
+                improved.bestPractices = Math.min(100, improved.bestPractices + boost / 2);
+                break;
+            case 'best_practice':
+                improved.bestPractices = Math.min(100, improved.bestPractices + boost);
+                break;
+        }
+    }
+    return improved;
+}
+// ============================================================================
+// Advanced Optimization Strategies
+// ============================================================================
+/**
+ * Apply multiple optimization passes
+ */
+export async function multiPassOptimization(variant, critique, maxPasses = 2) {
+    let currentContent = variant.content;
+    let currentCritique = critique;
+    const allOptimizations = [];
+    for (let pass = 0; pass < maxPasses; pass++) {
+        // Skip if already high quality
+        if (currentCritique.qualityScore >= 95) {
+            break;
+        }
+        const currentVariant = {
+            ...variant,
+            content: currentContent,
+        };
+        const result = await optimizeVariant(currentVariant, currentCritique);
+        currentContent = result.content;
+        allOptimizations.push(...result.optimizationsApplied);
+        // Update critique for next pass (simplified - in reality would re-critique)
+        currentCritique = {
+            ...currentCritique,
+            qualityScore: Math.min(100, currentCritique.qualityScore + 10),
+            assessment: result.finalMetrics,
+            issues: currentCritique.issues.filter((i) => i.severity === 'minor'),
+        };
+        logger.debug({ pass: pass + 1, qualityScore: currentCritique.qualityScore }, 'Optimization pass complete');
+    }
+    return {
+        content: currentContent,
+        optimizationsApplied: allOptimizations,
+        finalMetrics: currentCritique.assessment,
+        explanation: `Applied ${allOptimizations.length} optimizations across ${Math.min(maxPasses, allOptimizations.length > 0 ? maxPasses : 1)} passes.`,
+    };
+}
+/**
+ * Optimization presets for common scenarios
+ */
+export const OptimizationPresets = {
+    /**
+     * Focus on performance optimizations
+     */
+    performance: {
+        focus: ['performance', 'simplification'],
+        minScoreThreshold: 70,
+        maxIterations: 2,
+    },
+    /**
+     * Focus on code quality and maintainability
+     */
+    quality: {
+        focus: ['readability', 'best_practice'],
+        minScoreThreshold: 80,
+        maxIterations: 2,
+    },
+    /**
+     * Focus on security hardening
+     */
+    security: {
+        focus: ['security'],
+        minScoreThreshold: 90,
+        maxIterations: 3,
+    },
+    /**
+     * Balanced optimization
+     */
+    balanced: {
+        focus: ['performance', 'readability', 'security', 'best_practice'],
+        minScoreThreshold: 75,
+        maxIterations: 2,
+    },
+};
+/**
+ * Get optimization recommendations based on critique
+ */
+export function getOptimizationRecommendations(critique) {
+    const { assessment } = critique;
+    // Find weakest areas
+    const scores = Object.entries(assessment);
+    const weakest = scores.sort((a, b) => a[1] - b[1]).slice(0, 2);
+    // Determine best preset
+    if (critique.issues.some((i) => i.category === 'security' && i.severity === 'critical')) {
+        return {
+            preset: 'security',
+            reason: 'Critical security issues detected',
+            focusAreas: ['security'],
+        };
+    }
+    if (assessment.performance < 50) {
+        return {
+            preset: 'performance',
+            reason: 'Performance score is below threshold',
+            focusAreas: weakest.map(([area]) => area),
+        };
+    }
+    if (assessment.maintainability < 60 || assessment.bestPractices < 60) {
+        return {
+            preset: 'quality',
+            reason: 'Code quality needs improvement',
+            focusAreas: weakest.map(([area]) => area),
+        };
+    }
+    return {
+        preset: 'balanced',
+        reason: 'General optimization recommended',
+        focusAreas: weakest.map(([area]) => area),
+    };
+}
+//# sourceMappingURL=optimize.js.map

package/dist/tools/optimize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimize.js","sourceRoot":"","sources":["../../src/tools/optimize.ts"],"names":[],"mappings":"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"}

package/dist/tools/variants.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Atlas Server - Variant Generation Tool
+ *
+ * Generates multiple solution variants for a given task:
+ * - Different approaches with trade-offs
+ * - Pros and cons analysis
+ * - Use case recommendations
+ * - Diversity in implementation strategies
+ */
+import type { PipelineContext, DecompositionResult, SolutionVariant, VariantGenerationResult } from '../types.js';
+/**
+ * Generate multiple solution variants for a task
+ */
+export declare function generateVariants(context: PipelineContext, decomposition: DecompositionResult, variantCount?: number): Promise<VariantGenerationResult>;
+/**
+ * Compare variants and rank them
+ */
+export declare function rankVariants(variants: SolutionVariant[], criteria: RankingCriteria): RankedVariant[];
+export interface RankingCriteria {
+    /** Weight for simplicity (0-1) */
+    simplicityWeight: number;
+    /** Weight for performance (0-1) */
+    performanceWeight: number;
+    /** Weight for maintainability (0-1) */
+    maintainabilityWeight: number;
+    /** Weight for feature completeness (0-1) */
+    completenessWeight: number;
+}
+export interface RankedVariant extends SolutionVariant {
+    rank: number;
+    score: number;
+}
+/**
+ * Ensure variants are sufficiently diverse
+ */
+export declare function checkVariantDiversity(variants: SolutionVariant[]): {
+    isDiverse: boolean;
+    similarityScore: number;
+    suggestions: string[];
+};
+/**
+ * Merge best aspects of multiple variants
+ */
+export declare function synthesizeBestAspects(variants: SolutionVariant[]): {
+    combinedPros: string[];
+    conflictingAspects: string[];
+    synthesis: string;
+};
+//# sourceMappingURL=variants.d.ts.map

package/dist/tools/variants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variants.d.ts","sourceRoot":"","sources":["../../src/tools/variants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,EACf,uBAAuB,EACxB,MAAM,aAAa,CAAC;AAerB;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,eAAe,EACxB,aAAa,EAAE,mBAAmB,EAClC,YAAY,GAAE,MAA8B,GAC3C,OAAO,CAAC,uBAAuB,CAAC,CAqDlC;AA6GD;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,eAAe,EAAE,EAC3B,QAAQ,EAAE,eAAe,GACxB,aAAa,EAAE,CAYjB;AAED,MAAM,WAAW,eAAe;IAC9B,kCAAkC;IAClC,gBAAgB,EAAE,MAAM,CAAC;IACzB,mCAAmC;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,uCAAuC;IACvC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,4CAA4C;IAC5C,kBAAkB,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,aAAc,SAAQ,eAAe;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAmDD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG;IAClE,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAmCA;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,eAAe,EAAE,GAC1B;IACD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB,CAyBA"}

package/dist/tools/variants.js

@@ -0,0 +1,252 @@
+/**
+ * Atlas Server - Variant Generation Tool
+ *
+ * Generates multiple solution variants for a given task:
+ * - Different approaches with trade-offs
+ * - Pros and cons analysis
+ * - Use case recommendations
+ * - Diversity in implementation strategies
+ */
+import { getOllamaClient, PromptTemplates } from './ollama.js';
+import { logger, generateId } from '../utils.js';
+// ============================================================================
+// Configuration
+// ============================================================================
+const DEFAULT_VARIANT_COUNT = 3;
+const VARIANT_LABELS = ['A', 'B', 'C', 'D', 'E'];
+// ============================================================================
+// Variant Generation
+// ============================================================================
+/**
+ * Generate multiple solution variants for a task
+ */
+export async function generateVariants(context, decomposition, variantCount = DEFAULT_VARIANT_COUNT) {
+    logger.debug({ taskCount: decomposition.tasks.length, variantCount }, 'Starting variant generation');
+    const client = getOllamaClient();
+    const prompt = buildVariantPrompt(context, decomposition, variantCount);
+    const response = await client.generateJson(prompt, {
+        systemPrompt: PromptTemplates.variantGeneration,
+        temperature: 0.7, // Higher temp for creative diversity
+        maxTokens: 4096,
+    });
+    if (response.data) {
+        const variants = response.data.variants.map((v, index) => ({
+            id: generateId(),
+            label: VARIANT_LABELS[index] ?? `V${index + 1}`,
+            content: v.content,
+            approach: v.approach,
+            tradeoffs: {
+                pros: v.pros,
+                cons: v.cons,
+            },
+            useCase: v.useCase,
+        }));
+        const recommendedIndex = Math.min(Math.max(0, response.data.recommendedIndex), variants.length - 1);
+        return {
+            variants,
+            recommendedVariantId: variants[recommendedIndex]?.id ?? variants[0]?.id ?? '',
+            recommendationReason: response.data.recommendationReason,
+        };
+    }
+    // Fallback: generate single variant
+    logger.warn('Variant generation failed, using fallback');
+    return fallbackVariant(context, decomposition);
+}
+/**
+ * Build the variant generation prompt
+ */
+function buildVariantPrompt(context, decomposition, variantCount) {
+    const { intent, projectInfo, codeSnippets } = context;
+    let prompt = `Generate ${variantCount} different solution variants for this task.
+
+## Task Summary
+${decomposition.summary}
+
+## Subtasks
+${decomposition.tasks.map((t) => `- [${t.type}] ${t.description} (${t.complexity} complexity)`).join('\n')}
+
+## Intent
+- Type: ${intent.primaryIntent}
+- Keywords: ${intent.keywords.join(', ')}
+`;
+    if (projectInfo) {
+        prompt += `
+## Project Context
+- Languages: ${projectInfo.languages.join(', ')}
+- Frameworks: ${projectInfo.frameworks.join(', ')}
+`;
+    }
+    if (codeSnippets.length > 0) {
+        prompt += `
+## Existing Code Context
+${codeSnippets[0] ? `\`\`\`${codeSnippets[0].language}\n${codeSnippets[0].content.substring(0, 800)}\n\`\`\`` : ''}
+`;
+    }
+    prompt += `
+## Requirements
+Generate ${variantCount} meaningfully different solutions. Each should:
+1. Take a different approach or make different trade-offs
+2. Be complete and production-ready
+3. Include clear pros and cons
+4. Specify the best use case
+
+## Output Format
+{
+  "variants": [
+    {
+      "approach": "Brief description of the approach",
+      "content": "The complete solution code or text",
+      "pros": ["advantage 1", "advantage 2"],
+      "cons": ["disadvantage 1", "disadvantage 2"],
+      "useCase": "When to use this approach"
+    }
+  ],
+  "recommendedIndex": 0,
+  "recommendationReason": "Why this variant is recommended for most cases"
+}`;
+    return prompt;
+}
+/**
+ * Fallback variant when LLM fails
+ */
+function fallbackVariant(context, decomposition) {
+    const variant = {
+        id: generateId(),
+        label: 'A',
+        content: `// Solution for: ${decomposition.summary}
+// 
+// Tasks:
+${decomposition.tasks.map((t) => `// - ${t.description}`).join('\n')}
+//
+// Implementation needed based on the specific requirements.
+// This is a placeholder for the actual solution.
+
+function solution() {
+  // TODO: Implement based on task breakdown
+  throw new Error('Not implemented');
+}
+
+export { solution };`,
+        approach: 'Standard implementation approach',
+        tradeoffs: {
+            pros: ['Straightforward implementation', 'Easy to understand'],
+            cons: ['May need refinement', 'Generic approach'],
+        },
+        useCase: 'General purpose implementation',
+    };
+    return {
+        variants: [variant],
+        recommendedVariantId: variant.id,
+        recommendationReason: 'Single fallback variant generated',
+    };
+}
+// ============================================================================
+// Variant Analysis
+// ============================================================================
+/**
+ * Compare variants and rank them
+ */
+export function rankVariants(variants, criteria) {
+    return variants
+        .map((variant) => ({
+        variant,
+        score: calculateVariantScore(variant, criteria),
+    }))
+        .sort((a, b) => b.score - a.score)
+        .map((item, index) => ({
+        ...item.variant,
+        rank: index + 1,
+        score: item.score,
+    }));
+}
+/**
+ * Calculate score for a variant based on criteria
+ */
+function calculateVariantScore(variant, criteria) {
+    let score = 50; // Base score
+    // Adjust based on pros/cons ratio
+    const prosConsRatio = variant.tradeoffs.pros.length /
+        Math.max(1, variant.tradeoffs.cons.length);
+    score += Math.min(20, prosConsRatio * 10);
+    // Adjust based on code length (simple heuristic)
+    const codeLength = variant.content.length;
+    if (codeLength < 500) {
+        score += criteria.simplicityWeight * 15;
+    }
+    else if (codeLength > 2000) {
+        score -= criteria.simplicityWeight * 10;
+    }
+    // Check for performance keywords
+    const performanceKeywords = ['efficient', 'optimized', 'fast', 'cached', 'lazy'];
+    const hasPerformanceFeatures = performanceKeywords.some((kw) => variant.content.toLowerCase().includes(kw) ||
+        variant.approach.toLowerCase().includes(kw));
+    if (hasPerformanceFeatures) {
+        score += criteria.performanceWeight * 15;
+    }
+    // Check for maintainability indicators
+    const maintainabilityKeywords = ['modular', 'clean', 'documented', 'typed', 'tested'];
+    const hasMaintainabilityFeatures = maintainabilityKeywords.some((kw) => variant.approach.toLowerCase().includes(kw));
+    if (hasMaintainabilityFeatures) {
+        score += criteria.maintainabilityWeight * 15;
+    }
+    return Math.min(100, Math.max(0, score));
+}
+// ============================================================================
+// Variant Diversity
+// ============================================================================
+/**
+ * Ensure variants are sufficiently diverse
+ */
+export function checkVariantDiversity(variants) {
+    if (variants.length < 2) {
+        return {
+            isDiverse: true,
+            similarityScore: 0,
+            suggestions: [],
+        };
+    }
+    // Simple diversity check based on approach descriptions
+    const approaches = variants.map((v) => v.approach.toLowerCase());
+    const uniqueWords = new Set();
+    const allWords = [];
+    for (const approach of approaches) {
+        const words = approach.split(/\s+/).filter((w) => w.length > 3);
+        words.forEach((w) => uniqueWords.add(w));
+        allWords.push(...words);
+    }
+    const diversityRatio = uniqueWords.size / Math.max(1, allWords.length);
+    const isDiverse = diversityRatio > 0.5;
+    const suggestions = [];
+    if (!isDiverse) {
+        suggestions.push('Consider approaches with different paradigms (functional vs OOP)');
+        suggestions.push('Explore trade-offs between simplicity and features');
+        suggestions.push('Consider different libraries or built-in alternatives');
+    }
+    return {
+        isDiverse,
+        similarityScore: 1 - diversityRatio,
+        suggestions,
+    };
+}
+/**
+ * Merge best aspects of multiple variants
+ */
+export function synthesizeBestAspects(variants) {
+    const allPros = variants.flatMap((v) => v.tradeoffs.pros);
+    const allCons = variants.flatMap((v) => v.tradeoffs.cons);
+    // Find unique pros
+    const uniquePros = [...new Set(allPros)];
+    // Find conflicts (aspects that are pros in some variants but cons in others)
+    const conflictingAspects = uniquePros.filter((pro) => allCons.some((con) => con.toLowerCase().includes(pro.toLowerCase().split(' ')[0] ?? '')));
+    const synthesis = `A synthesized solution could combine:
+${uniquePros.slice(0, 5).map((p) => `- ${p}`).join('\n')}
+
+While being mindful of:
+${conflictingAspects.slice(0, 3).map((c) => `- ${c}`).join('\n') || '- No major conflicts identified'}`;
+    return {
+        combinedPros: uniquePros,
+        conflictingAspects,
+        synthesis,
+    };
+}
+//# sourceMappingURL=variants.js.map

package/dist/tools/variants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variants.js","sourceRoot":"","sources":["../../src/tools/variants.ts"],"names":[],"mappings":"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"}