clavix 2.7.0 → 2.8.0

package/dist/core/prompt-optimizer.d 2.ts

@@ -1,268 +0,0 @@
-/**
- * PromptOptimizer - Analyzes and improves prompts using the CLEAR Framework
- * CLEAR Framework: Concise, Logical, Explicit, Adaptive, Reflective
- * Developed by Dr. Leo Lo, University of New Mexico
- * Reference: https://guides.library.tamucc.edu/prompt-engineering/clear
- */
-export type OptimizerMode = 'fast' | 'deep';
-export interface PromptAnalysis {
-    gaps: string[];
-    ambiguities: string[];
-    strengths: string[];
-    suggestions: string[];
-}
-export interface ConciseAnalysis {
-    score: number;
-    verbosityCount: number;
-    pleasantriesCount: number;
-    signalToNoiseRatio: number;
-    issues: string[];
-    suggestions: string[];
-}
-export interface LogicAnalysis {
-    score: number;
-    hasCoherentFlow: boolean;
-    sequencingIssues: string[];
-    suggestedOrder: string[];
-    issues: string[];
-    suggestions: string[];
-}
-export interface ExplicitAnalysis {
-    score: number;
-    hasPersona: boolean;
-    hasOutputFormat: boolean;
-    hasToneStyle: boolean;
-    hasSuccessCriteria: boolean;
-    hasExamples: boolean;
-    issues: string[];
-    suggestions: string[];
-}
-export interface AdaptiveAnalysis {
-    score: number;
-    alternativePhrasings: string[];
-    alternativeStructures: Array<{
-        name: string;
-        structure: string;
-        benefits: string;
-    }>;
-    temperatureRecommendation: number;
-    issues: string[];
-    suggestions: string[];
-}
-export interface ReflectiveAnalysis {
-    score: number;
-    validationChecklist: string[];
-    edgeCases: string[];
-    potentialIssues: string[];
-    factCheckingSteps: string[];
-    qualityCriteria: string[];
-    issues: string[];
-    suggestions: string[];
-}
-export interface CLEARResult {
-    conciseness: ConciseAnalysis;
-    logic: LogicAnalysis;
-    explicitness: ExplicitAnalysis;
-    adaptiveness?: AdaptiveAnalysis;
-    reflectiveness?: ReflectiveAnalysis;
-    overallScore: number;
-    improvedPrompt: string;
-    changesSummary: Array<{
-        component: 'C' | 'L' | 'E' | 'A' | 'R';
-        change: string;
-    }>;
-}
-export interface CLEARScore {
-    overall: number;
-    conciseness: number;
-    logic: number;
-    explicitness: number;
-    adaptiveness?: number;
-    reflectiveness?: number;
-    rating: 'excellent' | 'good' | 'needs-improvement' | 'poor';
-}
-export interface TriageResult {
-    needsDeepAnalysis: boolean;
-    reasons: string[];
-}
-export interface QualityAssessment {
-    isAlreadyGood: boolean;
-    criteriaMetCount: number;
-    totalCriteria: number;
-    criteriaResults: {
-        clearGoal: boolean;
-        sufficientContext: boolean;
-        actionableLanguage: boolean;
-        reasonableScope: boolean;
-    };
-}
-export interface ChangesSummary {
-    changes: string[];
-}
-export interface ImprovedPrompt {
-    original: string;
-    analysis: PromptAnalysis;
-    improved: string;
-    changesSummary?: ChangesSummary;
-    triageResult?: TriageResult;
-    qualityAssessment?: QualityAssessment;
-    alternativePhrasings?: string[];
-    edgeCases?: string[];
-    implementationExamples?: {
-        good: string[];
-        bad: string[];
-    };
-    alternativeStructures?: Array<{
-        structure: string;
-        benefits: string;
-    }>;
-    potentialIssues?: string[];
-}
-export declare class PromptOptimizer {
-    /**
-     * Analyze a prompt and identify issues
-     */
-    analyze(prompt: string): PromptAnalysis;
-    /**
-     * Perform smart triage to determine if deep analysis is recommended
-     */
-    performTriage(prompt: string): TriageResult;
-    /**
-     * Assess prompt quality
-     */
-    assessQuality(prompt: string): QualityAssessment;
-    /**
-     * Generate an improved version of the prompt
-     */
-    improve(prompt: string, mode?: OptimizerMode): ImprovedPrompt;
-    /**
-     * Apply CLEAR Framework analysis to a prompt
-     * C = Concise, L = Logical, E = Explicit, A = Adaptive (deep only), R = Reflective (deep only)
-     */
-    applyCLEARFramework(prompt: string, mode?: OptimizerMode): CLEARResult;
-    /**
-     * Analyze Conciseness (C): Brevity and clarity
-     */
-    analyzeConciseness(prompt: string): ConciseAnalysis;
-    /**
-     * Analyze Logic (L): Structured and coherent prompts
-     */
-    analyzeLogic(prompt: string): LogicAnalysis;
-    /**
-     * Analyze Explicitness (E): Clear output specifications
-     */
-    analyzeExplicitness(prompt: string): ExplicitAnalysis;
-    /**
-     * Analyze Adaptiveness (A): Flexibility and customization
-     */
-    analyzeAdaptiveness(prompt: string): AdaptiveAnalysis;
-    /**
-     * Analyze Reflectiveness (R): Continuous evaluation and improvement
-     */
-    analyzeReflectiveness(prompt: string): ReflectiveAnalysis;
-    /**
-     * Calculate overall CLEAR score with weighted components
-     */
-    calculateCLEARScore(analysis: {
-        conciseness: ConciseAnalysis;
-        logic: LogicAnalysis;
-        explicitness: ExplicitAnalysis;
-        adaptiveness?: AdaptiveAnalysis;
-        reflectiveness?: ReflectiveAnalysis;
-    }): CLEARScore;
-    /**
-     * Generate improved prompt using CLEAR framework insights
-     */
-    private generateCLEARImprovedPrompt;
-    /**
-     * Generate CLEAR-labeled changes summary
-     */
-    private generateCLEARChangesSummary;
-    /**
-     * Map CLEAR result to legacy PromptAnalysis format for backward compatibility
-     */
-    mapCLEARToLegacy(clearResult: CLEARResult): PromptAnalysis;
-    /**
-     * Extract strengths from CLEAR analysis
-     */
-    private extractCLEARStrengths;
-    /**
-     * Find gaps in the prompt
-     */
-    private findGaps;
-    /**
-     * Find ambiguities in the prompt
-     */
-    private findAmbiguities;
-    /**
-     * Find strengths in the prompt
-     */
-    private findStrengths;
-    /**
-     * Generate improvement suggestions
-     */
-    private generateSuggestions;
-    /**
-     * Generate improved prompt with structure
-     */
-    private generateImprovedPrompt;
-    private hasContext;
-    private hasSuccessCriteria;
-    private hasTechnicalDetails;
-    private hasUserNeeds;
-    private hasExpectedOutput;
-    private extractOrInferObjective;
-    private extractOrInferRequirements;
-    private extractOrInferTechnical;
-    private extractOrInferOutput;
-    private extractOrInferSuccess;
-    /**
-     * Count missing critical elements
-     */
-    private countMissingCriticalElements;
-    /**
-     * Check for vague scope words without sufficient context
-     */
-    private hasVagueScopeWithoutContext;
-    /**
-     * Check if prompt has a clear goal
-     */
-    private hasClearGoal;
-    /**
-     * Check if prompt uses actionable language
-     */
-    private hasActionableLanguage;
-    /**
-     * Check if prompt has reasonable scope
-     */
-    private hasReasonableScope;
-    /**
-     * Generate changes summary
-     */
-    private generateChangesSummary;
-    /**
-     * Generate alternative phrasings (deep mode)
-     */
-    private generateAlternativePhrasings;
-    /**
-     * Identify edge cases in requirements (deep mode)
-     */
-    private identifyEdgeCases;
-    /**
-     * Generate implementation examples (deep mode)
-     */
-    private generateImplementationExamples;
-    /**
-     * Suggest alternative prompt structures (deep mode)
-     */
-    private suggestAlternativeStructures;
-    /**
-     * Identify potential issues with the prompt (deep mode)
-     */
-    private identifyPotentialIssues;
-    /**
-     * Extract core requirement from prompt
-     */
-    private extractCoreRequirement;
-}
-//# sourceMappingURL=prompt-optimizer.d.ts.map

