clavix 2.8.2 → 3.0.1

package/dist/core/intelligence/pattern-library.d.ts

@@ -0,0 +1,44 @@
+import { BasePattern } from './patterns/base-pattern.js';
+import { IntentAnalysis, OptimizationMode } from './types.js';
+export declare class PatternLibrary {
+    private patterns;
+    constructor();
+    private registerDefaultPatterns;
+    /**
+     * Register a new pattern
+     */
+    register(pattern: BasePattern): void;
+    /**
+     * Get a specific pattern by ID
+     */
+    get(id: string): BasePattern | undefined;
+    /**
+     * Get applicable patterns for given context (backward compatibility wrapper)
+     * @deprecated Use selectPatterns() method instead
+     */
+    getApplicablePatterns(prompt: string, intent: string, quality: {
+        clarity: number;
+        efficiency: number;
+        structure: number;
+        completeness: number;
+        actionability: number;
+        overall: number;
+    }, mode: OptimizationMode): BasePattern[];
+    /**
+     * Select applicable patterns for the given context
+     */
+    selectPatterns(intent: IntentAnalysis, mode: OptimizationMode): BasePattern[];
+    /**
+     * Get all registered patterns
+     */
+    getAllPatterns(): BasePattern[];
+    /**
+     * Get patterns by mode
+     */
+    getPatternsByMode(mode: OptimizationMode): BasePattern[];
+    /**
+     * Get pattern count
+     */
+    getPatternCount(): number;
+}
+//# sourceMappingURL=pattern-library.d.ts.map

package/dist/core/intelligence/pattern-library.js

@@ -0,0 +1,103 @@
+import { ConcisenessFilter } from './patterns/conciseness-filter.js';
+import { ObjectiveClarifier } from './patterns/objective-clarifier.js';
+import { TechnicalContextEnricher } from './patterns/technical-context-enricher.js';
+import { StructureOrganizer } from './patterns/structure-organizer.js';
+import { CompletenessValidator } from './patterns/completeness-validator.js';
+import { ActionabilityEnhancer } from './patterns/actionability-enhancer.js';
+export class PatternLibrary {
+    patterns = new Map();
+    constructor() {
+        this.registerDefaultPatterns();
+    }
+    registerDefaultPatterns() {
+        // Register core patterns (available in fast & deep modes)
+        this.register(new ConcisenessFilter()); // HIGH - Remove verbosity
+        this.register(new ObjectiveClarifier()); // HIGH - Add clarity
+        this.register(new TechnicalContextEnricher()); // MEDIUM - Add technical details
+        this.register(new StructureOrganizer()); // HIGH - Reorder logically
+        this.register(new CompletenessValidator()); // MEDIUM - Check missing elements
+        this.register(new ActionabilityEnhancer()); // HIGH - Vague to specific
+        // TODO: Register additional patterns for deep mode (future enhancement)
+        // Deep mode exclusive:
+        // - AlternativePhrasingGenerator
+        // - StructureVariationGenerator
+        // - EdgeCaseIdentifier
+        // - ValidationChecklistCreator
+        // - AssumptionExplicitizer
+        // - ScopeDefiner
+        // - StepByStepDecomposer
+        // - TemplatePatternApplier
+        // - ReflectionPrompter
+        // - ContextPrecisionBooster
+    }
+    /**
+     * Register a new pattern
+     */
+    register(pattern) {
+        this.patterns.set(pattern.id, pattern);
+    }
+    /**
+     * Get a specific pattern by ID
+     */
+    get(id) {
+        return this.patterns.get(id);
+    }
+    /**
+     * Get applicable patterns for given context (backward compatibility wrapper)
+     * @deprecated Use selectPatterns() method instead
+     */
+    getApplicablePatterns(prompt, intent, quality, mode) {
+        // Create IntentAnalysis from parameters
+        const intentAnalysis = {
+            primaryIntent: intent,
+            confidence: 100,
+            characteristics: {
+                hasCodeContext: false,
+                hasTechnicalTerms: false,
+                isOpenEnded: false,
+                needsStructure: false
+            }
+        };
+        // Use existing selectPatterns method
+        return this.selectPatterns(intentAnalysis, mode);
+    }
+    /**
+     * Select applicable patterns for the given context
+     */
+    selectPatterns(intent, mode) {
+        const applicablePatterns = [];
+        for (const pattern of this.patterns.values()) {
+            // Check mode compatibility
+            if (pattern.mode !== 'both' && pattern.mode !== mode) {
+                continue;
+            }
+            // Check intent compatibility
+            if (!pattern.applicableIntents.includes(intent.primaryIntent)) {
+                continue;
+            }
+            applicablePatterns.push(pattern);
+        }
+        // Sort by priority (highest first)
+        return applicablePatterns.sort((a, b) => b.priority - a.priority);
+    }
+    /**
+     * Get all registered patterns
+     */
+    getAllPatterns() {
+        return Array.from(this.patterns.values());
+    }
+    /**
+     * Get patterns by mode
+     */
+    getPatternsByMode(mode) {
+        return Array.from(this.patterns.values())
+            .filter(p => p.mode === mode || p.mode === 'both');
+    }
+    /**
+     * Get pattern count
+     */
+    getPatternCount() {
+        return this.patterns.size;
+    }
+}
+//# sourceMappingURL=pattern-library.js.map

