clavix 2.3.0 → 2.4.0

package/dist/core 2/adapters/warp-md-generator.js

@@ -0,0 +1,88 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WarpMdGenerator = void 0;
+const file_system_1 = require("../../utils/file-system");
+const path = __importStar(require("path"));
+/**
+ * Generator for Warp WARP.md file
+ * Provides workflow instructions optimized for Warp users
+ */
+class WarpMdGenerator {
+    /**
+     * Generate or update WARP.md with Clavix workflows
+     */
+    static async generate() {
+        const templatePath = path.join(__dirname, '../../templates/agents/warp.md');
+        if (!(await file_system_1.FileSystem.exists(templatePath))) {
+            throw new Error(`WARP.md template not found at ${templatePath}`);
+        }
+        const template = await file_system_1.FileSystem.readFile(templatePath);
+        await this.injectManagedBlock(this.TARGET_FILE, template);
+    }
+    static async injectManagedBlock(filePath, content) {
+        let fileContent = '';
+        if (await file_system_1.FileSystem.exists(filePath)) {
+            fileContent = await file_system_1.FileSystem.readFile(filePath);
+        }
+        const blockRegex = new RegExp(`${this.escapeRegex(this.START_MARKER)}[\\s\\S]*?${this.escapeRegex(this.END_MARKER)}`, 'g');
+        const wrappedContent = `${this.START_MARKER}\n${content}\n${this.END_MARKER}`;
+        if (blockRegex.test(fileContent)) {
+            fileContent = fileContent.replace(blockRegex, wrappedContent);
+        }
+        else {
+            if (fileContent && !fileContent.endsWith('\n\n')) {
+                fileContent += '\n\n';
+            }
+            fileContent += wrappedContent + '\n';
+        }
+        await file_system_1.FileSystem.writeFileAtomic(filePath, fileContent);
+    }
+    static escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    static async hasClavixBlock() {
+        if (!(await file_system_1.FileSystem.exists(this.TARGET_FILE))) {
+            return false;
+        }
+        const content = await file_system_1.FileSystem.readFile(this.TARGET_FILE);
+        return content.includes(this.START_MARKER);
+    }
+}
+exports.WarpMdGenerator = WarpMdGenerator;
+WarpMdGenerator.TARGET_FILE = 'WARP.md';
+WarpMdGenerator.START_MARKER = '<!-- CLAVIX:START -->';
+WarpMdGenerator.END_MARKER = '<!-- CLAVIX:END -->';
+//# sourceMappingURL=warp-md-generator.js.map

package/dist/core 2/adapters/windsurf-adapter.d.ts

@@ -0,0 +1,34 @@
+import { BaseAdapter } from './base-adapter';
+/**
+ * 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
+ */
+export declare class WindsurfAdapter extends BaseAdapter {
+    readonly name = "windsurf";
+    readonly displayName = "Windsurf";
+    readonly directory = ".windsurf/workflows";
+    readonly fileExtension = ".md";
+    readonly features: {
+        supportsSubdirectories: boolean;
+        supportsFrontmatter: boolean;
+    };
+    /**
+     * Detect if Windsurf is available in the project
+     * Checks for .windsurf directory
+     */
+    detectProject(): Promise<boolean>;
+    /**
+     * Get command path for Windsurf
+     */
+    getCommandPath(): string;
+    getTargetFilename(name: string): string;
+}
+//# sourceMappingURL=windsurf-adapter.d.ts.map

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

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

@@ -0,0 +1,51 @@
+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 2/agent-manager.js

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

@@ -0,0 +1,100 @@
+/**
+ * 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