clavix 2.3.0 → 2.4.0

package/dist/cli/commands/init.js

@@ -148,7 +148,7 @@ class Init extends core_1.Command {
                         new inquirer_1.default.Separator(),
                         // Universal Adapters
                         {
-                            name: 'agents.md (Universal - for tools without slash commands)',
+                            name: 'Agents (AGENTS.md - Universal - for tools without slash commands)',
                             value: 'agents-md',
                         },
                         {

package/dist/core 2/adapters/agents-md-generator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Generator for universal AGENTS.md file
+ * Provides workflow instructions for AI tools without slash command support
+ */
+export declare class AgentsMdGenerator {
+    static readonly TARGET_FILE = "AGENTS.md";
+    static readonly START_MARKER = "<!-- CLAVIX:START -->";
+    static readonly END_MARKER = "<!-- CLAVIX:END -->";
+    /**
+     * Generate or update AGENTS.md with Clavix workflows
+     */
+    static generate(): Promise<void>;
+    /**
+     * Inject or update managed block in AGENTS.md
+     */
+    private static injectManagedBlock;
+    /**
+     * Escape special regex characters
+     */
+    private static escapeRegex;
+    /**
+     * Check if AGENTS.md has Clavix block
+     */
+    static hasClavixBlock(): Promise<boolean>;
+}
+//# sourceMappingURL=agents-md-generator.d.ts.map

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

@@ -0,0 +1,102 @@
+"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.AgentsMdGenerator = void 0;
+const file_system_1 = require("../../utils/file-system");
+const path = __importStar(require("path"));
+/**
+ * Generator for universal AGENTS.md file
+ * Provides workflow instructions for AI tools without slash command support
+ */
+class AgentsMdGenerator {
+    /**
+     * Generate or update AGENTS.md with Clavix workflows
+     */
+    static async generate() {
+        const templatePath = path.join(__dirname, '../../templates/agents/agents.md');
+        // Check if template exists
+        if (!(await file_system_1.FileSystem.exists(templatePath))) {
+            throw new Error(`AGENTS.md template not found at ${templatePath}`);
+        }
+        const template = await file_system_1.FileSystem.readFile(templatePath);
+        // Inject into AGENTS.md using managed blocks
+        await this.injectManagedBlock(this.TARGET_FILE, template);
+    }
+    /**
+     * Inject or update managed block in AGENTS.md
+     */
+    static async injectManagedBlock(filePath, content) {
+        let fileContent = '';
+        // Read existing file or start with empty content
+        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)) {
+            // Replace existing block
+            fileContent = fileContent.replace(blockRegex, wrappedContent);
+        }
+        else {
+            // Append new block
+            if (fileContent && !fileContent.endsWith('\n\n')) {
+                fileContent += '\n\n';
+            }
+            fileContent += wrappedContent + '\n';
+        }
+        await file_system_1.FileSystem.writeFileAtomic(filePath, fileContent);
+    }
+    /**
+     * Escape special regex characters
+     */
+    static escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Check if AGENTS.md has Clavix block
+     */
+    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.AgentsMdGenerator = AgentsMdGenerator;
+AgentsMdGenerator.TARGET_FILE = 'AGENTS.md';
+AgentsMdGenerator.START_MARKER = '<!-- CLAVIX:START -->';
+AgentsMdGenerator.END_MARKER = '<!-- CLAVIX:END -->';
+//# sourceMappingURL=agents-md-generator.js.map

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

@@ -0,0 +1,27 @@
+import { BaseAdapter } from './base-adapter';
+/**
+ * Amp adapter
+ * Commands stored in .agents/commands/ (simple markdown, no frontmatter)
+ * Supports executable commands (experimental)
+ */
+export declare class AmpAdapter extends BaseAdapter {
+    readonly name = "amp";
+    readonly displayName = "Amp";
+    readonly directory = ".agents/commands";
+    readonly fileExtension = ".md";
+    readonly features: {
+        supportsSubdirectories: boolean;
+        supportsFrontmatter: boolean;
+        supportsExecutableCommands: boolean;
+    };
+    /**
+     * Detect if Amp is available in the project
+     */
+    detectProject(): Promise<boolean>;
+    /**
+     * Get command path for Amp
+     */
+    getCommandPath(): string;
+    getTargetFilename(name: string): string;
+}
+//# sourceMappingURL=amp-adapter.d.ts.map

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmpAdapter = void 0;
+const base_adapter_1 = require("./base-adapter");
+const file_system_1 = require("../../utils/file-system");
+/**
+ * Amp adapter
+ * Commands stored in .agents/commands/ (simple markdown, no frontmatter)
+ * Supports executable commands (experimental)
+ */
+class AmpAdapter extends base_adapter_1.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = 'amp';
+        this.displayName = 'Amp';
+        this.directory = '.agents/commands';
+        this.fileExtension = '.md';
+        this.features = {
+            supportsSubdirectories: false,
+            supportsFrontmatter: false,
+            supportsExecutableCommands: true,
+        };
+        // Uses default formatCommand from BaseAdapter (no special formatting)
+    }
+    /**
+     * Detect if Amp is available in the project
+     */
+    async detectProject() {
+        return await file_system_1.FileSystem.exists('.agents');
+    }
+    /**
+     * Get command path for Amp
+     */
+    getCommandPath() {
+        return this.directory;
+    }
+    getTargetFilename(name) {
+        return `clavix-${name}${this.fileExtension}`;
+    }
+}
+exports.AmpAdapter = AmpAdapter;
+//# sourceMappingURL=amp-adapter.js.map

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