package/dist/core/intelligence/patterns/actionability-enhancer.d.ts

@@ -0,0 +1,27 @@
+import { BasePattern } from './base-pattern.js';
+import { PatternContext, PatternResult, PromptIntent } from '../types.js';
+/**
+ * Actionability Enhancer Pattern
+ *
+ * Converts vague goals into specific, actionable tasks.
+ * Replaces abstract language with concrete requirements.
+ *
+ * Priority: HIGH (7)
+ */
+export declare class ActionabilityEnhancer extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: 'fast' | 'deep' | 'both';
+    priority: number;
+    private readonly VAGUE_WORDS;
+    apply(prompt: string, context: PatternContext): PatternResult;
+    private detectVagueWords;
+    private hasAbstractGoals;
+    private replaceVagueWords;
+    private addMeasurableCriteria;
+    private hasSpecificMetric;
+    private concretizeGoals;
+}
+//# sourceMappingURL=actionability-enhancer.d.ts.map

package/dist/core/intelligence/patterns/actionability-enhancer.js

@@ -0,0 +1,162 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * Actionability Enhancer Pattern
+ *
+ * Converts vague goals into specific, actionable tasks.
+ * Replaces abstract language with concrete requirements.
+ *
+ * Priority: HIGH (7)
+ */
+export class ActionabilityEnhancer extends BasePattern {
+    id = 'actionability-enhancer';
+    name = 'Actionability Enhancer';
+    description = 'Converts vague goals into specific, actionable tasks';
+    applicableIntents = ['code-generation', 'planning', 'refinement', 'debugging'];
+    mode = 'both';
+    priority = 7; // High priority
+    VAGUE_WORDS = {
+        'better': ['faster', 'more efficient', 'more reliable', 'more maintainable'],
+        'improve': ['optimize performance', 'enhance user experience', 'increase reliability', 'refactor for clarity'],
+        'good': ['high-performing', 'user-friendly', 'maintainable', 'secure'],
+        'nice': ['polished', 'intuitive', 'responsive', 'accessible'],
+        'fast': ['< 100ms response time', '< 2s load time', 'under 500ms', 'high-performance'],
+        'slow': ['> 2s load time', 'laggy', 'delayed response', 'poor performance'],
+        'something': ['[specify what]', '[component/feature/function]', '[define requirement]'],
+        'somehow': ['[specify method]', '[define approach]', '[explain how]'],
+        'maybe': ['[decide: yes/no]', '[clarify requirement]', '[confirm if needed]'],
+        'enhance': ['add features to', 'improve functionality of', 'extend capabilities of'],
+        'fix': ['resolve bug in', 'correct error in', 'debug issue with'],
+        'update': ['modify', 'change', 'revise', 'upgrade']
+    };
+    apply(prompt, context) {
+        let enhanced = prompt;
+        let changesCount = 0;
+        // Replace vague words with specific alternatives
+        const afterVague = this.replaceVagueWords(enhanced);
+        if (afterVague !== enhanced)
+            changesCount++;
+        enhanced = afterVague;
+        // Add measurable criteria where missing
+        const afterMeasurable = this.addMeasurableCriteria(enhanced);
+        if (afterMeasurable !== enhanced)
+            changesCount++;
+        enhanced = afterMeasurable;
+        // Convert abstract goals to concrete tasks
+        const afterConcrete = this.concretizeGoals(enhanced);
+        if (afterConcrete !== enhanced)
+            changesCount++;
+        enhanced = afterConcrete;
+        return {
+            enhancedPrompt: enhanced,
+            improvement: {
+                dimension: 'actionability',
+                description: `Made ${changesCount} improvements to increase specificity`,
+                impact: changesCount >= 3 ? 'high' : changesCount >= 2 ? 'medium' : 'low'
+            },
+            applied: enhanced !== prompt
+        };
+    }
+    detectVagueWords(prompt) {
+        const found = [];
+        for (const vague of Object.keys(this.VAGUE_WORDS)) {
+            // Match whole words only
+            const regex = new RegExp(`\\b${vague}\\b`, 'gi');
+            if (regex.test(prompt)) {
+                found.push(vague);
+            }
+        }
+        return found;
+    }
+    hasAbstractGoals(prompt) {
+        const abstractPatterns = [
+            /make\s+it\s+\w+/i, // "make it better"
+            /should\s+be\s+\w+/i, // "should be nice"
+            /want\s+it\s+to\s+be\s+\w+/i, // "want it to be good"
+            /more\s+\w+/i, // "more efficient"
+            /less\s+\w+/i // "less complex"
+        ];
+        return abstractPatterns.some(pattern => pattern.test(prompt));
+    }
+    replaceVagueWords(prompt) {
+        let enhanced = prompt;
+        for (const [vague, alternatives] of Object.entries(this.VAGUE_WORDS)) {
+            const regex = new RegExp(`\\b${vague}\\b`, 'gi');
+            if (regex.test(enhanced)) {
+                // For user-facing vague words, add clarifying question
+                if (['something', 'somehow', 'maybe'].includes(vague.toLowerCase())) {
+                    enhanced = enhanced.replace(regex, (match) => {
+                        return `${match} ${alternatives[0]}`;
+                    });
+                }
+                else {
+                    // For quality adjectives, suggest specific alternatives
+                    const suggestion = alternatives[0];
+                    enhanced = enhanced.replace(regex, (match) => {
+                        return `${match} (e.g., ${suggestion})`;
+                    });
+                }
+            }
+        }
+        return enhanced;
+    }
+    addMeasurableCriteria(prompt) {
+        const needsMeasurement = [
+            { pattern: /\bfast(?:er)?\b/gi, suggestion: ' (specify: < 100ms, < 1s, etc.)' },
+            { pattern: /\bslow(?:er)?\b/gi, suggestion: ' (specify: > 2s, > 5s, etc.)' },
+            { pattern: /\befficient\b/gi, suggestion: ' (specify metrics: time, memory, CPU)' },
+            { pattern: /\bscalable\b/gi, suggestion: ' (specify: handle 1K, 10K, 100K users)' },
+            { pattern: /\breliable\b/gi, suggestion: ' (specify: 99.9% uptime, < 0.1% error rate)' },
+            { pattern: /\bsecure\b/gi, suggestion: ' (specify: HTTPS, auth required, encrypted)' }
+        ];
+        let enhanced = prompt;
+        for (const { pattern, suggestion } of needsMeasurement) {
+            if (pattern.test(enhanced)) {
+                // Only add if not already specific
+                if (!this.hasSpecificMetric(enhanced)) {
+                    enhanced = enhanced.replace(pattern, (match) => match + suggestion);
+                }
+            }
+        }
+        return enhanced;
+    }
+    hasSpecificMetric(prompt) {
+        const metricPatterns = [
+            /\d+\s*(?:ms|s|min|hours?)/i, // Time metrics
+            /\d+\s*(?:kb|mb|gb)/i, // Size metrics
+            /\d+\s*(?:%|percent)/i, // Percentage
+            /<?>\s*\d+/i, // Comparison operators
+            /\d+k?\s*(?:users?|requests?)/i // Scale metrics
+        ];
+        return metricPatterns.some(pattern => pattern.test(prompt));
+    }
+    concretizeGoals(prompt) {
+        const abstractPatterns = [
+            {
+                pattern: /make\s+it\s+better/gi,
+                replacement: 'improve by [specify: performance, UX, reliability, etc.]'
+            },
+            {
+                pattern: /should\s+be\s+nice/gi,
+                replacement: 'should have [specify: polished UI, intuitive UX, etc.]'
+            },
+            {
+                pattern: /want\s+it\s+to\s+be\s+good/gi,
+                replacement: 'should meet [specify: quality standards, performance targets, etc.]'
+            },
+            {
+                pattern: /more\s+efficient/gi,
+                replacement: 'more efficient (reduce time/memory/CPU by [X%])'
+            },
+            {
+                pattern: /less\s+complex/gi,
+                replacement: 'less complex (reduce from [X] to [Y] components/lines/dependencies)'
+            }
+        ];
+        let enhanced = prompt;
+        for (const { pattern, replacement } of abstractPatterns) {
+            enhanced = enhanced.replace(pattern, replacement);
+        }
+        return enhanced;
+    }
+}
+//# sourceMappingURL=actionability-enhancer.js.map

