clavix 2.4.3 → 2.5.0

package/dist/cli/commands/task-complete.d.ts

@@ -0,0 +1,27 @@
+import { Command } from '@oclif/core';
+export default class TaskComplete extends Command {
+    static description: string;
+    static examples: string[];
+    static args: {
+        taskId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'no-git': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /**
+     * Find config file (auto-discover or use provided path)
+     */
+    private findConfigFile;
+    /**
+     * Handle git commit based on strategy
+     */
+    private handleGitCommit;
+    /**
+     * Show next incomplete task
+     */
+    private showNextTask;
+}
+//# sourceMappingURL=task-complete.d.ts.map

package/dist/cli/commands/task-complete.js

@@ -0,0 +1,305 @@
+"use strict";
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const chalk_1 = __importDefault(require("chalk"));
+const task_manager_1 = require("../../core/task-manager");
+const config_manager_1 = require("../../core/config-manager");
+const git_manager_1 = require("../../core/git-manager");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs-extra"));
+class TaskComplete extends core_1.Command {
+    async run() {
+        const { args, flags } = await this.parse(TaskComplete);
+        const taskId = args.taskId;
+        console.log(chalk_1.default.bold.cyan(`\nTask Completion: ${taskId}\n`));
+        try {
+            const taskManager = new task_manager_1.TaskManager();
+            const configManager = new config_manager_1.ConfigManager();
+            const gitManager = new git_manager_1.GitManager();
+            // Find config file
+            const configPath = await this.findConfigFile(flags.config);
+            console.log(chalk_1.default.dim(`Config: ${configPath}\n`));
+            // Read config
+            const config = await configManager.read(configPath);
+            const tasksPath = config.tasksPath;
+            // Read tasks
+            const phases = await taskManager.readTasksFile(tasksPath);
+            // Validate task exists
+            const task = taskManager.validateTaskExists(phases, taskId);
+            if (!task) {
+                // Smart recovery: List available tasks
+                console.log(chalk_1.default.red(`✗ Task ID "${taskId}" not found\n`));
+                console.log(chalk_1.default.yellow('Available task IDs:\n'));
+                phases.forEach(phase => {
+                    console.log(chalk_1.default.bold(`  ${phase.name}:`));
+                    phase.tasks.forEach(t => {
+                        const status = t.completed ? chalk_1.default.green('[x]') : chalk_1.default.gray('[ ]');
+                        console.log(`    ${status} ${chalk_1.default.cyan(t.id)} - ${t.description}`);
+                    });
+                    console.log();
+                });
+                this.error('Task not found. Please use one of the task IDs listed above.');
+            }
+            // Check if already completed
+            if (task.completed && !flags.force) {
+                console.log(chalk_1.default.yellow(`⚠ Task "${taskId}" is already marked as completed\n`));
+                // Check if it's in config too
+                const isInConfig = await configManager.isTaskCompleted(configPath, taskId);
+                if (isInConfig) {
+                    console.log(chalk_1.default.dim('Task is tracked in config as completed.\n'));
+                }
+                console.log(chalk_1.default.gray('Use --force to re-mark this task as completed.\n'));
+                // Show next task
+                await this.showNextTask(taskManager, phases);
+                return;
+            }
+            // Mark task as completed with validation
+            console.log(chalk_1.default.dim('Marking task as completed...'));
+            const result = await taskManager.markTaskCompletedWithValidation(tasksPath, taskId);
+            if (!result.success) {
+                // Smart recovery: Show error and suggestions
+                console.log(chalk_1.default.red(`\n✗ Failed to mark task as completed\n`));
+                console.log(chalk_1.default.yellow(`Error: ${result.error}\n`));
+                if (result.warnings && result.warnings.length > 0) {
+                    console.log(chalk_1.default.yellow('Warnings:'));
+                    result.warnings.forEach(warning => console.log(chalk_1.default.yellow(`  • ${warning}`)));
+                    console.log();
+                }
+                // Provide recovery suggestions
+                console.log(chalk_1.default.bold('Recovery Options:\n'));
+                console.log(chalk_1.default.gray('  1. Check if tasks.md file is readable and writable'));
+                console.log(chalk_1.default.gray('  2. Verify task ID matches exactly (run "clavix implement" to see current task)'));
+                console.log(chalk_1.default.gray('  3. Try running with --force flag if task is already completed'));
+                console.log(chalk_1.default.gray('  4. Check tasks.md.backup file if one was created\n'));
+                this.error('Task completion failed');
+            }
+            // Display warnings if any
+            if (result.warnings && result.warnings.length > 0) {
+                console.log(chalk_1.default.yellow('\nWarnings:'));
+                result.warnings.forEach(warning => console.log(chalk_1.default.yellow(`  • ${warning}`)));
+                console.log();
+            }
+            // Success!
+            if (result.alreadyCompleted) {
+                console.log(chalk_1.default.green(`✓ Task was already completed (tracking updated)\n`));
+            }
+            else {
+                console.log(chalk_1.default.green(`✓ Task marked as completed\n`));
+            }
+            // Track completion in config
+            console.log(chalk_1.default.dim('Updating configuration...'));
+            await configManager.trackCompletion(configPath, taskId);
+            // Update stats
+            const updatedStats = taskManager.getTaskStats(phases);
+            await configManager.update(configPath, { stats: updatedStats });
+            console.log(chalk_1.default.green('✓ Configuration updated\n'));
+            // Show progress
+            console.log(chalk_1.default.bold('Progress:'));
+            console.log(chalk_1.default.cyan(`  Completed: ${updatedStats.completed}/${updatedStats.total} tasks (${updatedStats.percentage.toFixed(0)}%)`));
+            console.log(chalk_1.default.cyan(`  Remaining: ${updatedStats.remaining} tasks\n`));
+            // Create git commit if enabled
+            if (!flags['no-git'] && config.commitStrategy !== 'none') {
+                await this.handleGitCommit(gitManager, configManager, configPath, config.commitStrategy, task, phases);
+            }
+            // Show next task
+            await this.showNextTask(taskManager, phases);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'An unexpected error occurred';
+            console.log(chalk_1.default.red(`\n✗ Error: ${errorMessage}\n`));
+            this.error(errorMessage);
+        }
+    }
+    /**
+     * Find config file (auto-discover or use provided path)
+     */
+    async findConfigFile(providedPath) {
+        if (providedPath) {
+            if (await fs.pathExists(providedPath)) {
+                return providedPath;
+            }
+            throw new Error(`Config file not found: ${providedPath}`);
+        }
+        // Auto-discover: Look for .clavix/outputs/*/.clavix-implement-config.json
+        const outputsDir = path.join(process.cwd(), '.clavix', 'outputs');
+        if (!(await fs.pathExists(outputsDir))) {
+            throw new Error('No .clavix/outputs directory found.\n\nHint: Run "clavix implement" first to initialize');
+        }
+        // Search for config files
+        const entries = await fs.readdir(outputsDir, { withFileTypes: true });
+        const configFiles = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory() || entry.name === 'archive') {
+                continue;
+            }
+            const configPath = path.join(outputsDir, entry.name, '.clavix-implement-config.json');
+            if (await fs.pathExists(configPath)) {
+                configFiles.push(configPath);
+            }
+        }
+        if (configFiles.length === 0) {
+            throw new Error('No config files found.\n\nHint: Run "clavix implement" first to initialize');
+        }
+        // Use most recent config
+        const configsWithStats = await Promise.all(configFiles.map(async (filePath) => {
+            const stat = await fs.stat(filePath);
+            return { path: filePath, mtime: stat.mtime };
+        }));
+        configsWithStats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        return configsWithStats[0].path;
+    }
+    /**
+     * Handle git commit based on strategy
+     */
+    async handleGitCommit(gitManager, configManager, configPath, strategy, completedTask, phases) {
+        console.log(chalk_1.default.dim(`Checking git commit strategy (${strategy})...`));
+        const config = await configManager.read(configPath);
+        const completedCount = config.completedTaskIds?.length ?? 0;
+        let shouldCommit = false;
+        let commitMessage = '';
+        switch (strategy) {
+            case 'per-task':
+                shouldCommit = true;
+                commitMessage = `clavix: ${completedTask.description}`;
+                break;
+            case 'per-5-tasks':
+                shouldCommit = completedCount % 5 === 0;
+                if (shouldCommit) {
+                    const last5 = config.completedTaskIds?.slice(-5) ?? [];
+                    const taskDescriptions = phases
+                        .flatMap(p => p.tasks)
+                        .filter((t) => last5.includes(t.id))
+                        .map((t) => t.description);
+                    commitMessage = `clavix: Completed ${last5.length} tasks\n\nCompleted tasks:\n${taskDescriptions.map(d => `- ${d}`).join('\n')}`;
+                }
+                break;
+            case 'per-phase':
+                // Check if current phase is complete
+                const currentPhase = phases.find(p => p.name === completedTask.phase);
+                if (currentPhase) {
+                    const phaseComplete = currentPhase.tasks.every((t) => t.completed);
+                    shouldCommit = phaseComplete;
+                    if (shouldCommit) {
+                        commitMessage = `clavix: Completed ${currentPhase.name}\n\nCompleted tasks:\n${currentPhase.tasks.map((t) => `- ${t.description}`).join('\n')}`;
+                    }
+                }
+                break;
+            case 'none':
+            default:
+                shouldCommit = false;
+                break;
+        }
+        if (!shouldCommit) {
+            console.log(chalk_1.default.dim('No commit needed (strategy criteria not met)\n'));
+            return;
+        }
+        // Check git status
+        const gitStatus = await gitManager.validateGitSetup();
+        if (!gitStatus.isRepo) {
+            console.log(chalk_1.default.yellow('⚠ Not a git repository - skipping commit\n'));
+            return;
+        }
+        if (!gitStatus.hasChanges) {
+            console.log(chalk_1.default.dim('No git changes to commit\n'));
+            return;
+        }
+        // Create commit
+        console.log(chalk_1.default.dim('Creating git commit...'));
+        const fullMessage = `${commitMessage}\n\nGenerated by Clavix task-complete`;
+        const success = await gitManager.createCommit({
+            message: fullMessage,
+            description: completedTask.description,
+            projectName: path.basename(path.dirname(configPath)),
+        });
+        if (success) {
+            console.log(chalk_1.default.green('✓ Git commit created\n'));
+        }
+        else {
+            console.log(chalk_1.default.yellow('⚠ Git commit failed (non-critical)\n'));
+        }
+    }
+    /**
+     * Show next incomplete task
+     */
+    async showNextTask(taskManager, phases) {
+        const nextTask = taskManager.findFirstIncompleteTask(phases);
+        if (!nextTask) {
+            console.log(chalk_1.default.bold.green('🎉 All tasks completed!\n'));
+            console.log(chalk_1.default.gray('Great work! All implementation tasks are done.\n'));
+            console.log(chalk_1.default.dim('Hint: Run "clavix archive" to archive this project\n'));
+            return;
+        }
+        console.log(chalk_1.default.bold('Next Task:'));
+        console.log(chalk_1.default.bold.white(`  ID: ${chalk_1.default.cyan(nextTask.id)}`));
+        console.log(chalk_1.default.bold.white(`  ${nextTask.description}`));
+        if (nextTask.prdReference) {
+            console.log(chalk_1.default.dim(`  Reference: ${nextTask.prdReference}`));
+        }
+        console.log(chalk_1.default.dim(`  Phase: ${nextTask.phase}\n`));
+    }
+}
+TaskComplete.description = 'Mark a task as completed with validation and optional git commit';
+TaskComplete.examples = [
+    '<%= config.bin %> <%= command.id %> phase-1-auth-1',
+    '<%= config.bin %> <%= command.id %> phase-2-api-3 --no-git',
+    '<%= config.bin %> <%= command.id %> setup-1 --force',
+];
+TaskComplete.args = {
+    taskId: core_1.Args.string({
+        description: 'Task ID to mark as completed',
+        required: true,
+    }),
+};
+TaskComplete.flags = {
+    'no-git': core_1.Flags.boolean({
+        description: 'Skip git commit even if strategy is enabled',
+        default: false,
+    }),
+    force: core_1.Flags.boolean({
+        char: 'f',
+        description: 'Force completion even if already marked complete',
+        default: false,
+    }),
+    config: core_1.Flags.string({
+        char: 'c',
+        description: 'Path to config file (defaults to auto-discover)',
+    }),
+};
+exports.default = TaskComplete;
+//# sourceMappingURL=task-complete.js.map

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

@@ -0,0 +1,149 @@
+/**
+ * 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';
+import { CommitStrategy } from './git-manager';
+/**
+ * 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