@@ -0,0 +1,22 @@
+import { BaseAdapter } from './base-adapter';
+import { CommandTemplate } from '../../types/agent';
+/**
+ * Augment CLI adapter
+ * Commands stored in .augment/commands/clavix with optional subdirectories
+ */
+export declare class AugmentAdapter extends BaseAdapter {
+    readonly name = "augment";
+    readonly displayName = "Augment CLI";
+    readonly directory = ".augment/commands/clavix";
+    readonly fileExtension = ".md";
+    readonly features: {
+        supportsSubdirectories: boolean;
+        supportsFrontmatter: boolean;
+        frontmatterFields: string[];
+    };
+    detectProject(): Promise<boolean>;
+    getCommandPath(): string;
+    protected formatCommand(template: CommandTemplate): string;
+    private getHomeDir;
+}
+//# sourceMappingURL=augment-adapter.d.ts.map

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

@@ -0,0 +1,77 @@
+"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.AugmentAdapter = void 0;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const base_adapter_1 = require("./base-adapter");
+const file_system_1 = require("../../utils/file-system");
+/**
+ * Augment CLI adapter
+ * Commands stored in .augment/commands/clavix with optional subdirectories
+ */
+class AugmentAdapter extends base_adapter_1.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = 'augment';
+        this.displayName = 'Augment CLI';
+        this.directory = '.augment/commands/clavix';
+        this.fileExtension = '.md';
+        this.features = {
+            supportsSubdirectories: true,
+            supportsFrontmatter: true,
+            frontmatterFields: ['description', 'argument-hint', 'model'],
+        };
+    }
+    async detectProject() {
+        if (await file_system_1.FileSystem.exists('.augment')) {
+            return true;
+        }
+        const homeAugmentDir = path.join(this.getHomeDir(), '.augment');
+        return file_system_1.FileSystem.exists(homeAugmentDir);
+    }
+    getCommandPath() {
+        return this.directory;
+    }
+    formatCommand(template) {
+        const frontmatter = `---\ndescription: ${template.description}\nargument-hint: [prompt]\n---\n\n`;
+        return frontmatter + template.content;
+    }
+    getHomeDir() {
+        return process.env.CLAVIX_HOME_OVERRIDE || os.homedir();
+    }
+}
+exports.AugmentAdapter = AugmentAdapter;
+//# sourceMappingURL=augment-adapter.js.map

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

@@ -0,0 +1,45 @@
+import { AgentAdapter, CommandTemplate, ManagedBlock, ProviderFeatures, ValidationResult } from '../../types/agent';
+/**
+ * Base adapter class with shared logic for all providers
+ * Ensures consistency and reduces code duplication
+ */
+export declare abstract class BaseAdapter implements AgentAdapter {
+    abstract readonly name: string;
+    abstract readonly displayName: string;
+    abstract readonly directory: string;
+    abstract readonly fileExtension: string;
+    readonly features?: ProviderFeatures;
+    abstract detectProject(): Promise<boolean>;
+    abstract getCommandPath(): string;
+    /**
+     * Determine the target filename for a generated command
+     * Providers can override to customize filename conventions
+     */
+    getTargetFilename(name: string): string;
+    /**
+     * Default validation logic - can be overridden
+     * Checks if directory can be created and is writable
+     */
+    validate(): Promise<ValidationResult>;
+    /**
+     * Generate commands - default implementation
+     * Creates command files in the provider's directory
+     */
+    generateCommands(templates: CommandTemplate[]): Promise<void>;
+    /**
+     * Format command content for this provider
+     * Default: return content as-is
+     * Override for provider-specific formatting (frontmatter, placeholders, etc.)
+     */
+    protected formatCommand(template: CommandTemplate): string;
+    /**
+     * Default documentation injection - no-op
+     * Override if provider needs doc injection (like Claude Code)
+     */
+    injectDocumentation(_blocks: ManagedBlock[]): Promise<void>;
+    /**
+     * Escape special regex characters
+     */
+    protected escapeRegex(str: string): string;
+}
+//# sourceMappingURL=base-adapter.d.ts.map

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