package/dist/core/question-engine 2.js

@@ -1,395 +0,0 @@
-"use strict";
-/**
- * QuestionEngine - Manages Socratic questioning flows for PRD generation
- *
- * This class handles:
- * - Loading question templates
- * - Sequential and conditional question flows
- * - Answer collection and validation
- * - Progress tracking
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuestionEngine = void 0;
-const fs = __importStar(require("fs-extra"));
-const path = __importStar(require("path"));
-/**
- * QuestionEngine class
- *
- * Manages the flow of questions, answer collection, and validation
- */
-class QuestionEngine {
-    constructor() {
-        this.currentFlow = null;
-        this.answers = {};
-        this.currentQuestionIndex = 0;
-    }
-    /**
-     * Load a question flow from a template file
-     *
-     * @param templatePath - Path to the question template
-     * @returns The loaded question flow
-     */
-    async loadFlow(templatePath) {
-        const fullPath = path.resolve(templatePath);
-        if (!await fs.pathExists(fullPath)) {
-            throw new Error(`Question template not found: ${templatePath}`);
-        }
-        const content = await fs.readFile(fullPath, 'utf-8');
-        const flow = this.parseTemplate(content);
-        this.currentFlow = flow;
-        this.answers = {};
-        this.currentQuestionIndex = 0;
-        return flow;
-    }
-    /**
-     * Parse a question template into a QuestionFlow
-     *
-     * Template format:
-     * ```markdown
-     * # Flow Name
-     *
-     * Flow description
-     *
-     * ## Question 1
-     *
-     * **text:** What problem are you solving?
-     * **type:** text
-     * **required:** true
-     * **validation:** minLength:10
-     *
-     * ## Question 2
-     *
-     * **text:** Select your technology stack
-     * **type:** list
-     * **choices:** React, Vue, Angular, Other
-     * ```
-     *
-     * @param template - Template content
-     * @returns Parsed QuestionFlow
-     */
-    parseTemplate(template) {
-        const lines = template.split('\n');
-        const questions = [];
-        let name = 'Default Flow';
-        let description = '';
-        let currentQuestion = null;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            // Skip empty lines
-            if (!line) {
-                continue;
-            }
-            // Extract flow name from first h1
-            if (line.startsWith('# ') && name === 'Default Flow') {
-                name = line.substring(2).trim();
-                continue;
-            }
-            // Extract description (first non-heading paragraph)
-            if (line && !line.startsWith('#') && !line.startsWith('**') && !description) {
-                description = line;
-                continue;
-            }
-            // Start new question on h2
-            if (line.startsWith('## ')) {
-                // Save previous question if exists
-                if (currentQuestion && currentQuestion.text) {
-                    questions.push(this.finalizeQuestion(currentQuestion, questions.length));
-                }
-                // Start new question
-                currentQuestion = {};
-                continue;
-            }
-            // Parse question metadata: **key:** value
-            const metadataMatch = line.match(/^\*\*(\w+):\*\*\s*(.+)$/);
-            if (metadataMatch && currentQuestion) {
-                const [, key, value] = metadataMatch;
-                this.parseQuestionMetadata(currentQuestion, key, value);
-            }
-        }
-        // Save last question
-        if (currentQuestion && currentQuestion.text) {
-            questions.push(this.finalizeQuestion(currentQuestion, questions.length));
-        }
-        return { name, description, questions };
-    }
-    /**
-     * Parse a single metadata field for a question
-     */
-    parseQuestionMetadata(question, key, value) {
-        switch (key.toLowerCase()) {
-            case 'text':
-                question.text = value;
-                break;
-            case 'type':
-                if (value === 'text' || value === 'list' || value === 'confirm') {
-                    question.type = value;
-                }
-                break;
-            case 'required':
-                question.required = value.toLowerCase() === 'true';
-                break;
-            case 'choices':
-                question.choices = value.split(',').map((c) => c.trim());
-                break;
-            case 'default':
-                if (question.type === 'confirm') {
-                    question.default = value.toLowerCase() === 'true';
-                }
-                else {
-                    question.default = value;
-                }
-                break;
-            case 'validation':
-                question.validate = this.createValidator(value);
-                break;
-            case 'condition':
-                question.condition = this.createCondition(value);
-                break;
-        }
-    }
-    /**
-     * Finalize a question by setting defaults and generating ID
-     */
-    finalizeQuestion(partial, index) {
-        return {
-            id: `q${index + 1}`,
-            text: partial.text || '',
-            type: partial.type || 'text',
-            required: partial.required !== undefined ? partial.required : true,
-            choices: partial.choices,
-            default: partial.default,
-            validate: partial.validate,
-            condition: partial.condition,
-        };
-    }
-    /**
-     * Create a validation function from a validation string
-     *
-     * Supported formats:
-     * - minLength:10 - Minimum length
-     * - maxLength:100 - Maximum length
-     * - pattern:^[a-z]+$ - Regex pattern
-     * - email - Email validation
-     * - url - URL validation
-     */
-    createValidator(validationStr) {
-        const parts = validationStr.split(':');
-        const type = parts[0].toLowerCase();
-        const param = parts[1];
-        return (answer) => {
-            switch (type) {
-                case 'minlength':
-                    if (answer.length < parseInt(param, 10)) {
-                        return `Minimum length is ${param} characters`;
-                    }
-                    break;
-                case 'maxlength':
-                    if (answer.length > parseInt(param, 10)) {
-                        return `Maximum length is ${param} characters`;
-                    }
-                    break;
-                case 'pattern':
-                    if (!new RegExp(param).test(answer)) {
-                        return 'Answer does not match required format';
-                    }
-                    break;
-                case 'email':
-                    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(answer)) {
-                        return 'Please enter a valid email address';
-                    }
-                    break;
-                case 'url':
-                    try {
-                        new URL(answer);
-                    }
-                    catch {
-                        return 'Please enter a valid URL';
-                    }
-                    break;
-            }
-            return true;
-        };
-    }
-    /**
-     * Create a condition function from a condition string
-     *
-     * Supported formats:
-     * - q1=true - Question 1 answer equals true
-     * - q2=JWT - Question 2 answer equals "JWT"
-     * - q3!=None - Question 3 answer not equals "None"
-     */
-    createCondition(conditionStr) {
-        const match = conditionStr.match(/^(\w+)\s*(=|!=)\s*(.+)$/);
-        if (!match) {
-            return () => true;
-        }
-        const [, questionId, operator, expectedValue] = match;
-        return (answers) => {
-            const actualValue = answers[questionId];
-            // Convert expected value to proper type
-            let expected = expectedValue;
-            if (expectedValue.toLowerCase() === 'true') {
-                expected = true;
-            }
-            else if (expectedValue.toLowerCase() === 'false') {
-                expected = false;
-            }
-            if (operator === '=') {
-                return actualValue === expected;
-            }
-            else {
-                return actualValue !== expected;
-            }
-        };
-    }
-    /**
-     * Get the next question in the flow
-     *
-     * @returns The next question, or null if flow is complete
-     */
-    getNextQuestion() {
-        if (!this.currentFlow) {
-            throw new Error('No question flow loaded');
-        }
-        // Find the next unanswered question that meets its condition
-        while (this.currentQuestionIndex < this.currentFlow.questions.length) {
-            const question = this.currentFlow.questions[this.currentQuestionIndex];
-            // Skip if already answered
-            if (question.id in this.answers) {
-                this.currentQuestionIndex++;
-                continue;
-            }
-            // Check if question condition is met (if it has one)
-            if (question.condition && !question.condition(this.answers)) {
-                this.currentQuestionIndex++;
-                continue;
-            }
-            return question;
-        }
-        return null;
-    }
-    /**
-     * Submit an answer to the current question
-     *
-     * @param questionId - ID of the question being answered
-     * @param answer - The answer
-     * @returns Validation result (true if valid, error message if invalid)
-     */
-    submitAnswer(questionId, answer) {
-        if (!this.currentFlow) {
-            throw new Error('No question flow loaded');
-        }
-        const question = this.currentFlow.questions.find((q) => q.id === questionId);
-        if (!question) {
-            throw new Error(`Question not found: ${questionId}`);
-        }
-        // Validate required fields (but allow false for boolean answers)
-        if (question.required && (answer === '' || answer === null || answer === undefined)) {
-            return 'This question is required';
-        }
-        // Run custom validation if provided
-        if (question.validate) {
-            const validationResult = question.validate(String(answer));
-            if (validationResult !== true) {
-                return validationResult;
-            }
-        }
-        // Store the answer
-        this.answers[questionId] = answer;
-        this.currentQuestionIndex++;
-        return true;
-    }
-    /**
-     * Get all collected answers
-     *
-     * @returns All answers collected so far
-     */
-    getAnswers() {
-        return { ...this.answers };
-    }
-    /**
-     * Get current progress through the question flow
-     *
-     * @returns Progress information
-     */
-    getProgress() {
-        if (!this.currentFlow) {
-            return { current: 0, total: 0, percentage: 0 };
-        }
-        const total = this.currentFlow.questions.length;
-        const current = Object.keys(this.answers).length;
-        const percentage = total > 0 ? Math.round((current / total) * 100) : 0;
-        return { current, total, percentage };
-    }
-    /**
-     * Check if the question flow is complete
-     *
-     * @returns True if all required questions are answered
-     */
-    isComplete() {
-        if (!this.currentFlow) {
-            return false;
-        }
-        // Check if all required questions have answers
-        for (const question of this.currentFlow.questions) {
-            // Skip if condition not met
-            if (question.condition && !question.condition(this.answers)) {
-                continue;
-            }
-            if (question.required && !(question.id in this.answers)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Reset the question flow
-     */
-    reset() {
-        this.answers = {};
-        this.currentQuestionIndex = 0;
-    }
-    /**
-     * Get the current question flow
-     *
-     * @returns The loaded question flow, or null if none loaded
-     */
-    getCurrentFlow() {
-        return this.currentFlow;
-    }
-}
-exports.QuestionEngine = QuestionEngine;
-//# sourceMappingURL=question-engine.js.map