clavix 2.3.1 → 2.4.1

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

@@ -0,0 +1,338 @@
+"use strict";
+/**
+ * ArchiveManager - Manages archival of completed PRD projects
+ *
+ * This class handles:
+ * - Listing active and archived PRD projects
+ * - Checking task completion status
+ * - Moving completed projects to archive
+ * - Managing archive directory structure
+ */
+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.ArchiveManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const task_manager_1 = require("./task-manager");
+/**
+ * ArchiveManager class
+ *
+ * Manages archival of completed PRD projects
+ */
+class ArchiveManager {
+    constructor() {
+        this.outputsDir = '.clavix/outputs';
+        this.archiveDir = '.clavix/outputs/archive';
+        this.taskManager = new task_manager_1.TaskManager();
+    }
+    /**
+     * List all PRD projects in outputs directory
+     *
+     * @param includeArchived - Include archived projects in results
+     * @returns Array of PRD projects
+     */
+    async listPrdProjects(includeArchived = false) {
+        const projects = [];
+        // Check if outputs directory exists
+        if (!(await fs.pathExists(this.outputsDir))) {
+            return projects;
+        }
+        const dirs = await fs.readdir(this.outputsDir);
+        for (const dir of dirs) {
+            // Skip archive directory when listing active projects
+            if (dir === 'archive' && !includeArchived) {
+                continue;
+            }
+            const fullPath = path.join(this.outputsDir, dir);
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory()) {
+                // Check if it has a PRD file
+                if (await this.hasPrdFile(fullPath)) {
+                    const taskStatus = await this.checkTasksStatus(fullPath);
+                    projects.push({
+                        name: dir,
+                        path: fullPath,
+                        taskStatus,
+                        modifiedTime: stat.mtime,
+                        isArchived: false,
+                    });
+                }
+            }
+        }
+        // Add archived projects if requested
+        if (includeArchived) {
+            const archivedProjects = await this.listArchivedProjects();
+            projects.push(...archivedProjects);
+        }
+        // Sort by modification time (most recent first)
+        projects.sort((a, b) => b.modifiedTime.getTime() - a.modifiedTime.getTime());
+        return projects;
+    }
+    /**
+     * List archived PRD projects
+     *
+     * @returns Array of archived PRD projects
+     */
+    async listArchivedProjects() {
+        const projects = [];
+        if (!(await fs.pathExists(this.archiveDir))) {
+            return projects;
+        }
+        const dirs = await fs.readdir(this.archiveDir);
+        for (const dir of dirs) {
+            const fullPath = path.join(this.archiveDir, dir);
+            const stat = await fs.stat(fullPath);
+            if (stat.isDirectory()) {
+                if (await this.hasPrdFile(fullPath)) {
+                    const taskStatus = await this.checkTasksStatus(fullPath);
+                    projects.push({
+                        name: dir,
+                        path: fullPath,
+                        taskStatus,
+                        modifiedTime: stat.mtime,
+                        isArchived: true,
+                    });
+                }
+            }
+        }
+        return projects;
+    }
+    /**
+     * Get PRD projects that are ready to archive (all tasks completed)
+     *
+     * @returns Array of archivable PRD projects
+     */
+    async getArchivablePrds() {
+        const allProjects = await this.listPrdProjects(false);
+        // Filter to only projects with all tasks completed
+        return allProjects.filter((project) => project.taskStatus.hasTasksFile && project.taskStatus.allCompleted);
+    }
+    /**
+     * Check task completion status for a PRD project
+     *
+     * @param projectPath - Path to the PRD project directory
+     * @returns Task status information
+     */
+    async checkTasksStatus(projectPath) {
+        const tasksPath = path.join(projectPath, 'tasks.md');
+        // Check if tasks.md exists
+        if (!(await fs.pathExists(tasksPath))) {
+            return {
+                hasTasksFile: false,
+                total: 0,
+                completed: 0,
+                remaining: 0,
+                percentage: 0,
+                allCompleted: false,
+            };
+        }
+        try {
+            // Read and parse tasks
+            const phases = await this.taskManager.readTasksFile(tasksPath);
+            const stats = this.taskManager.getTaskStats(phases);
+            return {
+                hasTasksFile: true,
+                total: stats.total,
+                completed: stats.completed,
+                remaining: stats.remaining,
+                percentage: stats.percentage,
+                allCompleted: stats.remaining === 0 && stats.total > 0,
+            };
+        }
+        catch {
+            // If parsing fails, return error status
+            return {
+                hasTasksFile: true,
+                total: 0,
+                completed: 0,
+                remaining: 0,
+                percentage: 0,
+                allCompleted: false,
+            };
+        }
+    }
+    /**
+     * Archive a PRD project (move to archive directory)
+     *
+     * @param projectName - Name of the project to archive
+     * @param force - Force archive even if tasks are incomplete
+     * @returns Success status and message
+     */
+    async archiveProject(projectName, force = false) {
+        const sourcePath = path.join(this.outputsDir, projectName);
+        // Check if project exists
+        if (!(await fs.pathExists(sourcePath))) {
+            return {
+                success: false,
+                message: `Project not found: ${projectName}`,
+            };
+        }
+        // Check if it's already in archive
+        if (sourcePath.includes('/archive/')) {
+            return {
+                success: false,
+                message: `Project is already archived: ${projectName}`,
+            };
+        }
+        // Check task status unless forced
+        if (!force) {
+            const taskStatus = await this.checkTasksStatus(sourcePath);
+            if (!taskStatus.hasTasksFile) {
+                return {
+                    success: false,
+                    message: `Project has no tasks.md file. Use --force to archive anyway.`,
+                };
+            }
+            if (!taskStatus.allCompleted) {
+                return {
+                    success: false,
+                    message: `Project has ${taskStatus.remaining} incomplete task(s). Use --force to archive anyway.`,
+                };
+            }
+        }
+        // Ensure archive directory exists
+        await fs.ensureDir(this.archiveDir);
+        // Move project to archive
+        const destPath = path.join(this.archiveDir, projectName);
+        // Check if destination already exists
+        if (await fs.pathExists(destPath)) {
+            return {
+                success: false,
+                message: `Archive already contains a project named: ${projectName}`,
+            };
+        }
+        try {
+            await fs.move(sourcePath, destPath);
+            return {
+                success: true,
+                message: `Successfully archived ${projectName} to ${destPath}`,
+            };
+        }
+        catch (error) {
+            const { getErrorMessage } = await Promise.resolve().then(() => __importStar(require('../utils/error-utils.js')));
+            return {
+                success: false,
+                message: `Failed to archive project: ${getErrorMessage(error)}`,
+            };
+        }
+    }
+    /**
+     * Restore an archived project back to active outputs
+     *
+     * @param projectName - Name of the archived project to restore
+     * @returns Success status and message
+     */
+    async restoreProject(projectName) {
+        const sourcePath = path.join(this.archiveDir, projectName);
+        // Check if archived project exists
+        if (!(await fs.pathExists(sourcePath))) {
+            return {
+                success: false,
+                message: `Archived project not found: ${projectName}`,
+            };
+        }
+        const destPath = path.join(this.outputsDir, projectName);
+        // Check if destination already exists
+        if (await fs.pathExists(destPath)) {
+            return {
+                success: false,
+                message: `Active outputs already contains a project named: ${projectName}`,
+            };
+        }
+        try {
+            await fs.move(sourcePath, destPath);
+            return {
+                success: true,
+                message: `Successfully restored ${projectName} to ${destPath}`,
+            };
+        }
+        catch (error) {
+            const { getErrorMessage } = await Promise.resolve().then(() => __importStar(require('../utils/error-utils.js')));
+            return {
+                success: false,
+                message: `Failed to restore project: ${getErrorMessage(error)}`,
+            };
+        }
+    }
+    /**
+     * Check if a directory contains a PRD file
+     */
+    async hasPrdFile(dirPath) {
+        const possibleFiles = [
+            'PRD.md',
+            'full-prd.md',
+            'prd.md',
+            'Full-PRD.md',
+            'FULL_PRD.md',
+            'FULL-PRD.md',
+            'QUICK_PRD.md',
+        ];
+        for (const filename of possibleFiles) {
+            if (await fs.pathExists(path.join(dirPath, filename))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Get incomplete tasks for a project (for display purposes)
+     *
+     * @param projectPath - Path to the PRD project
+     * @returns Array of incomplete task descriptions
+     */
+    async getIncompleteTasks(projectPath) {
+        const tasksPath = path.join(projectPath, 'tasks.md');
+        if (!(await fs.pathExists(tasksPath))) {
+            return [];
+        }
+        try {
+            const phases = await this.taskManager.readTasksFile(tasksPath);
+            const incompleteTasks = [];
+            for (const phase of phases) {
+                for (const task of phase.tasks) {
+                    if (!task.completed) {
+                        incompleteTasks.push(`[${phase.name}] ${task.description}`);
+                    }
+                }
+            }
+            return incompleteTasks;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.ArchiveManager = ArchiveManager;
+//# sourceMappingURL=archive-manager.js.map

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

@@ -0,0 +1,86 @@
+/**
+ * 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';
+/**
+ * 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

package/dist/core 2/doc-injector.d.ts

@@ -0,0 +1,51 @@
+export interface ManagedBlockOptions {
+    startMarker: string;
+    endMarker: string;
+    content: string;
+    createIfMissing?: boolean;
+    validateMarkdown?: boolean;
+}
+/**
+ * DocInjector - manages injection and updating of managed blocks in documentation files
+ */
+export declare class DocInjector {
+    private static readonly DEFAULT_START_MARKER;
+    private static readonly DEFAULT_END_MARKER;
+    /**
+     * Inject or update managed block in a file
+     */
+    static injectBlock(filePath: string, content: string, options?: Partial<ManagedBlockOptions>): Promise<void>;
+    /**
+     * Detect if file contains managed block
+     */
+    static hasBlock(filePath: string, startMarker?: string, endMarker?: string): Promise<boolean>;
+    /**
+     * Extract content from managed block
+     */
+    static extractBlock(filePath: string, startMarker?: string, endMarker?: string): Promise<string | null>;
+    /**
+     * Remove managed block from file
+     */
+    static removeBlock(filePath: string, startMarker?: string, endMarker?: string): Promise<void>;
+    /**
+     * Wrap content with markers
+     */
+    private static wrapContent;
+    /**
+     * Escape special regex characters
+     */
+    private static escapeRegex;
+    /**
+     * Basic markdown validation
+     */
+    private static validateMarkdown;
+    /**
+     * Create default AGENTS.md content
+     */
+    static getDefaultAgentsContent(): string;
+    /**
+     * Create default CLAUDE.md content for Claude Code
+     */
+    static getDefaultClaudeContent(): string;
+}
+//# sourceMappingURL=doc-injector.d.ts.map