clavix 4.12.0 → 5.0.0

package/dist/cli/commands/list.js

@@ -1,217 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import chalk from 'chalk';
-import fs from 'fs-extra';
-import * as path from 'path';
-import { SessionManager } from '../../core/session-manager.js';
-export default class List extends Command {
-    static description = 'List sessions and outputs';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --sessions',
-        '<%= config.bin %> <%= command.id %> --outputs',
-        '<%= config.bin %> <%= command.id %> --project my-feature',
-    ];
-    static flags = {
-        sessions: Flags.boolean({
-            char: 's',
-            description: 'List only sessions',
-            default: false,
-        }),
-        outputs: Flags.boolean({
-            char: 'o',
-            description: 'List only outputs',
-            default: false,
-        }),
-        archived: Flags.boolean({
-            char: 'a',
-            description: 'Include archived projects in outputs',
-            default: false,
-        }),
-        project: Flags.string({
-            char: 'p',
-            description: 'Filter by project name',
-        }),
-        limit: Flags.integer({
-            char: 'l',
-            description: 'Limit number of results',
-            default: 20,
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(List);
-        const clavixDir = path.join(process.cwd(), '.clavix');
-        if (!fs.existsSync(clavixDir)) {
-            this.error(chalk.red('No .clavix directory found.') +
-                '\n' +
-                chalk.yellow('Run ') +
-                chalk.cyan('clavix init') +
-                chalk.yellow(' to initialize Clavix in this project.'));
-        }
-        // If no specific flag is set, show both
-        const showSessions = flags.sessions || (!flags.outputs && !flags.sessions);
-        const showOutputs = flags.outputs || (!flags.outputs && !flags.sessions);
-        if (showSessions) {
-            await this.listSessions(flags.project, flags.limit);
-        }
-        if (showOutputs) {
-            if (showSessions) {
-                this.log(''); // Add spacing
-            }
-            await this.listOutputs(flags.project, flags.limit, flags.archived);
-        }
-    }
-    async listSessions(projectFilter, limit) {
-        this.log(chalk.bold.cyan('📋 Sessions\n'));
-        const sessionManager = new SessionManager();
-        const sessions = await sessionManager.listSessions();
-        if (sessions.length === 0) {
-            this.log(chalk.gray('  No sessions found.'));
-            this.log(chalk.gray('  Run ') + chalk.cyan('clavix start') + chalk.gray(' to create a new session.'));
-            return;
-        }
-        // Filter by project if specified
-        let filteredSessions = sessions;
-        if (projectFilter) {
-            filteredSessions = sessions.filter(s => s.projectName?.toLowerCase().includes(projectFilter.toLowerCase()));
-        }
-        // Sort by updated date (most recent first)
-        filteredSessions.sort((a, b) => new Date(b.updated).getTime() - new Date(a.updated).getTime());
-        // Apply limit
-        if (limit) {
-            filteredSessions = filteredSessions.slice(0, limit);
-        }
-        if (filteredSessions.length === 0) {
-            this.log(chalk.gray(`  No sessions found matching "${projectFilter}".`));
-            return;
-        }
-        // Display sessions in a table-like format
-        filteredSessions.forEach((session, index) => {
-            const isActive = session.status === 'active';
-            const statusIcon = isActive ? '🟢' : '⚪';
-            const projectName = session.projectName || 'untitled';
-            const created = new Date(session.created).toLocaleDateString();
-            const updated = new Date(session.updated).toLocaleString();
-            const messageCount = session.messageCount || 0;
-            this.log(`  ${statusIcon} ${chalk.bold(projectName)} ${chalk.gray(`(${session.id})`)}` +
-                `\n     ${chalk.gray('Created:')} ${created} ${chalk.gray('│')} ` +
-                `${chalk.gray('Updated:')} ${updated}` +
-                `\n     ${chalk.gray('Messages:')} ${messageCount} ${chalk.gray('│')} ` +
-                `${chalk.gray('Status:')} ${isActive ? chalk.green('active') : chalk.gray('completed')}` +
-                (index < filteredSessions.length - 1 ? '\n' : ''));
-        });
-        this.log('');
-        this.log(chalk.gray(`  Showing ${filteredSessions.length} of ${sessions.length} sessions`));
-        if (sessions.length > filteredSessions.length && !limit) {
-            this.log(chalk.gray(`  Use ${chalk.cyan('--limit N')} to show more results`));
-        }
-    }
-    async listOutputs(projectFilter, limit, includeArchived = false) {
-        this.log(chalk.bold.cyan('📁 Outputs\n'));
-        const outputsDir = path.join(process.cwd(), '.clavix', 'outputs');
-        if (!fs.existsSync(outputsDir)) {
-            this.log(chalk.gray('  No outputs found.'));
-            this.log(chalk.gray('  Run ') + chalk.cyan('clavix prd') + chalk.gray(' or ') + chalk.cyan('clavix summarize') + chalk.gray(' to generate outputs.'));
-            return;
-        }
-        const projectDirs = fs.readdirSync(outputsDir).filter(name => {
-            const fullPath = path.join(outputsDir, name);
-            // Skip archive directory in main listing
-            if (name === 'archive' && !includeArchived) {
-                return false;
-            }
-            return fs.statSync(fullPath).isDirectory();
-        });
-        if (projectDirs.length === 0) {
-            this.log(chalk.gray('  No outputs found.'));
-            return;
-        }
-        // Filter by project if specified
-        let filteredDirs = projectDirs;
-        if (projectFilter) {
-            filteredDirs = projectDirs.filter(dir => dir.toLowerCase().includes(projectFilter.toLowerCase()));
-        }
-        // Sort by modification time (most recent first)
-        filteredDirs.sort((a, b) => {
-            const aPath = path.join(outputsDir, a);
-            const bPath = path.join(outputsDir, b);
-            return fs.statSync(bPath).mtime.getTime() - fs.statSync(aPath).mtime.getTime();
-        });
-        // Apply limit
-        if (limit) {
-            filteredDirs = filteredDirs.slice(0, limit);
-        }
-        if (filteredDirs.length === 0) {
-            this.log(chalk.gray(`  No outputs found matching "${projectFilter}".`));
-            return;
-        }
-        // Display outputs
-        filteredDirs.forEach((projectDir, index) => {
-            const projectPath = path.join(outputsDir, projectDir);
-            const files = fs.readdirSync(projectPath).filter(f => f.endsWith('.md'));
-            const modified = fs.statSync(projectPath).mtime.toLocaleDateString();
-            this.log(`  📄 ${chalk.bold(projectDir)}` +
-                `\n     ${chalk.gray('Path:')} ${chalk.dim(path.relative(process.cwd(), projectPath))}` +
-                `\n     ${chalk.gray('Files:')} ${files.join(', ')}` +
-                `\n     ${chalk.gray('Modified:')} ${modified}` +
-                (index < filteredDirs.length - 1 ? '\n' : ''));
-        });
-        this.log('');
-        this.log(chalk.gray(`  Showing ${filteredDirs.length} of ${projectDirs.length} output directories`));
-        if (projectDirs.length > filteredDirs.length && !limit) {
-            this.log(chalk.gray(`  Use ${chalk.cyan('--limit N')} to show more results`));
-        }
-        // Show archived projects if flag is set
-        if (includeArchived) {
-            await this.listArchivedOutputs(projectFilter, limit);
-        }
-    }
-    async listArchivedOutputs(projectFilter, limit) {
-        const archiveDir = path.join(process.cwd(), '.clavix', 'outputs', 'archive');
-        if (!fs.existsSync(archiveDir)) {
-            return; // No archived projects
-        }
-        const archivedDirs = fs.readdirSync(archiveDir).filter(name => {
-            const fullPath = path.join(archiveDir, name);
-            return fs.statSync(fullPath).isDirectory();
-        });
-        if (archivedDirs.length === 0) {
-            return; // No archived projects
-        }
-        // Filter by project if specified
-        let filteredDirs = archivedDirs;
-        if (projectFilter) {
-            filteredDirs = archivedDirs.filter(dir => dir.toLowerCase().includes(projectFilter.toLowerCase()));
-        }
-        // Sort by modification time (most recent first)
-        filteredDirs.sort((a, b) => {
-            const aPath = path.join(archiveDir, a);
-            const bPath = path.join(archiveDir, b);
-            return fs.statSync(bPath).mtime.getTime() - fs.statSync(aPath).mtime.getTime();
-        });
-        // Apply limit
-        if (limit) {
-            filteredDirs = filteredDirs.slice(0, limit);
-        }
-        if (filteredDirs.length === 0) {
-            return; // No matching archived projects
-        }
-        // Display archived section header
-        this.log('');
-        this.log(chalk.bold.cyan('📦 Archived Outputs\n'));
-        // Display archived outputs
-        filteredDirs.forEach((projectDir, index) => {
-            const projectPath = path.join(archiveDir, projectDir);
-            const files = fs.readdirSync(projectPath).filter(f => f.endsWith('.md'));
-            const modified = fs.statSync(projectPath).mtime.toLocaleDateString();
-            this.log(`  📦 ${chalk.bold(projectDir)} ${chalk.gray('(archived)')}` +
-                `\n     ${chalk.gray('Path:')} ${chalk.dim(path.relative(process.cwd(), projectPath))}` +
-                `\n     ${chalk.gray('Files:')} ${files.join(', ')}` +
-                `\n     ${chalk.gray('Modified:')} ${modified}` +
-                (index < filteredDirs.length - 1 ? '\n' : ''));
-        });
-        this.log('');
-        this.log(chalk.gray(`  Showing ${filteredDirs.length} of ${archivedDirs.length} archived directories`));
-        this.log(chalk.gray(`  Use ${chalk.cyan('clavix archive --restore <project>')} to restore a project`));
-    }
-}
-//# sourceMappingURL=list.js.map

package/dist/cli/commands/plan.d.ts

@@ -1,21 +0,0 @@
-import { Command } from '@oclif/core';
-export default class Plan extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'prd-path': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        session: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'active-session': import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        source: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        'max-tasks': import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
-        overwrite: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
-    run(): Promise<void>;
-    private validateSessionFlags;
-    private prepareArtifactsFromSession;
-    private resolveProjectDirectory;
-    private sanitizeProjectName;
-    private isInteractive;
-}
-//# sourceMappingURL=plan.d.ts.map