package/dist/core/intelligence/patterns/base-pattern.d.ts

@@ -0,0 +1,31 @@
+import { PromptIntent, OptimizationMode, PatternContext, PatternResult } from '../types.js';
+export declare abstract class BasePattern {
+    abstract id: string;
+    abstract name: string;
+    abstract description: string;
+    abstract applicableIntents: PromptIntent[];
+    abstract mode: OptimizationMode | 'both';
+    abstract priority: number;
+    abstract apply(prompt: string, context: PatternContext): PatternResult;
+    /**
+     * Check if this pattern is applicable for the given context
+     */
+    isApplicable(context: PatternContext): boolean;
+    /**
+     * Utility: Remove extra whitespace
+     */
+    protected cleanWhitespace(text: string): string;
+    /**
+     * Utility: Check if prompt has a section
+     */
+    protected hasSection(prompt: string, keywords: string[]): boolean;
+    /**
+     * Utility: Count words
+     */
+    protected countWords(text: string): number;
+    /**
+     * Utility: Extract sentences
+     */
+    protected extractSentences(text: string): string[];
+}
+//# sourceMappingURL=base-pattern.d.ts.map

package/dist/core/intelligence/patterns/base-pattern.js

@@ -0,0 +1,39 @@
+export class BasePattern {
+    /**
+     * Check if this pattern is applicable for the given context
+     */
+    isApplicable(context) {
+        // Check mode compatibility
+        if (this.mode !== 'both' && this.mode !== context.mode) {
+            return false;
+        }
+        // Check intent compatibility
+        return this.applicableIntents.includes(context.intent.primaryIntent);
+    }
+    /**
+     * Utility: Remove extra whitespace
+     */
+    cleanWhitespace(text) {
+        return text.replace(/\s+/g, ' ').trim();
+    }
+    /**
+     * Utility: Check if prompt has a section
+     */
+    hasSection(prompt, keywords) {
+        const lowerPrompt = prompt.toLowerCase();
+        return keywords.some(keyword => lowerPrompt.includes(keyword.toLowerCase()));
+    }
+    /**
+     * Utility: Count words
+     */
+    countWords(text) {
+        return text.split(/\s+/).filter(word => word.length > 0).length;
+    }
+    /**
+     * Utility: Extract sentences
+     */
+    extractSentences(text) {
+        return text.split(/[.!?]+/).filter(s => s.trim().length > 0);
+    }
+}
+//# sourceMappingURL=base-pattern.js.map

