clavix 5.1.1 → 5.3.0

package/README.md

@@ -12,7 +12,8 @@
 
 | Version | Highlights | Details |
 | --- | --- | --- |
-| **v5.0.0** (Latest) | Agentic-first architecture - lean template delivery | [Changelog](CHANGELOG.md#500---2025-01-27) |
+| **v5.2.1** (Latest) | Diagnose command, DRY architecture, feature matrix | [Changelog](CHANGELOG.md) |
+| **v5.0.0** | Agentic-first architecture - lean template delivery | [Changelog](CHANGELOG.md#500---2025-01-27) |
 | **v4.12.0** | Final v4 release with full CLI commands | [Changelog](docs/archive/v4-changelog.md) |
 
 **Requirements:** Node.js >= 18.0.0
@@ -49,6 +50,15 @@ Clavix v5 follows an **agentic-first architecture**:
 | CLI agents | Claude Code, Droid CLI, CodeBuddy CLI, OpenCode, Gemini CLI, Qwen Code, LLXPRT, Amp, Crush CLI, Codex CLI, Augment CLI |
 | Universal adapters | AGENTS.md, GitHub Copilot, OCTO.md, WARP.md |
 
+### Feature Matrix
+
+| Feature | Claude Code | Cursor/Windsurf | Gemini/Qwen | Generic Agents |
+|---------|-------------|-----------------|-------------|----------------|
+| Slash commands | ✅ Native | ✅ Native | ✅ TOML | ❌ Read-only |
+| Doc injection | ✅ CLAUDE.md | ✅ .cursor/rules | ✅ N/A | ✅ AGENTS.md |
+| Namespace dirs | ✅ clavix/ | ✅ clavix/ | ✅ clavix/ | N/A |
+| Auto-detection | ✅ Yes | ✅ Yes | ✅ Yes | N/A |
+
 Full list and configuration: [docs/integrations.md](docs/integrations.md)
 
 ## Quickstart
@@ -77,6 +87,7 @@ The AI agent reads the improve template and:
 
 ### 3. Choose Your Workflow
 
+**Core Workflows:**
 | Command | When to Use |
 |---------|-------------|
 | `/clavix:improve` | Optimize a single prompt (auto-selects depth) |
@@ -84,7 +95,13 @@ The AI agent reads the improve template and:
 | `/clavix:start` | Explore ideas conversationally first |
 | `/clavix:plan` | Generate tasks from a PRD |
 | `/clavix:implement` | Execute tasks with progress tracking |
-| `/clavix:archive` | Archive completed projects |
+| `/clavix:summarize` | Extract requirements from conversation |
+
+**Project Management:**
+| Utility | Purpose |
+|---------|---------|
+| `/clavix:verify` | Check implementation against PRD requirements |
+| `/clavix:archive` | Archive completed projects to `.clavix/archive/` |
 
 See [Choosing the Right Workflow](docs/guides/choosing-workflow.md) for detailed guidance.
 
@@ -96,13 +113,13 @@ clavix update   # After npm update clavix
 
 ## CLI Commands
 
-Clavix v5 has only 4 CLI commands (for setup, not workflows):
+Clavix v5 has 4 CLI commands (for setup and diagnostics, not workflows):
 
 | Command | Purpose |
 |---------|---------|
-| `clavix init` | Initialize Clavix in a project |
+| `clavix init` | Initialize or reconfigure Clavix in a project |
 | `clavix update` | Update templates after package update |
-| `clavix config` | Manage configuration |
+| `clavix diagnose` | Check installation and report issues |
 | `clavix version` | Show version |
 
 **All workflows** (`/clavix:improve`, `/clavix:prd`, etc.) are **slash commands** that AI agents execute by reading markdown templates.

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

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Diagnose extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private checkVersion;
+    private checkClavixDir;
+    private checkConfig;
+    private static readonly DOC_GENERATORS;
+    private getDocGeneratorFile;
+    private getDocGeneratorName;
+    private checkIntegrations;
+    private checkTemplates;
+}
+//# sourceMappingURL=diagnose.d.ts.map

package/dist/cli/commands/diagnose.js

@@ -0,0 +1,295 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fs from 'fs-extra';
+import { AgentManager } from '../../core/agent-manager.js';
+import { FileSystem } from '../../utils/file-system.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export default class Diagnose extends Command {
+    static description = 'Diagnose Clavix installation and configuration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> # Check setup and report issues',
+    ];
+    async run() {
+        this.log(chalk.bold.cyan('\n🔍 Clavix Diagnostic Report\n'));
+        const results = [];
+        // 1. Check version
+        results.push(await this.checkVersion());
+        // 2. Check .clavix directory
+        results.push(await this.checkClavixDir());
+        // 3. Check config.json
+        results.push(await this.checkConfig());
+        // 4. Check integrations
+        results.push(...(await this.checkIntegrations()));
+        // 5. Check templates
+        results.push(await this.checkTemplates());
+        // Note: Slash commands are checked per-integration in checkIntegrations()
+        // No separate checkSlashCommands() - commands are in adapter-specific directories
+        // Print results
+        this.log(chalk.gray('─'.repeat(50)));
+        this.log(chalk.bold('\nResults:\n'));
+        let passCount = 0;
+        let warnCount = 0;
+        let failCount = 0;
+        for (const result of results) {
+            const icon = result.status === 'pass'
+                ? chalk.green('✓')
+                : result.status === 'warn'
+                    ? chalk.yellow('⚠')
+                    : chalk.red('✗');
+            const color = result.status === 'pass'
+                ? chalk.green
+                : result.status === 'warn'
+                    ? chalk.yellow
+                    : chalk.red;
+            this.log(`  ${icon} ${color(result.message)}`);
+            if (result.details) {
+                this.log(chalk.gray(`    ${result.details}`));
+            }
+            if (result.status === 'pass')
+                passCount++;
+            else if (result.status === 'warn')
+                warnCount++;
+            else
+                failCount++;
+        }
+        // Summary
+        this.log('\n' + chalk.gray('─'.repeat(50)));
+        this.log(chalk.bold(`\nSummary: ${chalk.green(passCount + ' passed')}, ${chalk.yellow(warnCount + ' warnings')}, ${chalk.red(failCount + ' failed')}\n`));
+        // Recommendations
+        if (failCount > 0) {
+            this.log(chalk.yellow('Recommendations:'));
+            this.log(chalk.gray('  • Run `clavix init` to initialize or repair installation'));
+            this.log(chalk.gray('  • Run `clavix update` to sync templates\n'));
+        }
+        else if (warnCount > 0) {
+            this.log(chalk.cyan('Tip: Run `clavix update` to resolve warnings\n'));
+        }
+        else {
+            this.log(chalk.green('✨ All checks passed! Clavix is ready to use.\n'));
+        }
+    }
+    async checkVersion() {
+        try {
+            const packageJsonPath = path.join(__dirname, '../../../package.json');
+            const packageJson = await fs.readJson(packageJsonPath);
+            return {
+                status: 'pass',
+                message: `Version: v${packageJson.version}`,
+            };
+        }
+        catch {
+            return {
+                status: 'fail',
+                message: 'Could not determine version',
+                details: 'package.json not found',
+            };
+        }
+    }
+    async checkClavixDir() {
+        const clavixDir = path.join(process.cwd(), '.clavix');
+        if (!(await FileSystem.exists(clavixDir))) {
+            return {
+                status: 'fail',
+                message: '.clavix directory not found',
+                details: 'Run `clavix init` to initialize',
+            };
+        }
+        // Check for essential subdirectory (outputs is always created)
+        // Note: 'instructions' is only created when generic integrations are used
+        // Note: 'commands' doesn't exist - commands go to adapter-specific directories
+        const outputsDir = path.join(clavixDir, 'outputs');
+        if (!(await FileSystem.exists(outputsDir))) {
+            return {
+                status: 'warn',
+                message: '.clavix directory incomplete',
+                details: 'Missing: outputs',
+            };
+        }
+        return {
+            status: 'pass',
+            message: '.clavix directory OK',
+        };
+    }
+    async checkConfig() {
+        const configPath = path.join(process.cwd(), '.clavix', 'config.json');
+        if (!(await FileSystem.exists(configPath))) {
+            return {
+                status: 'fail',
+                message: 'config.json not found',
+                details: 'Run `clavix init` to create configuration',
+            };
+        }
+        try {
+            const config = await fs.readJson(configPath);
+            if (!config.version) {
+                return {
+                    status: 'warn',
+                    message: 'config.json missing version field',
+                };
+            }
+            if (!config.integrations || config.integrations.length === 0) {
+                return {
+                    status: 'warn',
+                    message: 'No integrations configured',
+                    details: 'Run `clavix init` to add integrations',
+                };
+            }
+            return {
+                status: 'pass',
+                message: `config.json OK (${config.integrations.length} integration(s))`,
+            };
+        }
+        catch (error) {
+            return {
+                status: 'fail',
+                message: 'config.json is invalid',
+                details: `${error}`,
+            };
+        }
+    }
+    // Doc generators are integrations that generate documentation files, not adapters
+    static DOC_GENERATORS = [
+        'agents-md',
+        'octo-md',
+        'warp-md',
+        'copilot-instructions',
+    ];
+    getDocGeneratorFile(integration) {
+        switch (integration) {
+            case 'agents-md':
+                return 'AGENTS.md';
+            case 'octo-md':
+                return 'OCTO.md';
+            case 'warp-md':
+                return 'WARP.md';
+            case 'copilot-instructions':
+                return path.join('.github', 'copilot-instructions.md');
+            default:
+                return '';
+        }
+    }
+    getDocGeneratorName(integration) {
+        switch (integration) {
+            case 'agents-md':
+                return 'AGENTS.md';
+            case 'octo-md':
+                return 'OCTO.md';
+            case 'warp-md':
+                return 'WARP.md';
+            case 'copilot-instructions':
+                return 'GitHub Copilot';
+            default:
+                return integration;
+        }
+    }
+    async checkIntegrations() {
+        const results = [];
+        const configPath = path.join(process.cwd(), '.clavix', 'config.json');
+        if (!(await FileSystem.exists(configPath))) {
+            return results;
+        }
+        try {
+            const config = await fs.readJson(configPath);
+            const agentManager = new AgentManager();
+            for (const integrationName of config.integrations || []) {
+                // Handle doc generators specially (they don't have adapters)
+                if (Diagnose.DOC_GENERATORS.includes(integrationName)) {
+                    const docFile = this.getDocGeneratorFile(integrationName);
+                    const docPath = path.join(process.cwd(), docFile);
+                    if (await FileSystem.exists(docPath)) {
+                        results.push({
+                            status: 'pass',
+                            message: `${this.getDocGeneratorName(integrationName)}: Generated`,
+                            details: docFile,
+                        });
+                    }
+                    else {
+                        results.push({
+                            status: 'warn',
+                            message: `${this.getDocGeneratorName(integrationName)}: Not generated`,
+                            details: `Run \`clavix update\` to generate`,
+                        });
+                    }
+                    continue;
+                }
+                // Handle adapters (integrations with command generation)
+                const adapter = agentManager.getAdapter(integrationName);
+                if (!adapter) {
+                    results.push({
+                        status: 'warn',
+                        message: `Unknown integration: ${integrationName}`,
+                        details: 'May be removed in a future version',
+                    });
+                    continue;
+                }
+                // Check if adapter's command directory exists
+                const commandPath = adapter.getCommandPath();
+                const commandDirExists = await FileSystem.exists(commandPath);
+                if (commandDirExists) {
+                    const files = await FileSystem.listFiles(commandPath);
+                    const commandCount = files.filter((f) => f.endsWith('.md') || f.endsWith('.toml') || f.endsWith('.mdc')).length;
+                    results.push({
+                        status: 'pass',
+                        message: `${adapter.displayName}: ${commandCount} command(s)`,
+                        details: commandPath,
+                    });
+                }
+                else {
+                    results.push({
+                        status: 'warn',
+                        message: `${adapter.displayName}: commands not generated`,
+                        details: `Run \`clavix update\` to generate`,
+                    });
+                }
+            }
+        }
+        catch {
+            // Config read error handled elsewhere
+        }
+        return results;
+    }
+    async checkTemplates() {
+        const templateDir = path.join(__dirname, '../../templates');
+        if (!(await FileSystem.exists(templateDir))) {
+            return {
+                status: 'fail',
+                message: 'Template directory not found',
+                details: 'Package may be corrupted',
+            };
+        }
+        // Check for canonical templates
+        const canonicalDir = path.join(templateDir, 'slash-commands', '_canonical');
+        if (!(await FileSystem.exists(canonicalDir))) {
+            return {
+                status: 'warn',
+                message: 'Canonical templates missing',
+                details: 'Try reinstalling clavix',
+            };
+        }
+        const requiredTemplates = ['improve.md', 'prd.md', 'plan.md', 'implement.md'];
+        const missing = [];
+        for (const template of requiredTemplates) {
+            const templatePath = path.join(canonicalDir, template);
+            if (!(await FileSystem.exists(templatePath))) {
+                missing.push(template);
+            }
+        }
+        if (missing.length > 0) {
+            return {
+                status: 'warn',
+                message: 'Some canonical templates missing',
+                details: missing.join(', '),
+            };
+        }
+        return {
+            status: 'pass',
+            message: 'Package templates OK',
+        };
+    }
+}
+//# sourceMappingURL=diagnose.js.map

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