package/dist/cli/commands/plan.js

@@ -1,297 +0,0 @@
-import { Command, Flags } from '@oclif/core';
-import chalk from 'chalk';
-import inquirer from 'inquirer';
-import fs from 'fs-extra';
-import * as path from 'path';
-import { TaskManager } from '../../core/task-manager.js';
-import { SessionManager } from '../../core/session-manager.js';
-import { ConversationAnalyzer } from '../../core/conversation-analyzer.js';
-import { FileSystem } from '../../utils/file-system.js';
-import { AgentErrorMessages } from '../../utils/agent-error-messages.js';
-export default class Plan extends Command {
-    static description = 'Generate implementation task breakdown from PRD';
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '<%= config.bin %> <%= command.id %> --project my-app',
-        '<%= config.bin %> <%= command.id %> --prd-path .clavix/outputs/my-project',
-        '<%= config.bin %> <%= command.id %> --session 1234-5678',
-    ];
-    static flags = {
-        project: Flags.string({
-            char: 'p',
-            description: 'PRD project name (defaults to most recent)',
-        }),
-        'prd-path': Flags.string({
-            description: 'Direct path to PRD directory',
-        }),
-        session: Flags.string({
-            description: 'Session ID to plan from (generates mini-prd.md automatically)',
-        }),
-        'active-session': Flags.boolean({
-            description: 'Use the most recent active session as input',
-            default: false,
-        }),
-        source: Flags.string({
-            description: 'Preferred PRD source (auto|full|quick|mini|prompt)',
-            options: ['auto', 'full', 'quick', 'mini', 'prompt'],
-            default: 'auto',
-        }),
-        'max-tasks': Flags.integer({
-            description: 'Maximum tasks per phase',
-            default: 20,
-        }),
-        overwrite: Flags.boolean({
-            char: 'o',
-            description: 'Overwrite existing tasks.md file',
-            default: false,
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(Plan);
-        console.log(chalk.bold.cyan('\nTask Plan Generator\n'));
-        console.log(chalk.gray('Analyzing PRD and generating implementation tasks...\n'));
-        try {
-            this.validateSessionFlags(flags.session, flags['active-session']);
-            const manager = new TaskManager();
-            const sourcePreference = (flags.source ?? 'auto');
-            let projectName = null;
-            let prdPath = flags['prd-path'] ? path.resolve(flags['prd-path']) : null;
-            let generatedFromSession = false;
-            const generatedArtifacts = [];
-            if (flags.session || flags['active-session']) {
-                const sessionResult = await this.prepareArtifactsFromSession(flags.session, flags['active-session']);
-                prdPath = sessionResult.prdPath;
-                projectName = sessionResult.projectName;
-                generatedFromSession = true;
-                generatedArtifacts.push(...sessionResult.generatedArtifacts);
-            }
-            let selectedProject = null;
-            if (!prdPath) {
-                selectedProject = await this.resolveProjectDirectory(manager, flags.project);
-                if (!selectedProject) {
-                    this.error(AgentErrorMessages.noPrdFound());
-                }
-                prdPath = selectedProject.path;
-                projectName = selectedProject.name;
-            }
-            if (!prdPath) {
-                throw new Error('Unable to resolve PRD directory.');
-            }
-            const resolvedProjectName = projectName ?? path.basename(prdPath);
-            // Check if tasks.md already exists
-            const tasksPath = path.join(prdPath, 'tasks.md');
-            if ((await fs.pathExists(tasksPath)) && !flags.overwrite) {
-                console.log(chalk.yellow('Warning: tasks.md already exists.'));
-                console.log(chalk.gray(`Location: ${tasksPath}`));
-                console.log(chalk.gray('Use --overwrite to regenerate tasks.md.\n'));
-                return;
-            }
-            console.log(chalk.dim('Looking for PRD artifacts...'));
-            const availableSources = await manager.detectAvailableSources(prdPath);
-            if (availableSources.length === 0) {
-                this.error(AgentErrorMessages.noPrdFound());
-            }
-            if (sourcePreference !== 'auto' && !availableSources.includes(sourcePreference)) {
-                this.error(`Preferred source "${sourcePreference}" not found in ${prdPath}\n\n` +
-                    `Available sources: ${availableSources.join(', ') || 'none'}\n` +
-                    'Hint: Override with --source flag');
-            }
-            if (availableSources.length > 1 && sourcePreference === 'auto') {
-                console.log(chalk.dim(`Found multiple sources (${availableSources.join(', ')}). Selecting best match...`));
-            }
-            // Generate tasks
-            console.log(chalk.dim('Analyzing PRD content...'));
-            const result = await manager.generateTasksFromPrd(prdPath, {
-                maxTasksPerPhase: flags['max-tasks'],
-                includeReferences: true,
-                clearMode: 'fast',
-                source: sourcePreference,
-            });
-            const chosenSourceFile = path.basename(result.sourcePath);
-            const usingOverride = sourcePreference !== 'auto';
-            if (usingOverride) {
-                console.log(chalk.dim(`Using source: ${chosenSourceFile}`));
-            }
-            else {
-                console.log(chalk.dim(`Using source: ${chosenSourceFile} (override with --source to pick a different artifact).`));
-            }
-            // Display results
-            console.log(chalk.bold.green('\nTask plan generated successfully!\n'));
-            if (generatedFromSession) {
-                console.log(chalk.bold('Generated artifacts:'));
-                generatedArtifacts.forEach((artifact) => {
-                    console.log(chalk.gray(`  • ${artifact}`));
-                });
-                console.log();
-            }
-            console.log(chalk.bold('Summary:'));
-            console.log(chalk.cyan(`  Project: ${resolvedProjectName}`));
-            console.log(chalk.cyan(`  Source: ${chosenSourceFile}`));
-            console.log(chalk.cyan(`  Total Phases: ${result.phases.length}`));
-            console.log(chalk.cyan(`  Total Tasks: ${result.totalTasks}`));
-            console.log();
-            console.log(chalk.bold('Task Breakdown:\n'));
-            for (const phase of result.phases) {
-                console.log(chalk.bold(`  ${phase.name}`));
-                console.log(chalk.gray(`    ${phase.tasks.length} tasks`));
-                const preview = phase.tasks.slice(0, 3);
-                preview.forEach((task) => {
-                    console.log(chalk.dim(`    • ${task.description}`));
-                });
-                if (phase.tasks.length > 3) {
-                    console.log(chalk.dim(`    ... and ${phase.tasks.length - 3} more`));
-                }
-                console.log();
-            }
-            console.log(chalk.bold('Output:'));
-            console.log(chalk.cyan(`  ${result.outputPath}`));
-            console.log();
-            console.log(chalk.bold.green('Next Steps:\n'));
-            console.log(chalk.gray('  1. Review the generated tasks in tasks.md'));
-            console.log(chalk.gray('  2. Edit if needed (add/remove/modify tasks)'));
-            console.log(chalk.gray('  3. Run'), chalk.cyan('clavix implement'), chalk.gray('to start implementation'));
-            console.log();
-            console.log(chalk.dim('Tip: Tasks are optimized with Clavix Intelligence for optimal AI execution\n'));
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
-            this.error(errorMessage);
-        }
-    }
-    validateSessionFlags(session, activeSession) {
-        if (session && activeSession) {
-            throw new Error('Use either --session or --active-session, not both.');
-        }
-    }
-    async prepareArtifactsFromSession(sessionId, useActive) {
-        const sessionManager = new SessionManager();
-        const analyzer = new ConversationAnalyzer();
-        let session = null;
-        if (sessionId) {
-            session = await sessionManager.getSession(sessionId);
-            if (!session) {
-                throw new Error(`Session not found: ${sessionId}`);
-            }
-        }
-        else if (useActive) {
-            session = await sessionManager.getActiveSession();
-            if (!session) {
-                throw new Error('No active session found.');
-            }
-        }
-        if (!session) {
-            throw new Error('Session resolution failed.');
-        }
-        if (session.messages.length === 0) {
-            throw new Error('Session has no messages to analyze.');
-        }
-        console.log(chalk.dim(`Generating mini-PRD from session ${session.id}...`));
-        const analysis = analyzer.analyze(session);
-        const projectDirName = this.sanitizeProjectName(session.projectName);
-        const outputsDir = path.join('.clavix', 'outputs', projectDirName);
-        await FileSystem.ensureDir(outputsDir);
-        const miniPrdPath = path.join(outputsDir, 'mini-prd.md');
-        const promptPath = path.join(outputsDir, 'optimized-prompt.md');
-        const miniPrdContent = analyzer.generateMiniPrd(session, analysis);
-        const promptContent = analyzer.generateOptimizedPrompt(session, analysis);
-        await FileSystem.writeFileAtomic(miniPrdPath, miniPrdContent);
-        await FileSystem.writeFileAtomic(promptPath, promptContent);
-        console.log(chalk.dim(`Saved mini-prd.md and optimized-prompt.md to ${outputsDir}.\n`));
-        return {
-            prdPath: outputsDir,
-            projectName: projectDirName,
-            generatedArtifacts: [miniPrdPath, promptPath],
-        };
-    }
-    async resolveProjectDirectory(manager, projectName) {
-        const outputsDir = path.join(process.cwd(), '.clavix', 'outputs');
-        if (!(await fs.pathExists(outputsDir))) {
-            return null;
-        }
-        const entries = await fs.readdir(outputsDir, { withFileTypes: true });
-        const projects = [];
-        for (const entry of entries) {
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            if (entry.name === 'archive') {
-                continue;
-            }
-            const projectPath = path.join(outputsDir, entry.name);
-            const sources = await manager.detectAvailableSources(projectPath);
-            if (sources.length === 0) {
-                continue;
-            }
-            const hasTasks = await fs.pathExists(path.join(projectPath, 'tasks.md'));
-            const stats = await fs.stat(projectPath);
-            projects.push({
-                name: entry.name,
-                path: projectPath,
-                sources,
-                hasTasks,
-                mtime: stats.mtime,
-            });
-        }
-        if (projectName) {
-            const match = projects.find((project) => project.name === projectName);
-            if (!match) {
-                throw new Error(`PRD project not found: ${projectName}`);
-            }
-            console.log(chalk.dim(`Selected project: ${match.name}`));
-            return match;
-        }
-        if (projects.length === 0) {
-            return null;
-        }
-        if (projects.length === 1) {
-            const [project] = projects;
-            console.log(chalk.dim(`Auto-selected project: ${project.name}`));
-            return project;
-        }
-        if (this.isInteractive()) {
-            console.log(chalk.bold('Select a PRD project to generate a task plan:\n'));
-            const choices = projects.map((project) => {
-                const sourceLabel = project.sources.join('/') || 'prompt';
-                const taskLabel = project.hasTasks ? 'tasks present' : 'no tasks yet';
-                return {
-                    name: `${project.name} — sources: ${sourceLabel}; ${taskLabel}`,
-                    value: project.name,
-                };
-            });
-            const response = await inquirer.prompt([
-                {
-                    type: 'list',
-                    name: 'project',
-                    message: 'Project:',
-                    choices,
-                },
-            ]);
-            const selected = projects.find((project) => project.name === response.project);
-            if (!selected) {
-                throw new Error('Project selection failed.');
-            }
-            return selected;
-        }
-        projects.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        const chosen = projects[0];
-        console.log(chalk.dim(`Multiple PRD projects found; selected most recent: ${chosen.name}. Use --project to choose explicitly.`));
-        return chosen;
-    }
-    sanitizeProjectName(name) {
-        const fallback = 'session-project';
-        if (!name) {
-            return fallback;
-        }
-        const sanitized = name
-            .toLowerCase()
-            .replace(/[^a-z0-9-]/g, '-')
-            .replace(/-+/g, '-')
-            .replace(/^-|-$/g, '')
-            .substring(0, 50);
-        return sanitized || fallback;
-    }
-    isInteractive() {
-        return Boolean(process.stdin.isTTY && process.stdout.isTTY);
-    }
-}
-//# sourceMappingURL=plan.js.map

package/dist/cli/commands/prd.d.ts

@@ -1,24 +0,0 @@
-import { Command } from '@oclif/core';
-export default class Prd extends Command {
-    static description: string;
-    static examples: string[];
-    static flags: {
-        quick: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        template: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
-    /**
-     * Derive a project name from the answers
-     */
-    private deriveProjectName;
-    /**
-     * Auto-detect project tech stack from common config files
-     */
-    private detectProjectTechStack;
-    /**
-     * Validate the generated quick-prd.md for AI consumption quality
-     */
-    private validatePrdQuality;
-}
-//# sourceMappingURL=prd.d.ts.map