clavix 4.12.0 → 5.0.1

package/dist/core/conversation-analyzer.js

@@ -1,387 +0,0 @@
-/**
- * ConversationAnalyzer - Analyzes conversation sessions and extracts structured requirements
- *
- * This class handles:
- * - Conversation analysis and pattern extraction
- * - Key requirement identification
- * - Technical constraint extraction
- * - Success criteria identification
- * - Mini-PRD and optimized prompt generation
- */
-/**
- * ConversationAnalyzer class
- *
- * Analyzes conversational sessions to extract structured requirements
- * suitable for PRD generation or AI prompting
- */
-export class ConversationAnalyzer {
-    /**
-     * Analyze a conversation session
-     *
-     * @param session - The session to analyze
-     * @returns Structured analysis of the conversation
-     */
-    analyze(session) {
-        const userMessages = session.messages
-            .filter((m) => m.role === 'user')
-            .map((m) => m.content);
-        return {
-            summary: this.extractSummary(userMessages, session.projectName),
-            keyRequirements: this.extractKeyRequirements(userMessages),
-            technicalConstraints: this.extractTechnicalConstraints(userMessages),
-            successCriteria: this.extractSuccessCriteria(userMessages),
-            outOfScope: this.extractOutOfScope(userMessages),
-            additionalContext: this.extractAdditionalContext(userMessages),
-        };
-    }
-    /**
-     * Generate a mini-PRD from analyzed conversation
-     *
-     * @param session - The session
-     * @param analysis - The conversation analysis
-     * @returns Mini-PRD content
-     */
-    generateMiniPrd(session, analysis) {
-        const lines = [];
-        lines.push(`# Mini-PRD: ${session.projectName}`);
-        lines.push('');
-        lines.push(`*Generated from conversation session ${session.id}*`);
-        lines.push('');
-        lines.push('---');
-        lines.push('');
-        // Summary
-        lines.push('## Summary');
-        lines.push('');
-        lines.push(analysis.summary);
-        lines.push('');
-        // Key Requirements
-        if (analysis.keyRequirements.length > 0) {
-            lines.push('## Key Requirements');
-            lines.push('');
-            analysis.keyRequirements.forEach((req) => {
-                lines.push(`- ${req}`);
-            });
-            lines.push('');
-        }
-        // Technical Constraints
-        if (analysis.technicalConstraints.length > 0) {
-            lines.push('## Technical Constraints');
-            lines.push('');
-            analysis.technicalConstraints.forEach((constraint) => {
-                lines.push(`- ${constraint}`);
-            });
-            lines.push('');
-        }
-        // Success Criteria
-        if (analysis.successCriteria.length > 0) {
-            lines.push('## Success Criteria');
-            lines.push('');
-            analysis.successCriteria.forEach((criteria) => {
-                lines.push(`- ${criteria}`);
-            });
-            lines.push('');
-        }
-        // Out of Scope
-        if (analysis.outOfScope.length > 0) {
-            lines.push('## Out of Scope');
-            lines.push('');
-            analysis.outOfScope.forEach((item) => {
-                lines.push(`- ${item}`);
-            });
-            lines.push('');
-        }
-        // Additional Context
-        if (analysis.additionalContext.length > 0) {
-            lines.push('## Additional Context');
-            lines.push('');
-            analysis.additionalContext.forEach((context) => {
-                lines.push(`- ${context}`);
-            });
-            lines.push('');
-        }
-        // Metadata
-        lines.push('---');
-        lines.push('');
-        lines.push('**Conversation Details:**');
-        lines.push(`- Session ID: ${session.id}`);
-        lines.push(`- Messages: ${session.messages.length}`);
-        lines.push(`- Created: ${session.created.toLocaleString()}`);
-        lines.push(`- Updated: ${session.updated.toLocaleString()}`);
-        lines.push('');
-        return lines.join('\n');
-    }
-    /**
-     * Generate an optimized prompt for AI consumption
-     *
-     * @param session - The session
-     * @param analysis - The conversation analysis
-     * @returns Optimized prompt content
-     */
-    generateOptimizedPrompt(session, analysis) {
-        const lines = [];
-        lines.push(`# Development Task: ${session.projectName}`);
-        lines.push('');
-        lines.push('## Objective');
-        lines.push('');
-        lines.push(analysis.summary);
-        lines.push('');
-        // Core Requirements
-        if (analysis.keyRequirements.length > 0) {
-            lines.push('## Core Requirements');
-            lines.push('');
-            lines.push('Please implement the following:');
-            lines.push('');
-            analysis.keyRequirements.forEach((req, index) => {
-                lines.push(`${index + 1}. ${req}`);
-            });
-            lines.push('');
-        }
-        // Technical Constraints
-        if (analysis.technicalConstraints.length > 0) {
-            lines.push('## Technical Constraints');
-            lines.push('');
-            lines.push('Ensure the implementation adheres to these constraints:');
-            lines.push('');
-            analysis.technicalConstraints.forEach((constraint) => {
-                lines.push(`- ${constraint}`);
-            });
-            lines.push('');
-        }
-        // Success Criteria
-        if (analysis.successCriteria.length > 0) {
-            lines.push('## Success Criteria');
-            lines.push('');
-            lines.push('The implementation is complete when:');
-            lines.push('');
-            analysis.successCriteria.forEach((criteria) => {
-                lines.push(`- [ ] ${criteria}`);
-            });
-            lines.push('');
-        }
-        // Out of Scope
-        if (analysis.outOfScope.length > 0) {
-            lines.push('## Explicitly Out of Scope');
-            lines.push('');
-            lines.push('Do NOT implement:');
-            lines.push('');
-            analysis.outOfScope.forEach((item) => {
-                lines.push(`- ${item}`);
-            });
-            lines.push('');
-        }
-        // Additional Context
-        if (analysis.additionalContext.length > 0) {
-            lines.push('## Additional Context');
-            lines.push('');
-            analysis.additionalContext.forEach((context) => {
-                lines.push(context);
-                lines.push('');
-            });
-        }
-        // Instructions
-        lines.push('---');
-        lines.push('');
-        lines.push('**Development Instructions:**');
-        lines.push('');
-        lines.push('Please implement a solution that:');
-        lines.push('- Addresses all core requirements');
-        lines.push('- Respects technical constraints');
-        lines.push('- Meets all success criteria');
-        lines.push('- Is well-structured, maintainable, and tested');
-        lines.push('');
-        lines.push('Focus on creating production-quality code with proper error handling, documentation, and tests.');
-        lines.push('');
-        return lines.join('\n');
-    }
-    /**
-     * Extract a summary from the conversation
-     */
-    extractSummary(messages, projectName) {
-        if (messages.length === 0) {
-            return `This project (${projectName}) requires development based on the following requirements.`;
-        }
-        // Use the first message as the primary summary, or combine first few messages
-        const firstMessage = messages[0];
-        if (messages.length === 1) {
-            return firstMessage;
-        }
-        // Try to create a concise summary from the conversation
-        const combinedText = messages.slice(0, 3).join(' ');
-        if (combinedText.length <= 300) {
-            return combinedText;
-        }
-        return firstMessage;
-    }
-    /**
-     * Extract key requirements from messages
-     */
-    extractKeyRequirements(messages) {
-        const requirements = [];
-        // Keywords that indicate requirements
-        const requirementPatterns = [
-            /(?:need|want|should|must|require)(?:s)?\s+(?:to\s+)?(.+?)(?:\.|$)/gi,
-            /(?:implement|add|create|build|develop)\s+(.+?)(?:\.|$)/gi,
-            /(?:feature|functionality):\s*(.+?)(?:\.|$)/gi,
-        ];
-        for (const message of messages) {
-            for (const pattern of requirementPatterns) {
-                const matches = [...message.matchAll(pattern)];
-                for (const match of matches) {
-                    if (match[1]) {
-                        const requirement = match[1].trim();
-                        if (requirement.length > 10 && requirement.length < 200) {
-                            requirements.push(this.cleanupText(requirement));
-                        }
-                    }
-                }
-            }
-            // Also capture direct statements (messages that don't match patterns)
-            if (!this.matchesAnyPattern(message, requirementPatterns)) {
-                const cleaned = this.cleanupText(message);
-                if (cleaned.length > 10 && cleaned.length < 200) {
-                    requirements.push(cleaned);
-                }
-            }
-        }
-        // Remove duplicates and limit
-        return [...new Set(requirements)].slice(0, 10);
-    }
-    /**
-     * Extract technical constraints from messages
-     */
-    extractTechnicalConstraints(messages) {
-        const constraints = [];
-        const technicalKeywords = [
-            'typescript', 'javascript', 'python', 'java', 'node', 'react', 'vue', 'angular',
-            'database', 'sql', 'nosql', 'mongodb', 'postgres', 'mysql',
-            'api', 'rest', 'graphql', 'websocket',
-            'authentication', 'oauth', 'jwt', 'security',
-            'performance', 'scale', 'cache', 'redis',
-            'docker', 'kubernetes', 'aws', 'azure', 'gcp',
-            'framework', 'library', 'package', 'version',
-        ];
-        for (const message of messages) {
-            const lowerMessage = message.toLowerCase();
-            // Check for technical keywords
-            for (const keyword of technicalKeywords) {
-                if (lowerMessage.includes(keyword)) {
-                    // Extract the sentence containing the keyword
-                    const sentences = message.split(/[.!?]+/);
-                    for (const sentence of sentences) {
-                        if (sentence.toLowerCase().includes(keyword)) {
-                            const cleaned = this.cleanupText(sentence);
-                            if (cleaned.length > 10) {
-                                constraints.push(cleaned);
-                            }
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-        // Remove duplicates and limit
-        return [...new Set(constraints)].slice(0, 8);
-    }
-    /**
-     * Extract success criteria from messages
-     */
-    extractSuccessCriteria(messages) {
-        const criteria = [];
-        const criteriaPatterns = [
-            /(?:success|successful|complete|done)\s+(?:when|if|criteria):\s*(.+?)(?:\.|$)/gi,
-            /(?:should be able to)\s+(.+?)(?:\.|$)/gi,
-            /(?:must|has to)\s+(.+?)(?:\.|$)/gi,
-        ];
-        for (const message of messages) {
-            for (const pattern of criteriaPatterns) {
-                const matches = [...message.matchAll(pattern)];
-                for (const match of matches) {
-                    if (match[1]) {
-                        const criterion = this.cleanupText(match[1]);
-                        if (criterion.length > 10) {
-                            criteria.push(criterion);
-                        }
-                    }
-                }
-            }
-        }
-        // If no explicit criteria found, infer from requirements
-        if (criteria.length === 0 && messages.length > 0) {
-            criteria.push('All core requirements are implemented and functional');
-            criteria.push('Code is tested and well-documented');
-        }
-        return [...new Set(criteria)].slice(0, 6);
-    }
-    /**
-     * Extract out-of-scope items from messages
-     */
-    extractOutOfScope(messages) {
-        const outOfScope = [];
-        const outOfScopePatterns = [
-            /(?:don't|do not|don't)\s+(?:need|want|include)\s+(.+?)(?:\.|$)/gi,
-            /(?:not|no)\s+(?:in scope|necessary|needed|required):\s*(.+?)(?:\.|$)/gi,
-            /(?:skip|ignore|exclude)\s+(.+?)(?:\.|$)/gi,
-        ];
-        for (const message of messages) {
-            for (const pattern of outOfScopePatterns) {
-                const matches = [...message.matchAll(pattern)];
-                for (const match of matches) {
-                    if (match[1]) {
-                        const item = this.cleanupText(match[1]);
-                        if (item.length > 10) {
-                            outOfScope.push(item);
-                        }
-                    }
-                }
-            }
-        }
-        return [...new Set(outOfScope)].slice(0, 5);
-    }
-    /**
-     * Extract additional context from messages
-     */
-    extractAdditionalContext(messages) {
-        const context = [];
-        // Look for context indicators
-        const contextPatterns = [
-            /(?:context|background|note):\s*(.+?)(?:\.|$)/gi,
-            /(?:important|note that|keep in mind)\s+(.+?)(?:\.|$)/gi,
-        ];
-        for (const message of messages) {
-            for (const pattern of contextPatterns) {
-                const matches = [...message.matchAll(pattern)];
-                for (const match of matches) {
-                    if (match[1]) {
-                        const item = this.cleanupText(match[1]);
-                        if (item.length > 10) {
-                            context.push(item);
-                        }
-                    }
-                }
-            }
-        }
-        return [...new Set(context)].slice(0, 5);
-    }
-    /**
-     * Clean up extracted text
-     */
-    cleanupText(text) {
-        return text
-            .trim()
-            .replace(/\s+/g, ' ')
-            .replace(/^[,\s]+/, '')
-            .replace(/[,\s]+$/, '');
-    }
-    /**
-     * Check if message matches any pattern
-     */
-    matchesAnyPattern(message, patterns) {
-        for (const pattern of patterns) {
-            if (pattern.test(message)) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-//# sourceMappingURL=conversation-analyzer.js.map

package/dist/core/conversation-quality-tracker.d.ts

@@ -1,81 +0,0 @@
-/**
- * v4.3.2: Conversation Quality Tracker
- *
- * Implements the "Supportive Companion" UX pattern for conversational mode.
- * Silently tracks quality, provides positive reinforcement, and gentle guidance.
- */
-export interface TrackedTopic {
-    name: string;
-    confidence: number;
-    firstMentioned: number;
-}
-export interface ConversationQuality {
-    topics: TrackedTopic[];
-    overallCompleteness: number;
-    ambiguityLevel: number;
-    messageCount: number;
-}
-export interface NudgeResult {
-    shouldNudge: boolean;
-    message?: string;
-    gap?: string;
-}
-/**
- * ConversationQualityTracker - "Supportive Companion" UX
- *
- * Design principles:
- * - Silent tracking during normal flow
- * - Celebrate progress, don't criticize gaps
- * - Gentle nudge only for critical issues (max 1 per session)
- * - Always reassure that Clavix will help
- */
-export declare class ConversationQualityTracker {
-    private topics;
-    private messageCount;
-    private hasNudged;
-    private lastCheckpointAt;
-    private readonly TOPIC_KEYWORDS;
-    private readonly CRITICAL_TOPICS;
-    /**
-     * Track a new message (silent analysis)
-     */
-    trackMessage(content: string): void;
-    /**
-     * Get positive checkpoint message (call after ~5 messages or on "status")
-     * Returns null if not time for a checkpoint
-     */
-    getPositiveCheckpoint(): string | null;
-    /**
-     * Check if a gentle nudge is needed (max 1 per session, only for critical gaps)
-     */
-    shouldNudge(): NudgeResult;
-    /**
-     * Get reassuring end-of-session message
-     */
-    getEndMessage(): string;
-    /**
-     * Get current quality metrics (for internal use)
-     */
-    calculateQuality(): ConversationQuality;
-    /**
-     * Get list of covered topics (user-friendly names)
-     */
-    private getCoveredTopics;
-    /**
-     * Find a critical gap to nudge about
-     */
-    private findCriticalGap;
-    /**
-     * Analyze message content for topic coverage
-     */
-    private analyzeTopics;
-    /**
-     * Reset tracker for new session
-     */
-    reset(): void;
-    /**
-     * Get summary for debugging/logging
-     */
-    getSummary(): string;
-}
-//# sourceMappingURL=conversation-quality-tracker.d.ts.map

package/dist/core/conversation-quality-tracker.js

@@ -1,195 +0,0 @@
-/**
- * v4.3.2: Conversation Quality Tracker
- *
- * Implements the "Supportive Companion" UX pattern for conversational mode.
- * Silently tracks quality, provides positive reinforcement, and gentle guidance.
- */
-/**
- * ConversationQualityTracker - "Supportive Companion" UX
- *
- * Design principles:
- * - Silent tracking during normal flow
- * - Celebrate progress, don't criticize gaps
- * - Gentle nudge only for critical issues (max 1 per session)
- * - Always reassure that Clavix will help
- */
-export class ConversationQualityTracker {
-    topics = new Map();
-    messageCount = 0;
-    hasNudged = false;
-    lastCheckpointAt = 0;
-    // Topic detection keywords
-    TOPIC_KEYWORDS = {
-        features: ['feature', 'functionality', 'should', 'must', 'need', 'want', 'capability'],
-        'tech stack': [
-            'react',
-            'node',
-            'typescript',
-            'python',
-            'database',
-            'api',
-            'backend',
-            'frontend',
-        ],
-        constraints: [
-            'constraint',
-            'limitation',
-            'budget',
-            'timeline',
-            'deadline',
-            'must not',
-            'cannot',
-        ],
-        users: ['user', 'customer', 'audience', 'persona', 'who will'],
-        goals: ['goal', 'objective', 'purpose', 'why', 'problem', 'solve'],
-        scope: ['scope', 'out of scope', 'not include', 'exclude', 'later', 'mvp'],
-        success: ['success', 'metric', 'kpi', 'measure', 'criteria'],
-        design: ['design', 'ui', 'ux', 'layout', 'interface', 'look'],
-    };
-    // Critical gaps that warrant a nudge (only if quality < 40%)
-    CRITICAL_TOPICS = ['features', 'goals'];
-    /**
-     * Track a new message (silent analysis)
-     */
-    trackMessage(content) {
-        this.messageCount++;
-        this.analyzeTopics(content);
-    }
-    /**
-     * Get positive checkpoint message (call after ~5 messages or on "status")
-     * Returns null if not time for a checkpoint
-     */
-    getPositiveCheckpoint() {
-        // Only show checkpoint every 5 messages
-        if (this.messageCount < 5 || this.messageCount - this.lastCheckpointAt < 5) {
-            return null;
-        }
-        this.lastCheckpointAt = this.messageCount;
-        const coveredTopics = this.getCoveredTopics();
-        if (coveredTopics.length === 0) {
-            return null;
-        }
-        // Format covered topics nicely
-        const topicList = coveredTopics.slice(0, 3).join(', ');
-        return `📝 Shaping up nicely! Covered: ${topicList}. Continue or /summarize anytime.`;
-    }
-    /**
-     * Check if a gentle nudge is needed (max 1 per session, only for critical gaps)
-     */
-    shouldNudge() {
-        // Only nudge once per session
-        if (this.hasNudged) {
-            return { shouldNudge: false };
-        }
-        // Only nudge after a few messages
-        if (this.messageCount < 3) {
-            return { shouldNudge: false };
-        }
-        // Only nudge if quality is low
-        const quality = this.calculateQuality();
-        if (quality.overallCompleteness >= 40) {
-            return { shouldNudge: false };
-        }
-        // Find critical gap
-        const criticalGap = this.findCriticalGap();
-        if (!criticalGap) {
-            return { shouldNudge: false };
-        }
-        // Mark that we've nudged
-        this.hasNudged = true;
-        return {
-            shouldNudge: true,
-            gap: criticalGap,
-            message: `💡 One thought: a note about ${criticalGap} would help. No worries—Clavix will fill gaps when you summarize.`,
-        };
-    }
-    /**
-     * Get reassuring end-of-session message
-     */
-    getEndMessage() {
-        const coveredTopics = this.getCoveredTopics();
-        if (coveredTopics.length === 0) {
-            return '✨ Session recorded! Clavix Intelligence will help structure your requirements.';
-        }
-        if (coveredTopics.length >= 3) {
-            return '✨ Great session! You covered several key areas. Clavix Intelligence will enhance your summary.';
-        }
-        return '✨ Great session! Clavix Intelligence will enhance your summary with any missing pieces.';
-    }
-    /**
-     * Get current quality metrics (for internal use)
-     */
-    calculateQuality() {
-        const topics = Array.from(this.topics.values());
-        // Calculate completeness based on covered topics
-        const totalPossibleTopics = Object.keys(this.TOPIC_KEYWORDS).length;
-        const coveredCount = topics.filter((t) => t.confidence >= 30).length;
-        const overallCompleteness = Math.min(100, Math.round((coveredCount / totalPossibleTopics) * 100));
-        // Estimate ambiguity (higher if fewer topics covered with low confidence)
-        const avgConfidence = topics.length > 0 ? topics.reduce((sum, t) => sum + t.confidence, 0) / topics.length : 0;
-        const ambiguityLevel = Math.max(0, 100 - avgConfidence);
-        return {
-            topics,
-            overallCompleteness,
-            ambiguityLevel,
-            messageCount: this.messageCount,
-        };
-    }
-    /**
-     * Get list of covered topics (user-friendly names)
-     */
-    getCoveredTopics() {
-        return Array.from(this.topics.values())
-            .filter((t) => t.confidence >= 30)
-            .sort((a, b) => b.confidence - a.confidence)
-            .map((t) => t.name);
-    }
-    /**
-     * Find a critical gap to nudge about
-     */
-    findCriticalGap() {
-        for (const topic of this.CRITICAL_TOPICS) {
-            const tracked = this.topics.get(topic);
-            if (!tracked || tracked.confidence < 20) {
-                return topic;
-            }
-        }
-        return null;
-    }
-    /**
-     * Analyze message content for topic coverage
-     */
-    analyzeTopics(content) {
-        const lowerContent = content.toLowerCase();
-        for (const [topic, keywords] of Object.entries(this.TOPIC_KEYWORDS)) {
-            const matchedKeywords = keywords.filter((kw) => lowerContent.includes(kw));
-            if (matchedKeywords.length > 0) {
-                const existing = this.topics.get(topic);
-                const confidence = Math.min(100, matchedKeywords.length * 25 + (existing?.confidence || 0));
-                this.topics.set(topic, {
-                    name: topic,
-                    confidence,
-                    firstMentioned: existing?.firstMentioned || this.messageCount,
-                });
-            }
-        }
-    }
-    /**
-     * Reset tracker for new session
-     */
-    reset() {
-        this.topics.clear();
-        this.messageCount = 0;
-        this.hasNudged = false;
-        this.lastCheckpointAt = 0;
-    }
-    /**
-     * Get summary for debugging/logging
-     */
-    getSummary() {
-        const quality = this.calculateQuality();
-        const topics = this.getCoveredTopics();
-        return `Messages: ${this.messageCount}, Topics: [${topics.join(', ')}], Completeness: ${quality.overallCompleteness}%`;
-    }
-}
-//# sourceMappingURL=conversation-quality-tracker.js.map