clavix 2.7.1 → 2.8.0

package/dist/core/adapters 2/windsurf-adapter.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WindsurfAdapter = void 0;
-const base_adapter_1 = require("./base-adapter");
-const file_system_1 = require("../../utils/file-system");
-/**
- * Windsurf adapter
- * Workflows stored in .windsurf/workflows/ (supports subdirectories)
- * Slash command format: /[name] (no .md extension)
- *
- * Features:
- * - Supports subdirectories for workflow organization
- * - 12,000 character limit per workflow file
- * - Auto-discovers from workspace, subdirectories, and parent dirs up to git root
- *
- * Reference: https://docs.windsurf.com/windsurf/cascade/workflows
- */
-class WindsurfAdapter extends base_adapter_1.BaseAdapter {
-    constructor() {
-        super(...arguments);
-        this.name = 'windsurf';
-        this.displayName = 'Windsurf';
-        this.directory = '.windsurf/workflows';
-        this.fileExtension = '.md';
-        this.features = {
-            supportsSubdirectories: true,
-            supportsFrontmatter: false,
-        };
-        // Uses default formatCommand and generateCommands from BaseAdapter
-    }
-    /**
-     * Detect if Windsurf is available in the project
-     * Checks for .windsurf directory
-     */
-    async detectProject() {
-        return await file_system_1.FileSystem.exists('.windsurf');
-    }
-    /**
-     * Get command path for Windsurf
-     */
-    getCommandPath() {
-        return this.directory;
-    }
-    getTargetFilename(name) {
-        return `clavix-${name}${this.fileExtension}`;
-    }
-}
-exports.WindsurfAdapter = WindsurfAdapter;
-//# sourceMappingURL=windsurf-adapter.js.map

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

@@ -1,126 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentManager = void 0;
-const claude_code_adapter_1 = require("./adapters/claude-code-adapter");
-const cursor_adapter_1 = require("./adapters/cursor-adapter");
-const droid_adapter_1 = require("./adapters/droid-adapter");
-const opencode_adapter_1 = require("./adapters/opencode-adapter");
-const amp_adapter_1 = require("./adapters/amp-adapter");
-const crush_adapter_1 = require("./adapters/crush-adapter");
-const windsurf_adapter_1 = require("./adapters/windsurf-adapter");
-const kilocode_adapter_1 = require("./adapters/kilocode-adapter");
-const cline_adapter_1 = require("./adapters/cline-adapter");
-const roocode_adapter_1 = require("./adapters/roocode-adapter");
-const errors_1 = require("../types/errors");
-const codebuddy_adapter_1 = require("./adapters/codebuddy-adapter");
-const gemini_adapter_1 = require("./adapters/gemini-adapter");
-const qwen_adapter_1 = require("./adapters/qwen-adapter");
-const codex_adapter_1 = require("./adapters/codex-adapter");
-const augment_adapter_1 = require("./adapters/augment-adapter");
-/**
- * Agent Manager - handles agent detection and registration
- */
-class AgentManager {
-    constructor() {
-        this.adapters = new Map();
-        // Register all built-in adapters
-        this.registerAdapter(new claude_code_adapter_1.ClaudeCodeAdapter());
-        this.registerAdapter(new cursor_adapter_1.CursorAdapter());
-        this.registerAdapter(new droid_adapter_1.DroidAdapter());
-        this.registerAdapter(new opencode_adapter_1.OpenCodeAdapter());
-        this.registerAdapter(new amp_adapter_1.AmpAdapter());
-        this.registerAdapter(new crush_adapter_1.CrushAdapter());
-        this.registerAdapter(new windsurf_adapter_1.WindsurfAdapter());
-        this.registerAdapter(new kilocode_adapter_1.KilocodeAdapter());
-        this.registerAdapter(new cline_adapter_1.ClineAdapter());
-        this.registerAdapter(new roocode_adapter_1.RoocodeAdapter());
-        this.registerAdapter(new augment_adapter_1.AugmentAdapter());
-        this.registerAdapter(new codebuddy_adapter_1.CodeBuddyAdapter());
-        this.registerAdapter(new gemini_adapter_1.GeminiAdapter());
-        this.registerAdapter(new qwen_adapter_1.QwenAdapter());
-        this.registerAdapter(new codex_adapter_1.CodexAdapter());
-    }
-    /**
-     * Register a new agent adapter
-     */
-    registerAdapter(adapter) {
-        this.adapters.set(adapter.name, adapter);
-    }
-    /**
-     * Get all registered adapters
-     */
-    getAdapters() {
-        return Array.from(this.adapters.values());
-    }
-    /**
-     * Get adapter by name
-     */
-    getAdapter(name) {
-        return this.adapters.get(name);
-    }
-    /**
-     * Detect which agents are available in the current project
-     */
-    async detectAgents() {
-        const detected = [];
-        for (const adapter of this.adapters.values()) {
-            if (await adapter.detectProject()) {
-                detected.push(adapter);
-            }
-        }
-        return detected;
-    }
-    /**
-     * Get agent adapter by name or throw error
-     */
-    requireAdapter(name) {
-        const adapter = this.getAdapter(name);
-        if (!adapter) {
-            throw new errors_1.IntegrationError(`Agent "${name}" is not registered`, `Available agents: ${Array.from(this.adapters.keys()).join(', ')}`);
-        }
-        return adapter;
-    }
-    /**
-     * Check if an agent is available
-     */
-    hasAgent(name) {
-        return this.adapters.has(name);
-    }
-    /**
-     * Get list of available agent names
-     */
-    getAvailableAgents() {
-        return Array.from(this.adapters.keys());
-    }
-    /**
-     * Validate multiple adapters
-     * Returns map of adapter name to validation result
-     */
-    async validateAdapters(adapterNames) {
-        const results = new Map();
-        for (const name of adapterNames) {
-            const adapter = this.requireAdapter(name);
-            if (adapter.validate) {
-                results.set(name, await adapter.validate());
-            }
-            else {
-                // No validation method - assume valid
-                results.set(name, { valid: true });
-            }
-        }
-        return results;
-    }
-    /**
-     * Get adapter choices for inquirer checkbox prompt
-     * Returns array of choices with pre-selected defaults
-     */
-    getAdapterChoices() {
-        return Array.from(this.adapters.values()).map((adapter) => ({
-            name: `${adapter.displayName} (${adapter.directory})`,
-            value: adapter.name,
-            checked: adapter.name === 'claude-code', // Pre-select Claude Code by default
-        }));
-    }
-}
-exports.AgentManager = AgentManager;
-//# sourceMappingURL=agent-manager.js.map

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

