clavix 4.12.0 → 5.0.1

package/dist/core/question-engine.d.ts

@@ -1,167 +0,0 @@
-/**
- * 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
- */
-/**
- * Type of question input
- */
-export type QuestionType = 'text' | 'list' | 'confirm';
-/**
- * A single question in the flow
- */
-export interface Question {
-    id: string;
-    text: string;
-    type: QuestionType;
-    required: boolean;
-    choices?: string[];
-    default?: string | boolean;
-    validate?: (answer: string) => boolean | string;
-    condition?: (answers: Record<string, Answer>) => boolean;
-}
-/**
- * Answer to a question
- */
-export type Answer = string | boolean | string[];
-/**
- * Collection of answers keyed by question ID
- */
-export interface Answers {
-    [questionId: string]: Answer;
-}
-/**
- * Question flow configuration
- */
-export interface QuestionFlow {
-    name: string;
-    description: string;
-    questions: Question[];
-}
-/**
- * Progress information for multi-question flows
- */
-export interface QuestionProgress {
-    current: number;
-    total: number;
-    percentage: number;
-}
-/**
- * QuestionEngine class
- *
- * Manages the flow of questions, answer collection, and validation
- */
-export declare class QuestionEngine {
-    private currentFlow;
-    private answers;
-    private currentQuestionIndex;
-    /**
-     * Load a question flow from a template file
-     *
-     * @param templatePath - Path to the question template
-     * @returns The loaded question flow
-     */
-    loadFlow(templatePath: string): Promise<QuestionFlow>;
-    /**
-     * 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
-     */
-    private parseTemplate;
-    /**
-     * Parse a single metadata field for a question
-     */
-    private parseQuestionMetadata;
-    /**
-     * Finalize a question by setting defaults and generating ID
-     */
-    private finalizeQuestion;
-    /**
-     * 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
-     */
-    private createValidator;
-    /**
-     * 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"
-     */
-    private createCondition;
-    /**
-     * Get the next question in the flow
-     *
-     * @returns The next question, or null if flow is complete
-     */
-    getNextQuestion(): Question | 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: string, answer: Answer): boolean | string;
-    /**
-     * Get all collected answers
-     *
-     * @returns All answers collected so far
-     */
-    getAnswers(): Answers;
-    /**
-     * Get current progress through the question flow
-     *
-     * @returns Progress information
-     */
-    getProgress(): QuestionProgress;
-    /**
-     * Check if the question flow is complete
-     *
-     * @returns True if all required questions are answered
-     */
-    isComplete(): boolean;
-    /**
-     * Reset the question flow
-     */
-    reset(): void;
-    /**
-     * Get the current question flow
-     *
-     * @returns The loaded question flow, or null if none loaded
-     */
-    getCurrentFlow(): QuestionFlow | null;
-}
-//# sourceMappingURL=question-engine.d.ts.map

package/dist/core/question-engine.js

@@ -1,356 +0,0 @@
-/**
- * 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
- */
-import fs from 'fs-extra';
-import * as path from 'path';
-/**
- * QuestionEngine class
- *
- * Manages the flow of questions, answer collection, and validation
- */
-export class QuestionEngine {
-    currentFlow = null;
-    answers = {};
-    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;
-    }
-}
-//# sourceMappingURL=question-engine.js.map

package/dist/core/session-manager.d.ts

@@ -1,139 +0,0 @@
-/**
- * SessionManager - Manages conversational sessions for clavix start/summarize
- *
- * This class handles:
- * - Session creation with unique IDs
- * - Message tracking and storage
- * - Session file persistence (JSON format)
- * - Session listing, filtering, and search
- * - CRUD operations for sessions
- *
- * Sessions are stored in `.clavix/sessions/` as JSON files:
- * `.clavix/sessions/{session-id}.json`
- */
-import { Session, SessionMetadata, SessionFilter } from '../types/session.js';
-/**
- * Options for creating a new session
- */
-export interface CreateSessionOptions {
-    projectName?: string;
-    agent?: string;
-    description?: string;
-    tags?: string[];
-}
-/**
- * SessionManager class
- *
- * Manages all session-related operations including creation, storage,
- * retrieval, listing, and search functionality.
- */
-export declare class SessionManager {
-    private readonly sessionsDir;
-    private readonly defaultSessionsDir;
-    constructor(sessionsDir?: string);
-    /**
-     * Create a new session
-     *
-     * @param options - Session creation options
-     * @returns The created session
-     */
-    createSession(options?: CreateSessionOptions): Promise<Session>;
-    /**
-     * Get a session by ID
-     *
-     * @param sessionId - The session ID
-     * @returns The session, or null if not found
-     */
-    getSession(sessionId: string): Promise<Session | null>;
-    /**
-     * Save a session to disk
-     *
-     * @param session - The session to save
-     */
-    saveSession(session: Session): Promise<void>;
-    /**
-     * Update a session
-     *
-     * @param sessionId - The session ID
-     * @param updates - Partial session updates
-     * @returns The updated session, or null if not found
-     */
-    updateSession(sessionId: string, updates: Partial<Omit<Session, 'id' | 'created'>>): Promise<Session | null>;
-    /**
-     * Delete a session
-     *
-     * @param sessionId - The session ID
-     * @returns True if deleted, false if not found
-     */
-    deleteSession(sessionId: string): Promise<boolean>;
-    /**
-     * Add a message to a session
-     *
-     * @param sessionId - The session ID
-     * @param role - Message role (user or assistant)
-     * @param content - Message content
-     * @returns The updated session, or null if session not found
-     */
-    addMessage(sessionId: string, role: 'user' | 'assistant', content: string): Promise<Session | null>;
-    /**
-     * List all sessions with optional filtering
-     *
-     * @param filter - Optional filter criteria
-     * @returns Array of session metadata
-     */
-    listSessions(filter?: SessionFilter): Promise<SessionMetadata[]>;
-    /**
-     * Search sessions by keyword
-     *
-     * Searches in project name, description, tags, and message content
-     *
-     * @param keyword - Search keyword
-     * @returns Array of matching session metadata
-     */
-    searchSessions(keyword: string): Promise<SessionMetadata[]>;
-    /**
-     * Get the most recent active session
-     *
-     * @returns The active session, or null if none exists
-     */
-    getActiveSession(): Promise<Session | null>;
-    /**
-     * Mark a session as completed
-     *
-     * @param sessionId - The session ID
-     * @returns The updated session, or null if not found
-     */
-    completeSession(sessionId: string): Promise<Session | null>;
-    /**
-     * Mark a session as archived
-     *
-     * @param sessionId - The session ID
-     * @returns The updated session, or null if not found
-     */
-    archiveSession(sessionId: string): Promise<Session | null>;
-    /**
-     * Get the path to a session file
-     */
-    private getSessionPath;
-    /**
-     * Generate a default project name based on timestamp
-     */
-    private generateDefaultProjectName;
-    /**
-     * Serialize a session for file storage
-     */
-    private serializeSession;
-    /**
-     * Deserialize a session from file storage
-     */
-    private deserializeSession;
-    /**
-     * Extract metadata from a serialized session
-     */
-    private extractMetadata;
-    /**
-     * Check if session metadata matches filter criteria
-     */
-    private matchesFilter;
-}
-//# sourceMappingURL=session-manager.d.ts.map