clavix 4.11.2 → 5.0.0

package/dist/core/intelligence/patterns/assumption-explicitizer.js

@@ -1,296 +0,0 @@
-import { BasePattern, } from './base-pattern.js';
-/**
- * v4.5 Pattern: Assumption Explicitizer
- *
- * Makes implicit assumptions explicit to prevent misunderstandings
- * and ensure comprehensive requirement coverage.
- */
-export class AssumptionExplicitizer extends BasePattern {
-    // -------------------------------------------------------------------------
-    // Pattern Metadata (v4.5 unified types)
-    // -------------------------------------------------------------------------
-    id = 'assumption-explicitizer';
-    name = 'Assumption Explicitizer';
-    description = 'Make implicit assumptions explicit to prevent misunderstandings';
-    applicableIntents = [
-        'code-generation',
-        'planning',
-        'migration',
-        'testing',
-        'debugging',
-        'prd-generation',
-    ];
-    scope = 'comprehensive';
-    priority = 6; // MEDIUM - standard enhancement
-    phases = ['all'];
-    // -------------------------------------------------------------------------
-    // Configuration Schema (v4.5)
-    // -------------------------------------------------------------------------
-    static configSchema = {
-        maxAssumptions: {
-            type: 'number',
-            default: 8,
-            description: 'Maximum number of assumptions to surface',
-            validation: { min: 1, max: 15 },
-        },
-        checkDomainAssumptions: {
-            type: 'boolean',
-            default: true,
-            description: 'Check for domain-specific assumptions (auth, API style, etc.)',
-        },
-    };
-    // -------------------------------------------------------------------------
-    // Pattern Application
-    // -------------------------------------------------------------------------
-    apply(prompt, context) {
-        const assumptions = this.identifyAssumptions(prompt, context.intent.primaryIntent);
-        if (assumptions.length === 0) {
-            return {
-                enhancedPrompt: prompt,
-                improvement: {
-                    dimension: 'clarity',
-                    description: 'No implicit assumptions detected',
-                    impact: 'low',
-                },
-                applied: false,
-            };
-        }
-        // Append assumptions section to the prompt
-        const assumptionsSection = this.formatAssumptionsSection(assumptions);
-        const enhancedPrompt = `${prompt}\n\n${assumptionsSection}`;
-        return {
-            enhancedPrompt,
-            improvement: {
-                dimension: 'clarity',
-                description: `Identified ${assumptions.length} implicit assumptions to clarify`,
-                impact: 'high',
-            },
-            applied: true,
-        };
-    }
-    identifyAssumptions(prompt, intent) {
-        const assumptions = [];
-        const lowerPrompt = prompt.toLowerCase();
-        // Check for missing context that leads to assumptions
-        assumptions.push(...this.identifyMissingContext(lowerPrompt));
-        // Intent-specific assumptions
-        switch (intent) {
-            case 'code-generation':
-                assumptions.push(...this.getCodeAssumptions(lowerPrompt));
-                break;
-            case 'planning':
-                assumptions.push(...this.getPlanningAssumptions(lowerPrompt));
-                break;
-            case 'migration':
-                assumptions.push(...this.getMigrationAssumptions(lowerPrompt));
-                break;
-            case 'testing':
-                assumptions.push(...this.getTestingAssumptions(lowerPrompt));
-                break;
-            case 'debugging':
-                assumptions.push(...this.getDebuggingAssumptions(lowerPrompt));
-                break;
-        }
-        // Domain-specific assumptions
-        assumptions.push(...this.getDomainAssumptions(lowerPrompt));
-        return this.deduplicateAssumptions(assumptions).slice(0, 8);
-    }
-    identifyMissingContext(prompt) {
-        const assumptions = [];
-        // Check for vague technology references
-        if (!this.hasSection(prompt, ['react', 'vue', 'angular', 'svelte', 'next', 'nuxt'])) {
-            if (this.hasSection(prompt, ['component', 'frontend', 'ui'])) {
-                assumptions.push({
-                    assumption: 'Frontend framework is React',
-                    clarificationNeeded: 'Which frontend framework should be used? (React, Vue, Angular, etc.)',
-                });
-            }
-        }
-        // Check for missing language specification
-        if (!this.hasSection(prompt, ['typescript', 'javascript', 'python', 'java', 'go', 'rust'])) {
-            if (this.hasSection(prompt, ['function', 'class', 'code', 'implement'])) {
-                assumptions.push({
-                    assumption: 'Language is TypeScript/JavaScript',
-                    clarificationNeeded: 'Which programming language should be used?',
-                });
-            }
-        }
-        // Check for missing database type
-        if (!this.hasSection(prompt, ['postgres', 'mysql', 'mongodb', 'sqlite', 'redis'])) {
-            if (this.hasSection(prompt, ['database', 'store', 'persist', 'save'])) {
-                assumptions.push({
-                    assumption: 'Database type is flexible',
-                    clarificationNeeded: 'Which database technology is being used?',
-                });
-            }
-        }
-        return assumptions;
-    }
-    getCodeAssumptions(prompt) {
-        const assumptions = [];
-        // Error handling assumption
-        if (!this.hasSection(prompt, ['error', 'exception', 'catch', 'handle'])) {
-            assumptions.push({
-                assumption: 'Basic error handling is expected',
-                clarificationNeeded: 'What error handling strategy should be used? (throw, return null, default value, etc.)',
-            });
-        }
-        // Async assumption
-        if (this.hasSection(prompt, ['api', 'fetch', 'request', 'call'])) {
-            if (!this.hasSection(prompt, ['async', 'await', 'promise', 'callback'])) {
-                assumptions.push({
-                    assumption: 'Using async/await pattern',
-                    clarificationNeeded: 'Should this be synchronous or asynchronous?',
-                });
-            }
-        }
-        // State management assumption
-        if (this.hasSection(prompt, ['state', 'store', 'context'])) {
-            if (!this.hasSection(prompt, ['redux', 'zustand', 'mobx', 'context api'])) {
-                assumptions.push({
-                    assumption: 'Using React Context or local state',
-                    clarificationNeeded: 'Which state management approach is preferred?',
-                });
-            }
-        }
-        return assumptions;
-    }
-    getPlanningAssumptions(prompt) {
-        const assumptions = [];
-        // Team size assumption
-        if (!this.hasSection(prompt, ['team', 'developer', 'person'])) {
-            assumptions.push({
-                assumption: 'Small team (1-3 developers)',
-                clarificationNeeded: 'How many people will work on this?',
-            });
-        }
-        // Timeline assumption
-        if (!this.hasSection(prompt, ['deadline', 'timeline', 'sprint', 'week', 'month'])) {
-            assumptions.push({
-                assumption: 'Flexible timeline',
-                clarificationNeeded: 'What are the timeline constraints?',
-            });
-        }
-        // Scale assumption
-        if (!this.hasSection(prompt, ['users', 'traffic', 'scale', 'load'])) {
-            assumptions.push({
-                assumption: 'Starting with low-moderate scale',
-                clarificationNeeded: 'What is the expected scale (users, requests/sec)?',
-            });
-        }
-        return assumptions;
-    }
-    getMigrationAssumptions(prompt) {
-        const assumptions = [];
-        // Downtime assumption
-        if (!this.hasSection(prompt, ['downtime', 'zero-downtime', 'maintenance'])) {
-            assumptions.push({
-                assumption: 'Some downtime is acceptable',
-                clarificationNeeded: 'Is zero-downtime migration required?',
-            });
-        }
-        // Rollback assumption
-        if (!this.hasSection(prompt, ['rollback', 'revert', 'backup'])) {
-            assumptions.push({
-                assumption: 'Rollback capability is needed',
-                clarificationNeeded: 'What is the rollback strategy if migration fails?',
-            });
-        }
-        // Data preservation assumption
-        assumptions.push({
-            assumption: 'All existing data must be preserved',
-            clarificationNeeded: 'Can any data be discarded or archived during migration?',
-        });
-        return assumptions;
-    }
-    getTestingAssumptions(prompt) {
-        const assumptions = [];
-        // Test framework assumption
-        if (!this.hasSection(prompt, ['jest', 'vitest', 'mocha', 'pytest', 'junit'])) {
-            assumptions.push({
-                assumption: "Using project's existing test framework",
-                clarificationNeeded: 'Which test framework should be used?',
-            });
-        }
-        // Coverage assumption
-        if (!this.hasSection(prompt, ['coverage', 'percent', '%'])) {
-            assumptions.push({
-                assumption: 'Standard coverage target (80%+)',
-                clarificationNeeded: 'What is the target code coverage percentage?',
-            });
-        }
-        // Mocking assumption
-        if (!this.hasSection(prompt, ['mock', 'stub', 'fake', 'spy'])) {
-            assumptions.push({
-                assumption: 'External dependencies should be mocked',
-                clarificationNeeded: 'Should tests use real dependencies or mocks?',
-            });
-        }
-        return assumptions;
-    }
-    getDebuggingAssumptions(prompt) {
-        const assumptions = [];
-        // Environment assumption
-        if (!this.hasSection(prompt, ['production', 'staging', 'development', 'local'])) {
-            assumptions.push({
-                assumption: 'Bug occurs in development environment',
-                clarificationNeeded: 'In which environment does this bug occur?',
-            });
-        }
-        // Reproducibility assumption
-        if (!this.hasSection(prompt, ['always', 'sometimes', 'intermittent', 'random'])) {
-            assumptions.push({
-                assumption: 'Bug is consistently reproducible',
-                clarificationNeeded: 'Does this bug occur every time or intermittently?',
-            });
-        }
-        return assumptions;
-    }
-    getDomainAssumptions(prompt) {
-        const assumptions = [];
-        // Authentication assumption
-        if (this.hasSection(prompt, ['user', 'login', 'auth'])) {
-            if (!this.hasSection(prompt, ['jwt', 'session', 'oauth', 'cookie'])) {
-                assumptions.push({
-                    assumption: 'Using JWT-based authentication',
-                    clarificationNeeded: 'Which authentication mechanism is in use?',
-                });
-            }
-        }
-        // API style assumption
-        if (this.hasSection(prompt, ['api', 'endpoint'])) {
-            if (!this.hasSection(prompt, ['rest', 'graphql', 'grpc', 'websocket'])) {
-                assumptions.push({
-                    assumption: 'Building REST API',
-                    clarificationNeeded: 'Which API style? (REST, GraphQL, gRPC, etc.)',
-                });
-            }
-        }
-        return assumptions;
-    }
-    deduplicateAssumptions(assumptions) {
-        const seen = new Set();
-        return assumptions.filter((a) => {
-            const key = a.assumption.toLowerCase();
-            if (seen.has(key))
-                return false;
-            seen.add(key);
-            return true;
-        });
-    }
-    formatAssumptionsSection(assumptions) {
-        const lines = [
-            '### Implicit Assumptions',
-            '',
-            'The following assumptions are being made. Please clarify if any are incorrect:',
-            '',
-        ];
-        assumptions.forEach((a, index) => {
-            lines.push(`**${index + 1}. ${a.assumption}**`);
-            lines.push(`   → Clarify: ${a.clarificationNeeded}`);
-            lines.push('');
-        });
-        return lines.join('\n');
-    }
-}
-//# sourceMappingURL=assumption-explicitizer.js.map

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