@@ -3,6 +3,10 @@ export default class Init extends Command {
     static description: string;
     static examples: string[];
     run(): Promise<void>;
+    /**
+     * Regenerate commands for existing integrations (update mode)
+     */
+    private regenerateCommands;
     private createDirectoryStructure;
     private generateConfig;
     private generateInstructions;

package/dist/cli/commands/init.js

@@ -21,24 +21,9 @@ export default class Init extends Command {
     async run() {
         console.log(chalk.bold.cyan('\n🚀 Clavix Initialization\n'));
         try {
-            // Check if already initialized
-            if (await FileSystem.exists('.clavix')) {
-                const { reinit } = await inquirer.prompt([
-                    {
-                        type: 'confirm',
-                        name: 'reinit',
-                        message: 'Clavix is already initialized. Reinitialize?',
-                        default: false,
-                    },
-                ]);
-                if (!reinit) {
-                    console.log(chalk.yellow('\n✓ Initialization cancelled\n'));
-                    return;
-                }
-            }
-            // Load existing config if re-initializing
             const agentManager = new AgentManager();
             let existingIntegrations = [];
+            // Load existing config if present
             if (await FileSystem.exists('.clavix/config.json')) {
                 try {
                     const configContent = await FileSystem.readFile('.clavix/config.json');
@@ -49,6 +34,45 @@ export default class Init extends Command {
                     // Ignore parse errors, will use empty array
                 }
             }
+            // Check if already initialized
+            if (await FileSystem.exists('.clavix')) {
+                // Show current state
+                console.log(chalk.cyan('You have existing Clavix configuration:'));
+                if (existingIntegrations.length > 0) {
+                    const displayNames = existingIntegrations.map((name) => {
+                        const adapter = agentManager.getAdapter(name);
+                        return adapter?.displayName || name;
+                    });
+                    console.log(chalk.gray(`  Integrations: ${displayNames.join(', ')}\n`));
+                }
+                else {
+                    console.log(chalk.gray('  Integrations: (none configured)\n'));
+                }
+                const { action } = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'action',
+                        message: 'What would you like to do?',
+                        choices: [
+                            { name: 'Reconfigure integrations', value: 'reconfigure' },
+                            { name: 'Update existing (regenerate commands)', value: 'update' },
+                            { name: 'Cancel', value: 'cancel' },
+                        ],
+                    },
+                ]);
+                if (action === 'cancel') {
+                    console.log(chalk.yellow('\n✓ Initialization cancelled\n'));
+                    return;
+                }
+                if (action === 'update') {
+                    // Just regenerate commands for existing integrations
+                    console.log(chalk.cyan('\n📝 Regenerating commands...\n'));
+                    await this.regenerateCommands(agentManager, existingIntegrations);
+                    console.log(chalk.green('\n✅ Commands updated successfully!\n'));
+                    return;
+                }
+                // Continue with reconfiguration flow below
+            }
             // Select integrations using shared utility
             console.log(chalk.gray('Select AI development tools to support:\n'));
             console.log(chalk.gray('(Space to select, Enter to confirm)\n'));
@@ -83,6 +107,32 @@ export default class Init extends Command {
                 if (cleanupAction === 'cleanup') {
                     console.log(chalk.gray('\n🗑️  Cleaning up deselected integrations...'));
                     for (const integrationName of deselectedIntegrations) {
+                        // Handle doc generators (AGENTS.md, OCTO.md, WARP.md, copilot-instructions)
+                        if (integrationName === 'agents-md') {
+                            await DocInjector.removeBlock('AGENTS.md');
+                            console.log(chalk.gray('  ✓ Cleaned AGENTS.md Clavix block'));
+                            continue;
+                        }
+                        if (integrationName === 'octo-md') {
+                            await DocInjector.removeBlock('OCTO.md');
+                            console.log(chalk.gray('  ✓ Cleaned OCTO.md Clavix block'));
+                            continue;
+                        }
+                        if (integrationName === 'warp-md') {
+                            await DocInjector.removeBlock('WARP.md');
+                            console.log(chalk.gray('  ✓ Cleaned WARP.md Clavix block'));
+                            continue;
+                        }
+                        if (integrationName === 'copilot-instructions') {
+                            await DocInjector.removeBlock('.github/copilot-instructions.md');
+                            console.log(chalk.gray('  ✓ Cleaned copilot-instructions.md Clavix block'));
+                            continue;
+                        }
+                        // Handle Claude Code (has CLAUDE.md doc injection)
+                        if (integrationName === 'claude-code') {
+                            await DocInjector.removeBlock('CLAUDE.md');
+                            console.log(chalk.gray('  ✓ Cleaned CLAUDE.md Clavix block'));
+                        }
                         const adapter = agentManager.getAdapter(integrationName);
                         if (adapter) {
                             const removed = await adapter.removeAllCommands();
@@ -247,8 +297,69 @@ export default class Init extends Command {
             throw toError(error);
         }
     }
+    /**
+     * Regenerate commands for existing integrations (update mode)
+     */
+    async regenerateCommands(agentManager, integrations) {
+        for (const integrationName of integrations) {
+            // Handle doc generators (not adapters)
+            if (integrationName === 'agents-md') {
+                console.log(chalk.gray('  ✓ Regenerating AGENTS.md...'));
+                await AgentsMdGenerator.generate();
+                continue;
+            }
+            if (integrationName === 'copilot-instructions') {
+                console.log(chalk.gray('  ✓ Regenerating .github/copilot-instructions.md...'));
+                await CopilotInstructionsGenerator.generate();
+                continue;
+            }
+            if (integrationName === 'octo-md') {
+                console.log(chalk.gray('  ✓ Regenerating OCTO.md...'));
+                await OctoMdGenerator.generate();
+                continue;
+            }
+            if (integrationName === 'warp-md') {
+                console.log(chalk.gray('  ✓ Regenerating WARP.md...'));
+                await WarpMdGenerator.generate();
+                continue;
+            }
+            // Handle regular adapters
+            const adapter = agentManager.getAdapter(integrationName);
+            if (!adapter) {
+                console.log(chalk.yellow(`  ⚠ Unknown integration: ${integrationName}`));
+                continue;
+            }
+            console.log(chalk.gray(`  ✓ Regenerating ${adapter.displayName} commands...`));
+            // Remove existing commands before regenerating
+            const removed = await adapter.removeAllCommands();
+            if (removed > 0) {
+                console.log(chalk.gray(`    Removed ${removed} existing command(s)`));
+            }
+            // Generate slash commands
+            const templates = await this.generateSlashCommands(adapter);
+            // Handle legacy command cleanup (silent in update mode)
+            const commandNames = templates.map((template) => template.name);
+            const legacyFiles = await collectLegacyCommandFiles(adapter, commandNames);
+            if (legacyFiles.length > 0) {
+                for (const file of legacyFiles) {
+                    await FileSystem.remove(file);
+                }
+                console.log(chalk.gray(`    Cleaned ${legacyFiles.length} legacy file(s)`));
+            }
+            // Re-inject documentation blocks (Claude Code only)
+            if (integrationName === 'claude-code') {
+                console.log(chalk.gray('  ✓ Updating CLAUDE.md documentation...'));
+                await this.injectDocumentation(adapter);
+            }
+        }
+        // Regenerate instructions folder if needed
+        if (InstructionsGenerator.needsGeneration(integrations)) {
+            console.log(chalk.gray('\n📁 Updating .clavix/instructions/ reference folder...'));
+            await InstructionsGenerator.generate();
+        }
+    }
     async createDirectoryStructure() {
-        const dirs = ['.clavix', '.clavix/sessions', '.clavix/outputs', '.clavix/templates'];
+        const dirs = ['.clavix', '.clavix/outputs', '.clavix/templates'];
         for (const dir of dirs) {
             await FileSystem.ensureDir(dir);
         }
@@ -274,7 +385,6 @@ Welcome to Clavix! This directory contains your local Clavix configuration and d
 ├── config.json           # Your Clavix configuration
 ├── INSTRUCTIONS.md       # This file
 ├── instructions/         # Workflow instruction files for AI agents
-├── sessions/             # Conversational mode session files
 ├── outputs/
 │   ├── <project-name>/  # Per-project outputs
 │   │   ├── full-prd.md
@@ -293,7 +403,7 @@ Welcome to Clavix! This directory contains your local Clavix configuration and d
 |---------|---------|
 | \`clavix init\` | Initialize Clavix in a project |
 | \`clavix update\` | Update templates after package update |
-| \`clavix config\` | Manage configuration |
+| \`clavix diagnose\` | Check installation health |
 | \`clavix version\` | Show version |
 
 ### Workflow Commands (Slash Commands)
@@ -363,11 +473,7 @@ PRD Creation → Task Planning → Implementation → Archive
 
 Create custom templates in \`.clavix/templates/\` to override defaults.
 
-Edit configuration:
-\`\`\`bash
-clavix config edit      # Opens config.json in $EDITOR
-clavix config set key=value
-\`\`\`
+To reconfigure integrations, run \`clavix init\` again.
 
 ## Need Help?
 

package/dist/cli/commands/update.js

@@ -220,7 +220,7 @@ This project uses Clavix for prompt improvement and PRD generation.
 |---------|---------|
 | \`clavix init\` | Initialize Clavix in a project |
 | \`clavix update\` | Update templates after package update |
-| \`clavix config\` | Manage configuration |
+| \`clavix diagnose\` | Check installation health |
 | \`clavix version\` | Show version |
 
 ### Workflow Commands (Slash Commands)

package/dist/constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Clavix constants and magic values
+ * Centralizes hardcoded values for maintainability
+ */
+export declare const BACKUP_EXTENSION = ".backup";
+export declare const SEPARATOR_WIDTH = 50;
+export declare const SEPARATOR_CHAR = "\u2500";
+export declare const CLAVIX_BLOCK_START = "<!-- CLAVIX:START -->";
+export declare const CLAVIX_BLOCK_END = "<!-- CLAVIX:END -->";
+export declare const WINDSURF_CHAR_LIMIT = 12000;
+export declare const DEPTH_STANDARD = "standard";
+export declare const DEPTH_COMPREHENSIVE = "comprehensive";
+export declare const CLAVIX_CONFIG_DIR = ".clavix";
+export declare const CLAVIX_CONFIG_FILE = "config.json";
+export declare const CLAVIX_OUTPUTS_DIR = "outputs";
+export declare const CLAVIX_PROMPTS_DIR = "prompts";
+export declare const CLAVIX_TEMPLATES_DIR = "templates";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -0,0 +1,24 @@
+/**
+ * Clavix constants and magic values
+ * Centralizes hardcoded values for maintainability
+ */
+// File system
+export const BACKUP_EXTENSION = '.backup';
+// CLI formatting
+export const SEPARATOR_WIDTH = 50;
+export const SEPARATOR_CHAR = '─';
+// Clavix managed block markers
+export const CLAVIX_BLOCK_START = '<!-- CLAVIX:START -->';
+export const CLAVIX_BLOCK_END = '<!-- CLAVIX:END -->';
+// Adapter-specific limits
+export const WINDSURF_CHAR_LIMIT = 12000;
+// Depth terminology (canonical)
+export const DEPTH_STANDARD = 'standard';
+export const DEPTH_COMPREHENSIVE = 'comprehensive';
+// File patterns
+export const CLAVIX_CONFIG_DIR = '.clavix';
+export const CLAVIX_CONFIG_FILE = 'config.json';
+export const CLAVIX_OUTPUTS_DIR = 'outputs';
+export const CLAVIX_PROMPTS_DIR = 'prompts';
+export const CLAVIX_TEMPLATES_DIR = 'templates';
+//# sourceMappingURL=constants.js.map