package/dist/core/intelligence/patterns/completeness-validator.d.ts

@@ -0,0 +1,27 @@
+import { BasePattern } from './base-pattern.js';
+import { PatternContext, PatternResult, PromptIntent } from '../types.js';
+/**
+ * Completeness Validator Pattern
+ *
+ * Ensures all necessary requirements are present.
+ * Adds placeholder sections for missing critical elements.
+ *
+ * Priority: MEDIUM (6)
+ */
+export declare class CompletenessValidator extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: 'fast' | 'deep' | 'both';
+    priority: number;
+    apply(prompt: string, context: PatternContext): PatternResult;
+    private findMissingElements;
+    private hasObjective;
+    private hasTechStack;
+    private hasSuccessCriteria;
+    private hasConstraints;
+    private hasOutputFormat;
+    private getMissingElementPrompt;
+}
+//# sourceMappingURL=completeness-validator.d.ts.map

package/dist/core/intelligence/patterns/completeness-validator.js

@@ -0,0 +1,135 @@
+import { BasePattern } from './base-pattern.js';
+/**
+ * Completeness Validator Pattern
+ *
+ * Ensures all necessary requirements are present.
+ * Adds placeholder sections for missing critical elements.
+ *
+ * Priority: MEDIUM (6)
+ */
+export class CompletenessValidator extends BasePattern {
+    id = 'completeness-validator';
+    name = 'Completeness Validator';
+    description = 'Ensures all necessary requirements are present';
+    applicableIntents = ['code-generation', 'planning', 'refinement'];
+    mode = 'both';
+    priority = 6; // Medium priority
+    apply(prompt, context) {
+        const missing = this.findMissingElements(prompt);
+        if (missing.length === 0) {
+            return {
+                enhancedPrompt: prompt,
+                improvement: {
+                    dimension: 'completeness',
+                    description: 'All required elements present',
+                    impact: 'low'
+                },
+                applied: false
+            };
+        }
+        // Calculate completeness score
+        const totalElements = 5;
+        const presentElements = totalElements - missing.length;
+        const score = Math.round((presentElements / totalElements) * 100);
+        let enhanced = prompt + '\n\n';
+        // Add missing elements section
+        enhanced += '---\n\n';
+        enhanced += `**Completeness Check**: ${score}% (${presentElements}/${totalElements} elements present)\n\n`;
+        enhanced += '**Missing Information** (please specify):\n\n';
+        for (const element of missing) {
+            enhanced += this.getMissingElementPrompt(element) + '\n';
+        }
+        const result = enhanced.trim();
+        return {
+            enhancedPrompt: result,
+            improvement: {
+                dimension: 'completeness',
+                description: `Added ${missing.length} missing element prompts (${score}% complete)`,
+                impact: missing.length >= 3 ? 'high' : missing.length >= 2 ? 'medium' : 'low'
+            },
+            applied: true
+        };
+    }
+    findMissingElements(prompt) {
+        const missing = [];
+        const lowerPrompt = prompt.toLowerCase();
+        // Check for objective/goal
+        if (!this.hasObjective(lowerPrompt)) {
+            missing.push('objective');
+        }
+        // Check for tech stack
+        if (!this.hasTechStack(lowerPrompt)) {
+            missing.push('tech-stack');
+        }
+        // Check for success criteria
+        if (!this.hasSuccessCriteria(lowerPrompt)) {
+            missing.push('success-criteria');
+        }
+        // Check for constraints
+        if (!this.hasConstraints(lowerPrompt)) {
+            missing.push('constraints');
+        }
+        // Check for output format
+        if (!this.hasOutputFormat(lowerPrompt)) {
+            missing.push('output-format');
+        }
+        return missing;
+    }
+    hasObjective(prompt) {
+        const objectivePatterns = [
+            'objective', 'goal', 'purpose', 'need to', 'want to',
+            'trying to', 'aim', 'intend'
+        ];
+        return objectivePatterns.some(pattern => prompt.includes(pattern));
+    }
+    hasTechStack(prompt) {
+        const techPatterns = [
+            // Languages
+            'javascript', 'typescript', 'python', 'java', 'rust', 'go',
+            'php', 'ruby', 'swift', 'kotlin', 'c++', 'c#',
+            // Frameworks
+            'react', 'vue', 'angular', 'svelte', 'next', 'nuxt',
+            'express', 'fastapi', 'django', 'flask', 'spring', 'rails',
+            // Databases
+            'postgres', 'mysql', 'mongodb', 'redis', 'sqlite',
+            // Tools
+            'docker', 'kubernetes', 'aws', 'azure', 'gcp',
+            // Generic
+            'tech stack', 'technology', 'framework', 'library', 'using', 'built with'
+        ];
+        return techPatterns.some(pattern => prompt.includes(pattern));
+    }
+    hasSuccessCriteria(prompt) {
+        const successPatterns = [
+            'success', 'criteria', 'measure', 'metric', 'kpi',
+            'should work', 'expected to', 'result in', 'achieve'
+        ];
+        return successPatterns.some(pattern => prompt.includes(pattern));
+    }
+    hasConstraints(prompt) {
+        const constraintPatterns = [
+            'constraint', 'limit', 'limitation', 'must not', 'cannot',
+            'should not', 'avoid', 'within', 'budget', 'time', 'deadline'
+        ];
+        return constraintPatterns.some(pattern => prompt.includes(pattern));
+    }
+    hasOutputFormat(prompt) {
+        const outputPatterns = [
+            'output', 'format', 'return', 'result', 'deliverable',
+            'component', 'function', 'class', 'api', 'endpoint',
+            'file', 'document', 'report'
+        ];
+        return outputPatterns.some(pattern => prompt.includes(pattern));
+    }
+    getMissingElementPrompt(element) {
+        const prompts = {
+            'objective': '- **Objective**: What is the primary goal? What problem are you solving?',
+            'tech-stack': '- **Tech Stack**: Which technologies/frameworks? (e.g., React, Node.js, PostgreSQL)',
+            'success-criteria': '- **Success Criteria**: How will you know it works? What metrics matter?',
+            'constraints': '- **Constraints**: Any limitations? (time, budget, performance, compatibility)',
+            'output-format': '- **Expected Output**: What should the result look like? (component, API, file, etc.)'
+        };
+        return prompts[element] || `- **${element}**: Please specify`;
+    }
+}
+//# sourceMappingURL=completeness-validator.js.map

