clavix 4.11.2 → 5.0.0

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

@@ -1,149 +0,0 @@
-/**
- * ConfigManager - Manages .clavix-implement-config.json
- *
- * This class handles:
- * - Reading/writing implementation configuration
- * - Tracking task completion state
- * - Managing resume checkpoints
- * - Storing git commit strategy preferences
- */
-import { Task } from './task-manager.js';
-import { CommitStrategy } from './git-manager.js';
-/**
- * Configuration for task implementation
- */
-export interface ImplementConfig {
-    /** Git commit strategy */
-    commitStrategy: CommitStrategy;
-    /** Path to tasks.md file */
-    tasksPath: string;
-    /** Current task being worked on */
-    currentTask: Task;
-    /** Overall task statistics */
-    stats: {
-        total: number;
-        completed: number;
-        remaining: number;
-        percentage: number;
-    };
-    /** Timestamp when config was last updated */
-    timestamp: string;
-    /** ID of the last completed task */
-    lastCompletedTaskId?: string;
-    /** Array of all completed task IDs (for validation and resume) */
-    completedTaskIds?: string[];
-    /** Timestamps for each task completion (for tracking progress) */
-    completionTimestamps?: Record<string, string>;
-    /** Array of blocked task IDs with reasons */
-    blockedTasks?: Array<{
-        taskId: string;
-        reason: string;
-        timestamp: string;
-    }>;
-    /** Resume checkpoint for interrupted sessions */
-    resumeCheckpoint?: {
-        lastTaskId: string;
-        phaseProgress: Record<string, number>;
-        sessionStartTime: string;
-    };
-}
-/**
- * Options for updating config
- */
-export interface ConfigUpdateOptions {
-    /** Merge with existing config (true) or overwrite (false) */
-    merge?: boolean;
-    /** Validate config structure before writing */
-    validate?: boolean;
-}
-/**
- * ConfigManager class
- *
- * Manages implementation configuration and task tracking state
- */
-export declare class ConfigManager {
-    /**
-     * Read implementation config from file
-     * @param configPath - Path to config file (.clavix-implement-config.json)
-     * @returns Implementation configuration
-     */
-    read(configPath: string): Promise<ImplementConfig>;
-    /**
-     * Write implementation config to file
-     * @param configPath - Path to config file
-     * @param config - Configuration to write
-     * @param options - Update options
-     */
-    write(configPath: string, config: ImplementConfig, options?: ConfigUpdateOptions): Promise<void>;
-    /**
-     * Update specific fields in config
-     * @param configPath - Path to config file
-     * @param updates - Partial config updates
-     */
-    update(configPath: string, updates: Partial<ImplementConfig>): Promise<void>;
-    /**
-     * Track a task completion
-     * @param configPath - Path to config file
-     * @param taskId - ID of completed task
-     */
-    trackCompletion(configPath: string, taskId: string): Promise<void>;
-    /**
-     * Add a blocked task
-     * @param configPath - Path to config file
-     * @param taskId - ID of blocked task
-     * @param reason - Reason for blocking
-     */
-    addBlockedTask(configPath: string, taskId: string, reason: string): Promise<void>;
-    /**
-     * Remove a blocked task (unblock)
-     * @param configPath - Path to config file
-     * @param taskId - ID of task to unblock
-     */
-    removeBlockedTask(configPath: string, taskId: string): Promise<void>;
-    /**
-     * Get current implementation state
-     * @param configPath - Path to config file
-     * @returns State summary
-     */
-    getState(configPath: string): Promise<{
-        currentTaskId: string;
-        completedCount: number;
-        remainingCount: number;
-        blockedCount: number;
-        lastCompletedTaskId?: string;
-        lastCompletionTime?: string;
-    }>;
-    /**
-     * Check if a task has been completed
-     * @param configPath - Path to config file
-     * @param taskId - Task ID to check
-     * @returns true if task is in completed list
-     */
-    isTaskCompleted(configPath: string, taskId: string): Promise<boolean>;
-    /**
-     * Validate config structure
-     * @param config - Configuration to validate
-     * @throws Error if config is invalid
-     */
-    private validateConfig;
-    /**
-     * Migrate old config format to new format
-     * @param config - Old config format
-     * @returns Migrated config
-     */
-    private migrateConfig;
-    /**
-     * Create a resume checkpoint
-     * @param configPath - Path to config file
-     * @param currentTaskId - Current task being worked on
-     * @param phaseProgress - Progress by phase (phase name -> completed count)
-     */
-    createResumeCheckpoint(configPath: string, currentTaskId: string, phaseProgress: Record<string, number>): Promise<void>;
-    /**
-     * Get the config file path for a PRD directory
-     * @param prdPath - Path to PRD directory
-     * @returns Path to config file
-     */
-    static getConfigPath(prdPath: string): string;
-}
-//# sourceMappingURL=config-manager.d.ts.map

package/dist/core/config-manager.js