@@ -1,192 +0,0 @@
-import { PromptIntent, PatternContext, PatternResult } from '../types.js';
-/**
- * v4.11: Pattern scope determines when a pattern is active.
- * - 'standard': Only for standard depth optimization
- * - 'comprehensive': Only for comprehensive depth analysis
- * - 'both': Available at both depth levels
- *
- * Note: Renamed from PatternMode in v4.11. 'fast' → 'standard', 'deep' → 'comprehensive'
- */
-export type PatternScope = 'standard' | 'comprehensive' | 'both';
-export type PatternMode = PatternScope;
-/**
- * Pattern phases for PRD and Conversational modes.
- * Patterns declare which phases they apply to.
- *
- * - 'question-validation': PRD mode - validating individual answers
- * - 'output-generation': PRD mode - generating final PRD documents
- * - 'conversation-tracking': Conversational mode - analyzing messages in real-time
- * - 'summarization': Conversational mode - extracting requirements from conversation
- * - 'all': Pattern applies to all phases (default for basic patterns)
- */
-export type PatternPhase = 'question-validation' | 'output-generation' | 'conversation-tracking' | 'summarization' | 'all';
-/**
- * Pattern Priority Scale (1-10)
- *
- * Higher priority patterns run FIRST (sorted descending).
- *
- * 10: CRITICAL - Must run before everything else
- *     Use case: Mode detection, fundamental structure validation
- *
- * 9:  VERY HIGH - Structural integrity
- *     Use case: Ambiguity detection, completeness validation, PRD structure
- *
- * 8:  HIGH - Core enhancement
- *     Use case: Objective clarification, structure organization, summarization
- *
- * 7:  MEDIUM-HIGH - Important enrichment
- *     Use case: Output format, success criteria, requirement prioritization
- *
- * 6:  MEDIUM - Standard enhancement
- *     Use case: Context enrichment, topic coherence, user personas
- *
- * 5:  MEDIUM-LOW - Supplementary
- *     Use case: Step decomposition, technical context, implicit requirements
- *
- * 4:  LOW - Polish
- *     Use case: Conciseness filtering, actionability enhancement
- *
- * 3:  VERY LOW - Final touches
- *     Use case: Phrasing alternatives, edge cases, validation checklists
- *
- * 2:  MINIMAL - Only if nothing else applies
- *     Use case: Reserved for future
- *
- * 1:  LOWEST - Last resort
- *     Use case: Reserved for future
- *
- * Collision Resolution: When priorities are equal, patterns run
- * in registration order (first registered runs first).
- */
-export type PatternPriority = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
-/**
- * Pattern dependency configuration.
- * Allows patterns to express execution order constraints.
- */
-export interface PatternDependency {
-    /**
-     * Patterns that must run before this one.
-     * Uses pattern IDs.
-     */
-    runAfter?: string[];
-    /**
-     * Patterns that are mutually exclusive with this one.
-     * If one runs, the other won't.
-     */
-    excludesWith?: string[];
-    /**
-     * Patterns that enhance this one when both run.
-     * Informational only, no enforcement.
-     */
-    enhancedBy?: string[];
-}
-/**
- * Schema field types for pattern configuration
- */
-export type PatternConfigFieldType = 'string' | 'number' | 'boolean' | 'array' | 'enum';
-/**
- * Single field in a pattern's configuration schema
- */
-export interface PatternConfigField {
-    type: PatternConfigFieldType;
-    default: unknown;
-    description: string;
-    validation?: {
-        min?: number;
-        max?: number;
-        enum?: string[];
-        minLength?: number;
-        maxLength?: number;
-    };
-}
-/**
- * Configuration schema for a pattern.
- * Each pattern declares its configurable options.
- * Empty object `{}` means no configuration available.
- */
-export interface PatternConfigSchema {
-    [fieldName: string]: PatternConfigField;
-}
-/**
- * Interface for PatternLibrary to avoid circular dependency.
- * Used by patterns to access their configuration.
- */
-export interface IPatternLibrary {
-    getPatternSettings(patternId: string): Record<string, unknown> | undefined;
-}
-export declare abstract class BasePattern {
-    /** Unique identifier for this pattern (e.g., 'conciseness-filter') */
-    abstract readonly id: string;
-    /** Human-readable name (e.g., 'Conciseness Filter') */
-    abstract readonly name: string;
-    /** Brief description of what this pattern does */
-    abstract readonly description: string;
-    /** Which intents this pattern is applicable to */
-    abstract readonly applicableIntents: PromptIntent[];
-    /** Which depth level(s) this pattern runs at (v4.11: renamed from mode) */
-    abstract readonly scope: PatternScope;
-    /** Execution priority (1-10, higher runs first) */
-    abstract readonly priority: PatternPriority;
-    /** Which phases this pattern applies to (PRD/conversational modes) */
-    abstract readonly phases: PatternPhase[];
-    /** Optional dependency configuration */
-    readonly dependencies?: PatternDependency;
-    /**
-     * Configuration schema for this pattern.
-     * Override in subclass to define configurable options.
-     * Empty object means no configuration available.
-     */
-    static readonly configSchema: PatternConfigSchema;
-    /**
-     * Reference to pattern library for accessing configuration.
-     * Injected by PatternLibrary on registration.
-     */
-    private patternLibraryRef?;
-    /**
-     * Inject PatternLibrary reference for config access.
-     * Called by PatternLibrary during registration.
-     */
-    setPatternLibrary(library: IPatternLibrary): void;
-    /**
-     * Get settings for this pattern with defaults applied.
-     * Use in apply() method to access user configuration.
-     *
-     * @example
-     * ```typescript
-     * apply(prompt: string, context: PatternContext): PatternResult {
-     *   const settings = this.getSettings();
-     *   if (fluffCount > settings.fluffThreshold) {
-     *     // ...
-     *   }
-     * }
-     * ```
-     */
-    protected getSettings(): Record<string, unknown>;
-    /**
-     * Apply this pattern to the given prompt.
-     * Must be implemented by all concrete patterns.
-     */
-    abstract apply(prompt: string, context: PatternContext): PatternResult;
-    /**
-     * Check if this pattern is applicable for the given context.
-     * Can be overridden for custom applicability logic.
-     */
-    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

@@ -1,103 +0,0 @@
-// ============================================================================
-// Base Pattern Abstract Class
-// ============================================================================
-export class BasePattern {
-    // -------------------------------------------------------------------------
-    // Optional Pattern Metadata
-    // -------------------------------------------------------------------------
-    /** Optional dependency configuration */
-    dependencies;
-    // -------------------------------------------------------------------------
-    // Configuration Support (v4.5)
-    // -------------------------------------------------------------------------
-    /**
-     * Configuration schema for this pattern.
-     * Override in subclass to define configurable options.
-     * Empty object means no configuration available.
-     */
-    static configSchema = {};
-    /**
-     * Reference to pattern library for accessing configuration.
-     * Injected by PatternLibrary on registration.
-     */
-    patternLibraryRef;
-    /**
-     * Inject PatternLibrary reference for config access.
-     * Called by PatternLibrary during registration.
-     */
-    setPatternLibrary(library) {
-        this.patternLibraryRef = library;
-    }
-    /**
-     * Get settings for this pattern with defaults applied.
-     * Use in apply() method to access user configuration.
-     *
-     * @example
-     * ```typescript
-     * apply(prompt: string, context: PatternContext): PatternResult {
-     *   const settings = this.getSettings();
-     *   if (fluffCount > settings.fluffThreshold) {
-     *     // ...
-     *   }
-     * }
-     * ```
-     */
-    getSettings() {
-        // Get the static configSchema from the concrete class
-        const ConcreteClass = this.constructor;
-        const schema = ConcreteClass.configSchema;
-        // Build defaults from schema
-        const defaults = {};
-        for (const [key, field] of Object.entries(schema)) {
-            defaults[key] = field.default;
-        }
-        // Merge with user config (user config overrides defaults)
-        const userConfig = this.patternLibraryRef?.getPatternSettings(this.id) || {};
-        return { ...defaults, ...userConfig };
-    }
-    /**
-     * Check if this pattern is applicable for the given context.
-     * Can be overridden for custom applicability logic.
-     */
-    isApplicable(context) {
-        // v4.11: Check scope compatibility with depth level
-        // For improve mode, compare scope with depthLevel
-        // For prd/conversational modes, use the derived depth from phase
-        if (context.depthLevel) {
-            if (this.scope !== 'both' && this.scope !== context.depthLevel) {
-                return false;
-            }
-        }
-        // Check intent compatibility
-        return this.applicableIntents.includes(context.intent.primaryIntent);
-    }
-    // -------------------------------------------------------------------------
-    // Utility Methods
-    // -------------------------------------------------------------------------
-    /**
-     * 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

@@ -1,27 +0,0 @@
-import { BasePattern, PatternScope, PatternPriority, PatternPhase, PatternConfigSchema } from './base-pattern.js';
-import { PatternContext, PatternResult, PromptIntent } from '../types.js';
-/**
- * v4.5 Pattern: Completeness Validator
- *
- * Ensures all necessary requirements are present.
- * Adds placeholder sections for missing critical elements.
- */
-export declare class CompletenessValidator extends BasePattern {
-    readonly id = "completeness-validator";
-    readonly name = "Completeness Validator";
-    readonly description = "Ensures all necessary requirements are present";
-    readonly applicableIntents: PromptIntent[];
-    readonly scope: PatternScope;
-    readonly priority: PatternPriority;
-    readonly phases: PatternPhase[];
-    static readonly configSchema: PatternConfigSchema;
-    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