package/dist/core/intelligence/patterns/conciseness-filter.d.ts

@@ -0,0 +1,12 @@
+import { BasePattern } from './base-pattern.js';
+import { PatternContext, PatternResult, PromptIntent } from '../types.js';
+export declare class ConcisenessFilter extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: 'fast' | 'deep' | 'both';
+    priority: number;
+    apply(prompt: string, context: PatternContext): PatternResult;
+}
+//# sourceMappingURL=conciseness-filter.d.ts.map

package/dist/core/intelligence/patterns/conciseness-filter.js

@@ -0,0 +1,61 @@
+import { BasePattern } from './base-pattern.js';
+export class ConcisenessFilter extends BasePattern {
+    id = 'conciseness-filter';
+    name = 'Conciseness Filter';
+    description = 'Removes unnecessary pleasantries, fluff words, and redundancy';
+    applicableIntents = ['code-generation', 'planning', 'refinement', 'debugging', 'documentation'];
+    mode = 'both';
+    priority = 10; // High priority - run early
+    apply(prompt, context) {
+        let cleaned = prompt;
+        let changesCount = 0;
+        // Remove pleasantries at start
+        const pleasantries = [
+            /^(please|could you|would you mind|I would appreciate if you could|kindly)\s+/gi,
+            /thank you/gi,
+            /thanks in advance/gi,
+            /I appreciate your help/gi
+        ];
+        for (const pattern of pleasantries) {
+            const before = cleaned;
+            cleaned = cleaned.replace(pattern, '');
+            if (before !== cleaned)
+                changesCount++;
+        }
+        // Remove fluff words
+        const fluffWords = ['very', 'really', 'just', 'basically', 'simply', 'actually', 'literally'];
+        for (const word of fluffWords) {
+            const regex = new RegExp(`\\b${word}\\b`, 'gi');
+            const before = cleaned;
+            cleaned = cleaned.replace(regex, '');
+            if (before !== cleaned)
+                changesCount++;
+        }
+        // Remove redundant phrases
+        const redundantPhrases = [
+            /in order to/gi, // Replace with "to"
+            /at this point in time/gi, // Replace with "now"
+            /due to the fact that/gi, // Replace with "because"
+            /for the purpose of/gi, // Replace with "for"
+            /in the event that/gi // Replace with "if"
+        ];
+        cleaned = cleaned.replace(/in order to/gi, 'to');
+        cleaned = cleaned.replace(/at this point in time/gi, 'now');
+        cleaned = cleaned.replace(/due to the fact that/gi, 'because');
+        cleaned = cleaned.replace(/for the purpose of/gi, 'for');
+        cleaned = cleaned.replace(/in the event that/gi, 'if');
+        // Clean up extra whitespace
+        cleaned = this.cleanWhitespace(cleaned);
+        const applied = changesCount > 0 || cleaned !== prompt;
+        return {
+            enhancedPrompt: cleaned,
+            improvement: {
+                dimension: 'efficiency',
+                description: `Removed ${changesCount} unnecessary phrases for conciseness`,
+                impact: changesCount > 3 ? 'high' : changesCount > 1 ? 'medium' : 'low'
+            },
+            applied
+        };
+    }
+}
+//# sourceMappingURL=conciseness-filter.js.map

package/dist/core/intelligence/patterns/objective-clarifier.d.ts

@@ -0,0 +1,14 @@
+import { BasePattern } from './base-pattern.js';
+import { PatternContext, PatternResult, PromptIntent } from '../types.js';
+export declare class ObjectiveClarifier extends BasePattern {
+    id: string;
+    name: string;
+    description: string;
+    applicableIntents: PromptIntent[];
+    mode: 'fast' | 'deep' | 'both';
+    priority: number;
+    apply(prompt: string, context: PatternContext): PatternResult;
+    private hasExplicitObjective;
+    private extractObjective;
+}
+//# sourceMappingURL=objective-clarifier.d.ts.map