clavix 2.3.0 → 2.4.0

package/dist/core 2/session-manager.js

@@ -0,0 +1,403 @@
+"use strict";
+/**
+ * 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`
+ */
+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.SessionManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const file_system_1 = require("../utils/file-system");
+// Use require for uuid to avoid Jest ESM issues
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const { v4: uuidv4 } = require('uuid');
+/**
+ * SessionManager class
+ *
+ * Manages all session-related operations including creation, storage,
+ * retrieval, listing, and search functionality.
+ */
+class SessionManager {
+    constructor(sessionsDir) {
+        this.defaultSessionsDir = '.clavix/sessions';
+        this.sessionsDir = sessionsDir || this.defaultSessionsDir;
+    }
+    /**
+     * Create a new session
+     *
+     * @param options - Session creation options
+     * @returns The created session
+     */
+    async createSession(options = {}) {
+        const now = new Date();
+        const session = {
+            id: uuidv4(),
+            projectName: options.projectName || this.generateDefaultProjectName(),
+            agent: options.agent || 'Claude Code',
+            created: now,
+            updated: now,
+            status: 'active',
+            messages: [],
+            tags: options.tags,
+            description: options.description,
+        };
+        await this.saveSession(session);
+        return session;
+    }
+    /**
+     * Get a session by ID
+     *
+     * @param sessionId - The session ID
+     * @returns The session, or null if not found
+     */
+    async getSession(sessionId) {
+        try {
+            const sessionPath = this.getSessionPath(sessionId);
+            const exists = await fs.pathExists(sessionPath);
+            if (!exists) {
+                return null;
+            }
+            const serialized = await fs.readJSON(sessionPath);
+            return this.deserializeSession(serialized);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Save a session to disk
+     *
+     * @param session - The session to save
+     */
+    async saveSession(session) {
+        await file_system_1.FileSystem.ensureDir(this.sessionsDir);
+        const sessionPath = this.getSessionPath(session.id);
+        const serialized = this.serializeSession(session);
+        // Use atomic write to prevent corruption
+        await file_system_1.FileSystem.writeFileAtomic(sessionPath, JSON.stringify(serialized, null, 2));
+    }
+    /**
+     * Update a session
+     *
+     * @param sessionId - The session ID
+     * @param updates - Partial session updates
+     * @returns The updated session, or null if not found
+     */
+    async updateSession(sessionId, updates) {
+        const session = await this.getSession(sessionId);
+        if (!session) {
+            return null;
+        }
+        const updatedSession = {
+            ...session,
+            ...updates,
+            id: session.id,
+            created: session.created,
+            updated: new Date(),
+        };
+        await this.saveSession(updatedSession);
+        return updatedSession;
+    }
+    /**
+     * Delete a session
+     *
+     * @param sessionId - The session ID
+     * @returns True if deleted, false if not found
+     */
+    async deleteSession(sessionId) {
+        const sessionPath = this.getSessionPath(sessionId);
+        const exists = await fs.pathExists(sessionPath);
+        if (!exists) {
+            return false;
+        }
+        await fs.remove(sessionPath);
+        return true;
+    }
+    /**
+     * 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
+     */
+    async addMessage(sessionId, role, content) {
+        const session = await this.getSession(sessionId);
+        if (!session) {
+            return null;
+        }
+        const message = {
+            role,
+            content,
+            timestamp: new Date(),
+        };
+        session.messages.push(message);
+        session.updated = new Date();
+        await this.saveSession(session);
+        return session;
+    }
+    /**
+     * List all sessions with optional filtering
+     *
+     * @param filter - Optional filter criteria
+     * @returns Array of session metadata
+     */
+    async listSessions(filter) {
+        await file_system_1.FileSystem.ensureDir(this.sessionsDir);
+        const files = await fs.readdir(this.sessionsDir);
+        const sessionFiles = files.filter((f) => f.endsWith('.json'));
+        const sessions = [];
+        for (const file of sessionFiles) {
+            try {
+                const sessionPath = path.join(this.sessionsDir, file);
+                const serialized = await fs.readJSON(sessionPath);
+                const metadata = this.extractMetadata(serialized);
+                // Apply filters
+                if (filter && !this.matchesFilter(metadata, filter)) {
+                    continue;
+                }
+                sessions.push(metadata);
+            }
+            catch {
+                // Skip corrupted session files
+                continue;
+            }
+        }
+        // Sort by updated date (most recent first)
+        sessions.sort((a, b) => {
+            return new Date(b.updated).getTime() - new Date(a.updated).getTime();
+        });
+        return sessions;
+    }
+    /**
+     * Search sessions by keyword
+     *
+     * Searches in project name, description, tags, and message content
+     *
+     * @param keyword - Search keyword
+     * @returns Array of matching session metadata
+     */
+    async searchSessions(keyword) {
+        await file_system_1.FileSystem.ensureDir(this.sessionsDir);
+        const files = await fs.readdir(this.sessionsDir);
+        const sessionFiles = files.filter((f) => f.endsWith('.json'));
+        const matches = [];
+        const lowerKeyword = keyword.toLowerCase();
+        for (const file of sessionFiles) {
+            try {
+                const sessionPath = path.join(this.sessionsDir, file);
+                const serialized = await fs.readJSON(sessionPath);
+                // Search in project name
+                if (serialized.projectName.toLowerCase().includes(lowerKeyword)) {
+                    matches.push(this.extractMetadata(serialized));
+                    continue;
+                }
+                // Search in description
+                if (serialized.description?.toLowerCase().includes(lowerKeyword)) {
+                    matches.push(this.extractMetadata(serialized));
+                    continue;
+                }
+                // Search in tags
+                if (serialized.tags?.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
+                    matches.push(this.extractMetadata(serialized));
+                    continue;
+                }
+                // Search in message content
+                const hasMessageMatch = serialized.messages.some((msg) => msg.content.toLowerCase().includes(lowerKeyword));
+                if (hasMessageMatch) {
+                    matches.push(this.extractMetadata(serialized));
+                }
+            }
+            catch {
+                // Skip corrupted session files
+                continue;
+            }
+        }
+        // Sort by updated date (most recent first)
+        matches.sort((a, b) => {
+            return new Date(b.updated).getTime() - new Date(a.updated).getTime();
+        });
+        return matches;
+    }
+    /**
+     * Get the most recent active session
+     *
+     * @returns The active session, or null if none exists
+     */
+    async getActiveSession() {
+        const activeSessions = await this.listSessions({ status: 'active' });
+        if (activeSessions.length === 0) {
+            return null;
+        }
+        // Return the most recently updated active session
+        return this.getSession(activeSessions[0].id);
+    }
+    /**
+     * Mark a session as completed
+     *
+     * @param sessionId - The session ID
+     * @returns The updated session, or null if not found
+     */
+    async completeSession(sessionId) {
+        return this.updateSession(sessionId, { status: 'completed' });
+    }
+    /**
+     * Mark a session as archived
+     *
+     * @param sessionId - The session ID
+     * @returns The updated session, or null if not found
+     */
+    async archiveSession(sessionId) {
+        return this.updateSession(sessionId, { status: 'archived' });
+    }
+    /**
+     * Get the path to a session file
+     */
+    getSessionPath(sessionId) {
+        return path.join(this.sessionsDir, `${sessionId}.json`);
+    }
+    /**
+     * Generate a default project name based on timestamp
+     */
+    generateDefaultProjectName() {
+        const date = new Date();
+        const timestamp = date.toISOString().split('T')[0]; // YYYY-MM-DD
+        return `session-${timestamp}`;
+    }
+    /**
+     * Serialize a session for file storage
+     */
+    serializeSession(session) {
+        return {
+            id: session.id,
+            projectName: session.projectName,
+            agent: session.agent,
+            created: session.created.toISOString(),
+            updated: session.updated.toISOString(),
+            status: session.status,
+            messages: session.messages.map((msg) => ({
+                role: msg.role,
+                content: msg.content,
+                timestamp: msg.timestamp.toISOString(),
+            })),
+            tags: session.tags,
+            description: session.description,
+        };
+    }
+    /**
+     * Deserialize a session from file storage
+     */
+    deserializeSession(serialized) {
+        return {
+            id: serialized.id,
+            projectName: serialized.projectName,
+            agent: serialized.agent,
+            created: new Date(serialized.created),
+            updated: new Date(serialized.updated),
+            status: serialized.status,
+            messages: serialized.messages.map((msg) => ({
+                role: msg.role,
+                content: msg.content,
+                timestamp: new Date(msg.timestamp),
+            })),
+            tags: serialized.tags,
+            description: serialized.description,
+        };
+    }
+    /**
+     * Extract metadata from a serialized session
+     */
+    extractMetadata(serialized) {
+        return {
+            id: serialized.id,
+            projectName: serialized.projectName,
+            agent: serialized.agent,
+            created: serialized.created,
+            updated: serialized.updated,
+            status: serialized.status,
+            messageCount: serialized.messages.length,
+            tags: serialized.tags,
+            description: serialized.description,
+        };
+    }
+    /**
+     * Check if session metadata matches filter criteria
+     */
+    matchesFilter(metadata, filter) {
+        // Status filter
+        if (filter.status && metadata.status !== filter.status) {
+            return false;
+        }
+        // Project name filter
+        if (filter.projectName && metadata.projectName !== filter.projectName) {
+            return false;
+        }
+        // Agent filter
+        if (filter.agent && metadata.agent !== filter.agent) {
+            return false;
+        }
+        // Tags filter (session must have ALL specified tags)
+        if (filter.tags && filter.tags.length > 0) {
+            if (!metadata.tags || metadata.tags.length === 0) {
+                return false;
+            }
+            const hasAllTags = filter.tags.every((tag) => metadata.tags.includes(tag));
+            if (!hasAllTags) {
+                return false;
+            }
+        }
+        // Date range filters
+        const updatedDate = new Date(metadata.updated);
+        if (filter.startDate && updatedDate < filter.startDate) {
+            return false;
+        }
+        if (filter.endDate && updatedDate > filter.endDate) {
+            return false;
+        }
+        return true;
+    }
+}
+exports.SessionManager = SessionManager;
+//# sourceMappingURL=session-manager.js.map

package/dist/core 2/task-manager.d.ts

@@ -0,0 +1,155 @@
+/**
+ * TaskManager - Manages PRD-based task generation and execution
+ *
+ * This class handles:
+ * - Analyzing PRD documents
+ * - Generating CLEAR-optimized task breakdowns
+ * - Reading/writing tasks.md with checkbox format
+ * - Tracking task completion state
+ * - Managing session resume capability
+ */
+export type PrdSourceType = 'auto' | 'full' | 'quick' | 'mini' | 'prompt';
+/**
+ * Represents a single task in the implementation plan
+ */
+export interface Task {
+    id: string;
+    description: string;
+    phase: string;
+    completed: boolean;
+    prdReference?: string;
+}
+/**
+ * Represents a phase/section of tasks
+ */
+export interface TaskPhase {
+    name: string;
+    tasks: Task[];
+}
+/**
+ * Options for task generation
+ */
+export interface TaskGenerationOptions {
+    maxTasksPerPhase?: number;
+    includeReferences?: boolean;
+    clearMode?: 'fast' | 'deep';
+    source?: PrdSourceType;
+}
+/**
+ * Result of task generation
+ */
+export interface TaskGenerationResult {
+    phases: TaskPhase[];
+    totalTasks: number;
+    outputPath: string;
+    sourcePath: string;
+    sourceType: Exclude<PrdSourceType, 'auto'>;
+}
+/**
+ * TaskManager class
+ *
+ * Generates and manages implementation tasks from PRD documents
+ */
+export declare class TaskManager {
+    private readonly optimizer;
+    constructor();
+    /**
+     * Generate tasks.md from PRD
+     *
+     * @param prdPath - Path to the PRD directory
+     * @param options - Generation options
+     * @returns Task generation result
+     */
+    generateTasksFromPrd(prdPath: string, options?: TaskGenerationOptions): Promise<TaskGenerationResult>;
+    /**
+     * Find the PRD file in a directory
+     */
+    private resolvePrdFile;
+    /**
+     * Analyze PRD content and generate task breakdown
+     */
+    private analyzePrdAndGenerateTasks;
+    private getSectionByAliases;
+    private generatePhasesFromCoreFeatures;
+    private extractListItems;
+    private buildFeatureTaskDescriptions;
+    private formatInlineText;
+    private toTitleCase;
+    private injectTechnicalConstraintsTask;
+    private appendSuccessCriteriaPhase;
+    /**
+     * Parse PRD into sections
+     */
+    private parsePrdSections;
+    /**
+     * Normalize section name for consistent lookup
+     */
+    private normalizeSectionName;
+    /**
+     * Generate tasks from requirements section
+     */
+    private generateTasksFromRequirements;
+    /**
+     * Generate a phase from a feature description
+     */
+    private generatePhaseFromFeature;
+    /**
+     * Convert behavior description to task description
+     */
+    private convertBehaviorToTask;
+    /**
+     * Generate default phases when no structure found
+     */
+    private generateDefaultPhases;
+    /**
+     * Sanitize ID for use in task IDs
+     */
+    private sanitizeId;
+    /**
+     * Optimize task description using CLEAR principles
+     */
+    private optimizeTaskDescription;
+    /**
+     * Write tasks to tasks.md file
+     */
+    private writeTasksFile;
+    /**
+     * Read tasks from tasks.md file
+     */
+    readTasksFile(tasksPath: string): Promise<TaskPhase[]>;
+    /**
+     * Parse tasks.md content into TaskPhase objects
+     */
+    private parseTasksFile;
+    /**
+     * Find the first incomplete task
+     */
+    findFirstIncompleteTask(phases: TaskPhase[]): Task | null;
+    /**
+     * Mark a task as completed in the tasks.md file
+     */
+    markTaskCompleted(tasksPath: string, taskId: string): Promise<void>;
+    /**
+     * Escape special regex characters
+     */
+    private escapeRegex;
+    /**
+     * Get task completion statistics
+     */
+    getTaskStats(phases: TaskPhase[]): {
+        total: number;
+        completed: number;
+        remaining: number;
+        percentage: number;
+    };
+    /**
+     * Find PRD directory from current working directory
+     */
+    findPrdDirectory(projectName?: string): Promise<string>;
+    /**
+     * Check if directory has a PRD file
+     */
+    hasPrdFile(dirPath: string): Promise<boolean>;
+    detectAvailableSources(dirPath: string): Promise<Array<Exclude<PrdSourceType, 'auto'>>>;
+}
+//# sourceMappingURL=task-manager.d.ts.map