@@ -1,230 +0,0 @@
-/**
- * ConfigManager - Manages .clavix-implement-config.json
- *
- * This class handles:
- * - Reading/writing implementation configuration
- * - Tracking task completion state
- * - Managing resume checkpoints
- * - Storing git commit strategy preferences
- */
-import fs from 'fs-extra';
-import * as path from 'path';
-/**
- * ConfigManager class
- *
- * Manages implementation configuration and task tracking state
- */
-export class ConfigManager {
-    /**
-     * Read implementation config from file
-     * @param configPath - Path to config file (.clavix-implement-config.json)
-     * @returns Implementation configuration
-     */
-    async read(configPath) {
-        if (!(await fs.pathExists(configPath))) {
-            throw new Error(`Config file not found: ${configPath}\n\nHint: Run "clavix implement" first to initialize configuration`);
-        }
-        try {
-            const config = await fs.readJson(configPath);
-            // Migrate old config format if needed
-            return this.migrateConfig(config);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to read config file: ${errorMessage}`);
-        }
-    }
-    /**
-     * Write implementation config to file
-     * @param configPath - Path to config file
-     * @param config - Configuration to write
-     * @param options - Update options
-     */
-    async write(configPath, config, options = {}) {
-        const { validate = true } = options;
-        if (validate) {
-            this.validateConfig(config);
-        }
-        try {
-            await fs.writeJson(configPath, config, { spaces: 2 });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-            throw new Error(`Failed to write config file: ${errorMessage}`);
-        }
-    }
-    /**
-     * Update specific fields in config
-     * @param configPath - Path to config file
-     * @param updates - Partial config updates
-     */
-    async update(configPath, updates) {
-        const existing = await this.read(configPath);
-        const updated = {
-            ...existing,
-            ...updates,
-            timestamp: new Date().toISOString(),
-        };
-        await this.write(configPath, updated);
-    }
-    /**
-     * Track a task completion
-     * @param configPath - Path to config file
-     * @param taskId - ID of completed task
-     */
-    async trackCompletion(configPath, taskId) {
-        const config = await this.read(configPath);
-        // Initialize tracking arrays if not present
-        if (!config.completedTaskIds) {
-            config.completedTaskIds = [];
-        }
-        if (!config.completionTimestamps) {
-            config.completionTimestamps = {};
-        }
-        // Add to completed tasks (avoid duplicates)
-        if (!config.completedTaskIds.includes(taskId)) {
-            config.completedTaskIds.push(taskId);
-        }
-        // Record completion timestamp
-        config.completionTimestamps[taskId] = new Date().toISOString();
-        // Update last completed task
-        config.lastCompletedTaskId = taskId;
-        // Update timestamp
-        config.timestamp = new Date().toISOString();
-        await this.write(configPath, config);
-    }
-    /**
-     * Add a blocked task
-     * @param configPath - Path to config file
-     * @param taskId - ID of blocked task
-     * @param reason - Reason for blocking
-     */
-    async addBlockedTask(configPath, taskId, reason) {
-        const config = await this.read(configPath);
-        if (!config.blockedTasks) {
-            config.blockedTasks = [];
-        }
-        // Remove existing entry for this task if present
-        config.blockedTasks = config.blockedTasks.filter(b => b.taskId !== taskId);
-        // Add new blocked task
-        config.blockedTasks.push({
-            taskId,
-            reason,
-            timestamp: new Date().toISOString(),
-        });
-        config.timestamp = new Date().toISOString();
-        await this.write(configPath, config);
-    }
-    /**
-     * Remove a blocked task (unblock)
-     * @param configPath - Path to config file
-     * @param taskId - ID of task to unblock
-     */
-    async removeBlockedTask(configPath, taskId) {
-        const config = await this.read(configPath);
-        if (config.blockedTasks) {
-            config.blockedTasks = config.blockedTasks.filter(b => b.taskId !== taskId);
-            config.timestamp = new Date().toISOString();
-            await this.write(configPath, config);
-        }
-    }
-    /**
-     * Get current implementation state
-     * @param configPath - Path to config file
-     * @returns State summary
-     */
-    async getState(configPath) {
-        const config = await this.read(configPath);
-        return {
-            currentTaskId: config.currentTask.id,
-            completedCount: config.completedTaskIds?.length ?? 0,
-            remainingCount: config.stats.remaining,
-            blockedCount: config.blockedTasks?.length ?? 0,
-            lastCompletedTaskId: config.lastCompletedTaskId,
-            lastCompletionTime: config.lastCompletedTaskId
-                ? config.completionTimestamps?.[config.lastCompletedTaskId]
-                : undefined,
-        };
-    }
-    /**
-     * Check if a task has been completed
-     * @param configPath - Path to config file
-     * @param taskId - Task ID to check
-     * @returns true if task is in completed list
-     */
-    async isTaskCompleted(configPath, taskId) {
-        const config = await this.read(configPath);
-        return config.completedTaskIds?.includes(taskId) ?? false;
-    }
-    /**
-     * Validate config structure
-     * @param config - Configuration to validate
-     * @throws Error if config is invalid
-     */
-    validateConfig(config) {
-        if (!config.commitStrategy) {
-            throw new Error('Config validation failed: commitStrategy is required');
-        }
-        if (!config.tasksPath) {
-            throw new Error('Config validation failed: tasksPath is required');
-        }
-        if (!config.currentTask) {
-            throw new Error('Config validation failed: currentTask is required');
-        }
-        if (!config.stats) {
-            throw new Error('Config validation failed: stats is required');
-        }
-        const validStrategies = ['per-task', 'per-5-tasks', 'per-phase', 'none'];
-        if (!validStrategies.includes(config.commitStrategy)) {
-            throw new Error(`Config validation failed: invalid commitStrategy "${config.commitStrategy}"`);
-        }
-    }
-    /**
-     * Migrate old config format to new format
-     * @param config - Old config format
-     * @returns Migrated config
-     */
-    migrateConfig(config) {
-        // If already has new fields, return as-is
-        if (config.completedTaskIds !== undefined) {
-            return config;
-        }
-        // Migrate from old format
-        const migrated = {
-            commitStrategy: config.commitStrategy ?? 'none',
-            tasksPath: config.tasksPath ?? '',
-            currentTask: config.currentTask ?? { id: 'initial', description: 'Initial Task', phase: 'initialization', completed: false },
-            stats: config.stats ?? { total: 0, completed: 0, remaining: 0, percentage: 0 },
-            timestamp: config.timestamp ?? new Date().toISOString(),
-            completedTaskIds: [],
-            completionTimestamps: {},
-            blockedTasks: [],
-        };
-        return migrated;
-    }
-    /**
-     * Create a resume checkpoint
-     * @param configPath - Path to config file
-     * @param currentTaskId - Current task being worked on
-     * @param phaseProgress - Progress by phase (phase name -> completed count)
-     */
-    async createResumeCheckpoint(configPath, currentTaskId, phaseProgress) {
-        const config = await this.read(configPath);
-        config.resumeCheckpoint = {
-            lastTaskId: currentTaskId,
-            phaseProgress,
-            sessionStartTime: new Date().toISOString(),
-        };
-        config.timestamp = new Date().toISOString();
-        await this.write(configPath, config);
-    }
-    /**
-     * Get the config file path for a PRD directory
-     * @param prdPath - Path to PRD directory
-     * @returns Path to config file
-     */
-    static getConfigPath(prdPath) {
-        return path.join(prdPath, '.clavix-implement-config.json');
-    }
-}
-//# sourceMappingURL=config-manager.js.map

package/dist/core/conversation-analyzer.d.ts

@@ -1,86 +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
- */
-import { Session } from '../types/session.js';
-/**
- * Analyzed conversation data
- */
-export interface ConversationAnalysis {
-    summary: string;
-    keyRequirements: string[];
-    technicalConstraints: string[];
-    successCriteria: string[];
-    outOfScope: string[];
-    additionalContext: string[];
-}
-/**
- * ConversationAnalyzer class
- *
- * Analyzes conversational sessions to extract structured requirements
- * suitable for PRD generation or AI prompting
- */
-export declare class ConversationAnalyzer {
-    /**
-     * Analyze a conversation session
-     *
-     * @param session - The session to analyze
-     * @returns Structured analysis of the conversation
-     */
-    analyze(session: Session): ConversationAnalysis;
-    /**
-     * Generate a mini-PRD from analyzed conversation
-     *
-     * @param session - The session
-     * @param analysis - The conversation analysis
-     * @returns Mini-PRD content
-     */
-    generateMiniPrd(session: Session, analysis: ConversationAnalysis): string;
-    /**
-     * Generate an optimized prompt for AI consumption
-     *
-     * @param session - The session
-     * @param analysis - The conversation analysis
-     * @returns Optimized prompt content
-     */
-    generateOptimizedPrompt(session: Session, analysis: ConversationAnalysis): string;
-    /**
-     * Extract a summary from the conversation
-     */
-    private extractSummary;
-    /**
-     * Extract key requirements from messages
-     */
-    private extractKeyRequirements;
-    /**
-     * Extract technical constraints from messages
-     */
-    private extractTechnicalConstraints;
-    /**
-     * Extract success criteria from messages
-     */
-    private extractSuccessCriteria;
-    /**
-     * Extract out-of-scope items from messages
-     */
-    private extractOutOfScope;
-    /**
-     * Extract additional context from messages
-     */
-    private extractAdditionalContext;
-    /**
-     * Clean up extracted text
-     */
-    private cleanupText;
-    /**
-     * Check if message matches any pattern
-     */
-    private matchesAnyPattern;
-}
-//# sourceMappingURL=conversation-analyzer.d.ts.map