@@ -1,51 +0,0 @@
-import { AgentAdapter, ValidationResult } from '../types/agent';
-/**
- * Agent Manager - handles agent detection and registration
- */
-export declare class AgentManager {
-    private adapters;
-    constructor();
-    /**
-     * Register a new agent adapter
-     */
-    registerAdapter(adapter: AgentAdapter): void;
-    /**
-     * Get all registered adapters
-     */
-    getAdapters(): AgentAdapter[];
-    /**
-     * Get adapter by name
-     */
-    getAdapter(name: string): AgentAdapter | undefined;
-    /**
-     * Detect which agents are available in the current project
-     */
-    detectAgents(): Promise<AgentAdapter[]>;
-    /**
-     * Get agent adapter by name or throw error
-     */
-    requireAdapter(name: string): AgentAdapter;
-    /**
-     * Check if an agent is available
-     */
-    hasAgent(name: string): boolean;
-    /**
-     * Get list of available agent names
-     */
-    getAvailableAgents(): string[];
-    /**
-     * Validate multiple adapters
-     * Returns map of adapter name to validation result
-     */
-    validateAdapters(adapterNames: string[]): Promise<Map<string, ValidationResult>>;
-    /**
-     * Get adapter choices for inquirer checkbox prompt
-     * Returns array of choices with pre-selected defaults
-     */
-    getAdapterChoices(): Array<{
-        name: string;
-        value: string;
-        checked?: boolean;
-    }>;
-}
-//# sourceMappingURL=agent-manager.d.ts.map

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

@@ -1,338 +0,0 @@
-"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/archive-manager.d 2.ts

@@ -1,100 +0,0 @@
-/**
- * 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
- */
-/**
- * Status of a PRD project's tasks
- */
-export interface TaskStatus {
-    hasTasksFile: boolean;
-    total: number;
-    completed: number;
-    remaining: number;
-    percentage: number;
-    allCompleted: boolean;
-}
-/**
- * Information about a PRD project
- */
-export interface PrdProject {
-    name: string;
-    path: string;
-    taskStatus: TaskStatus;
-    modifiedTime: Date;
-    isArchived: boolean;
-}
-/**
- * ArchiveManager class
- *
- * Manages archival of completed PRD projects
- */
-export declare class ArchiveManager {
-    private readonly taskManager;
-    private readonly outputsDir;
-    private readonly archiveDir;
-    constructor();
-    /**
-     * List all PRD projects in outputs directory
-     *
-     * @param includeArchived - Include archived projects in results
-     * @returns Array of PRD projects
-     */
-    listPrdProjects(includeArchived?: boolean): Promise<PrdProject[]>;
-    /**
-     * List archived PRD projects
-     *
-     * @returns Array of archived PRD projects
-     */
-    listArchivedProjects(): Promise<PrdProject[]>;
-    /**
-     * Get PRD projects that are ready to archive (all tasks completed)
-     *
-     * @returns Array of archivable PRD projects
-     */
-    getArchivablePrds(): Promise<PrdProject[]>;
-    /**
-     * Check task completion status for a PRD project
-     *
-     * @param projectPath - Path to the PRD project directory
-     * @returns Task status information
-     */
-    checkTasksStatus(projectPath: string): Promise<TaskStatus>;
-    /**
-     * 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
-     */
-    archiveProject(projectName: string, force?: boolean): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    /**
-     * Restore an archived project back to active outputs
-     *
-     * @param projectName - Name of the archived project to restore
-     * @returns Success status and message
-     */
-    restoreProject(projectName: string): Promise<{
-        success: boolean;
-        message: string;
-    }>;
-    /**
-     * Check if a directory contains a PRD file
-     */
-    private hasPrdFile;
-    /**
-     * Get incomplete tasks for a project (for display purposes)
-     *
-     * @param projectPath - Path to the PRD project
-     * @returns Array of incomplete task descriptions
-     */
-    getIncompleteTasks(projectPath: string): Promise<string[]>;
-}
-//# sourceMappingURL=archive-manager.d.ts.map