@@ -0,0 +1,142 @@
+"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.BaseAdapter = void 0;
+const path = __importStar(require("path"));
+const file_system_1 = require("../../utils/file-system");
+const errors_1 = require("../../types/errors");
+/**
+ * Base adapter class with shared logic for all providers
+ * Ensures consistency and reduces code duplication
+ */
+class BaseAdapter {
+    /**
+     * Determine the target filename for a generated command
+     * Providers can override to customize filename conventions
+     */
+    getTargetFilename(name) {
+        return `${name}${this.fileExtension}`;
+    }
+    /**
+     * Default validation logic - can be overridden
+     * Checks if directory can be created and is writable
+     */
+    async validate() {
+        const errors = [];
+        const warnings = [];
+        const commandPath = this.getCommandPath();
+        // Check if parent directory exists
+        const parentDir = path.dirname(commandPath);
+        if (!(await file_system_1.FileSystem.exists(parentDir))) {
+            // Check if we can create parent by finding first existing ancestor
+            let ancestorDir = parentDir;
+            let canCreate = false;
+            // Walk up the directory tree until we find an existing directory
+            while (ancestorDir !== '.' && ancestorDir !== '/' && ancestorDir.length > 0) {
+                ancestorDir = path.dirname(ancestorDir);
+                if (await file_system_1.FileSystem.exists(ancestorDir)) {
+                    canCreate = true;
+                    break;
+                }
+            }
+            // If we reached '.' or '/', it means we can create the directory
+            if (ancestorDir === '.' || ancestorDir === '/' || canCreate) {
+                warnings.push(`Parent directory ${parentDir} will be created`);
+            }
+            else {
+                errors.push(`Parent directory ${parentDir} does not exist and cannot be created`);
+            }
+        }
+        // Try to ensure directory exists
+        if (errors.length === 0) {
+            try {
+                await file_system_1.FileSystem.ensureDir(commandPath);
+            }
+            catch (error) {
+                errors.push(`Cannot create command directory: ${error}`);
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors: errors.length > 0 ? errors : undefined,
+            warnings: warnings.length > 0 ? warnings : undefined,
+        };
+    }
+    /**
+     * Generate commands - default implementation
+     * Creates command files in the provider's directory
+     */
+    async generateCommands(templates) {
+        const commandPath = this.getCommandPath();
+        try {
+            // Ensure directory exists
+            await file_system_1.FileSystem.ensureDir(commandPath);
+            // Generate each command file
+            for (const template of templates) {
+                const content = this.formatCommand(template);
+                const filename = this.getTargetFilename(template.name);
+                const filePath = path.join(commandPath, filename);
+                await file_system_1.FileSystem.writeFileAtomic(filePath, content);
+            }
+        }
+        catch (error) {
+            throw new errors_1.IntegrationError(`Failed to generate ${this.displayName} commands: ${error}`, `Ensure ${commandPath} is writable`);
+        }
+    }
+    /**
+     * Format command content for this provider
+     * Default: return content as-is
+     * Override for provider-specific formatting (frontmatter, placeholders, etc.)
+     */
+    formatCommand(template) {
+        return template.content;
+    }
+    /**
+     * Default documentation injection - no-op
+     * Override if provider needs doc injection (like Claude Code)
+     */
+    async injectDocumentation(_blocks) {
+        // Default: no documentation injection
+        // Override in subclasses if needed
+    }
+    /**
+     * Escape special regex characters
+     */
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+}
+exports.BaseAdapter = BaseAdapter;
+//# sourceMappingURL=base-adapter.js.map

package/dist/core 2/adapters/claude-code-adapter.d.ts

@@ -0,0 +1,32 @@
+import { BaseAdapter } from './base-adapter';
+import { ManagedBlock } from '../../types/agent';
+/**
+ * Claude Code agent adapter
+ */
+export declare class ClaudeCodeAdapter extends BaseAdapter {
+    readonly name = "claude-code";
+    readonly displayName = "Claude Code";
+    readonly directory = ".claude/commands/clavix";
+    readonly fileExtension = ".md";
+    readonly features: {
+        supportsSubdirectories: boolean;
+        supportsFrontmatter: boolean;
+    };
+    /**
+     * Detect if Claude Code is available in the project
+     */
+    detectProject(): Promise<boolean>;
+    /**
+     * Get command path for Claude Code
+     */
+    getCommandPath(): string;
+    /**
+     * Inject documentation blocks into CLAUDE.md
+     */
+    injectDocumentation(blocks: ManagedBlock[]): Promise<void>;
+    /**
+     * Inject or update a managed block in a file
+     */
+    private injectManagedBlock;
+}
+//# sourceMappingURL=claude-code-adapter.d.ts.map

package/dist/core 2/adapters/claude-code-adapter.js

@@ -0,0 +1,116 @@
+"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.ClaudeCodeAdapter = void 0;
+const path = __importStar(require("path"));
+const base_adapter_1 = require("./base-adapter");
+const file_system_1 = require("../../utils/file-system");
+const errors_1 = require("../../types/errors");
+/**
+ * Claude Code agent adapter
+ */
+class ClaudeCodeAdapter extends base_adapter_1.BaseAdapter {
+    constructor() {
+        super(...arguments);
+        this.name = 'claude-code';
+        this.displayName = 'Claude Code';
+        this.directory = '.claude/commands/clavix';
+        this.fileExtension = '.md';
+        this.features = {
+            supportsSubdirectories: true,
+            supportsFrontmatter: false,
+        };
+        // escapeRegex is inherited from BaseAdapter
+    }
+    /**
+     * Detect if Claude Code is available in the project
+     */
+    async detectProject() {
+        // Check if .claude directory exists
+        return await file_system_1.FileSystem.exists('.claude');
+    }
+    /**
+     * Get command path for Claude Code
+     */
+    getCommandPath() {
+        return this.directory;
+    }
+    // generateCommands is inherited from BaseAdapter
+    /**
+     * Inject documentation blocks into CLAUDE.md
+     */
+    async injectDocumentation(blocks) {
+        try {
+            for (const block of blocks) {
+                await this.injectManagedBlock(block.targetFile, block.content, block.startMarker, block.endMarker);
+            }
+        }
+        catch (error) {
+            throw new errors_1.IntegrationError(`Failed to inject documentation: ${error}`, 'Ensure target files are writable');
+        }
+    }
+    /**
+     * Inject or update a managed block in a file
+     */
+    async injectManagedBlock(filePath, content, startMarker, endMarker) {
+        const fullPath = path.resolve(filePath);
+        let fileContent = '';
+        // Read existing file or create new
+        if (await file_system_1.FileSystem.exists(fullPath)) {
+            fileContent = await file_system_1.FileSystem.readFile(fullPath);
+        }
+        else {
+            // Create parent directory if needed
+            const dir = path.dirname(fullPath);
+            await file_system_1.FileSystem.ensureDir(dir);
+        }
+        const blockRegex = new RegExp(`${this.escapeRegex(startMarker)}[\\s\\S]*?${this.escapeRegex(endMarker)}`, 'g');
+        const wrappedContent = `${startMarker}\n${content}\n${endMarker}`;
+        if (blockRegex.test(fileContent)) {
+            // Replace existing block
+            fileContent = fileContent.replace(blockRegex, wrappedContent);
+        }
+        else {
+            // Append new block
+            if (fileContent && !fileContent.endsWith('\n\n')) {
+                fileContent += '\n\n';
+            }
+            fileContent += wrappedContent + '\n';
+        }
+        await file_system_1.FileSystem.writeFileAtomic(fullPath, fileContent);
+    }
+}
+exports.ClaudeCodeAdapter = ClaudeCodeAdapter;
+//# sourceMappingURL=claude-code-adapter.js.map

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

@@ -0,0 +1,34 @@
+import { BaseAdapter } from './base-adapter';
+/**
+ * Cline adapter
+ * Workflows stored in .cline/workflows/ (flat structure, no subdirectories)
+ * Slash command format: /<name.md> (includes .md extension with leading slash)
+ *
+ * Features:
+ * - Lives alongside Cline Rules
+ * - Clear step-by-step instructions in markdown
+ * - Supports built-in tools, CLI utilities, and MCP integrations
+ *
+ * Reference: https://docs.cline.bot/features/slash-commands/workflows
+ */
+export declare class ClineAdapter extends BaseAdapter {
+    readonly name = "cline";
+    readonly displayName = "Cline";
+    readonly directory = ".clinerules/workflows";
+    readonly fileExtension = ".md";
+    readonly features: {
+        supportsSubdirectories: boolean;
+        supportsFrontmatter: boolean;
+    };
+    /**
+     * Detect if Cline is available in the project
+     * Checks for .cline directory
+     */
+    detectProject(): Promise<boolean>;
+    /**
+     * Get command path for Cline
+     */
+    getCommandPath(): string;
+    getTargetFilename(name: string): string;
+}
+//# sourceMappingURL=cline-adapter.d.ts.map