clavix 4.9.0 → 4.11.1

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

@@ -0,0 +1,17 @@
+import { Command } from '@oclif/core';
+export default class Analyze extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        pretty: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        prompt: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    /**
+     * v4.11: Calculate escalation with unified improve mode
+     */
+    private calculateEscalation;
+}
+//# sourceMappingURL=analyze.d.ts.map

package/dist/cli/commands/analyze.js

@@ -0,0 +1,133 @@
+import { Command, Args, Flags } from '@oclif/core';
+import { UniversalOptimizer } from '../../core/intelligence/index.js';
+export default class Analyze extends Command {
+    static description = 'Analyze a prompt and return structured JSON with intent, quality, and escalation data';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Create a login page"',
+        '<%= config.bin %> <%= command.id %> "Build an API for user management" --pretty',
+    ];
+    static flags = {
+        pretty: Flags.boolean({
+            char: 'p',
+            description: 'Pretty-print the JSON output',
+            default: false,
+        }),
+    };
+    static args = {
+        prompt: Args.string({
+            description: 'The prompt to analyze',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Analyze);
+        if (!args.prompt || args.prompt.trim().length === 0) {
+            const errorOutput = {
+                error: 'No prompt provided',
+                message: 'Please provide a prompt to analyze',
+            };
+            console.log(JSON.stringify(errorOutput, null, flags.pretty ? 2 : 0));
+            this.exit(1);
+            return;
+        }
+        const optimizer = new UniversalOptimizer();
+        // v4.11: Use 'improve' mode for analysis
+        const result = await optimizer.optimize(args.prompt, 'improve');
+        // Calculate escalation score and recommendation
+        const escalation = this.calculateEscalation(result);
+        // Build the analysis result
+        const analysisResult = {
+            intent: result.intent.primaryIntent,
+            confidence: result.intent.confidence,
+            quality: {
+                overall: Math.round(result.quality.overall),
+                clarity: Math.round(result.quality.clarity),
+                efficiency: Math.round(result.quality.efficiency),
+                structure: Math.round(result.quality.structure),
+                completeness: Math.round(result.quality.completeness),
+                actionability: Math.round(result.quality.actionability),
+                specificity: Math.round(result.quality.specificity ?? 0),
+            },
+            escalation,
+            characteristics: {
+                hasCodeContext: result.intent.characteristics.hasCodeContext,
+                hasTechnicalTerms: result.intent.characteristics.hasTechnicalTerms,
+                isOpenEnded: result.intent.characteristics.isOpenEnded,
+                needsStructure: result.intent.characteristics.needsStructure,
+            },
+        };
+        // Output as JSON
+        console.log(JSON.stringify(analysisResult, null, flags.pretty ? 2 : 0));
+    }
+    /**
+     * v4.11: Calculate escalation with unified improve mode
+     */
+    calculateEscalation(result) {
+        const factors = [];
+        let score = 0;
+        // Quality-based factors
+        if (result.quality.overall < 50) {
+            score += 30;
+            factors.push('low overall quality');
+        }
+        else if (result.quality.overall < 65) {
+            score += 15;
+            factors.push('moderate quality - could be improved');
+        }
+        if (result.quality.clarity < 50) {
+            score += 15;
+            factors.push('unclear objective');
+        }
+        if (result.quality.completeness < 50) {
+            score += 20;
+            factors.push('missing technical requirements');
+        }
+        if (result.quality.actionability < 50) {
+            score += 15;
+            factors.push('vague scope');
+        }
+        // Intent-based factors
+        if (result.intent.primaryIntent === 'planning') {
+            score += 15;
+            factors.push('planning intent - benefits from exploration');
+        }
+        if (result.intent.primaryIntent === 'prd-generation') {
+            score += 25;
+            factors.push('PRD generation - needs strategic planning');
+        }
+        // Characteristics-based factors
+        if (result.intent.characteristics.isOpenEnded && result.intent.characteristics.needsStructure) {
+            score += 10;
+            factors.push('open-ended without structure');
+        }
+        // Confidence-based factors
+        if (result.intent.confidence < 70) {
+            score += 10;
+            factors.push('low intent confidence');
+        }
+        // v4.11: Determine recommendation based on score and intent
+        let recommend = 'improve';
+        let recommendedDepth = 'standard';
+        if (result.intent.primaryIntent === 'prd-generation') {
+            recommend = 'prd';
+        }
+        else if (score >= 60 || result.quality.overall < 50) {
+            recommendedDepth = 'comprehensive';
+        }
+        else if (score >= 35) {
+            recommendedDepth = 'comprehensive';
+        }
+        // Check for strategic keywords that suggest PRD mode
+        const strategicIntents = ['planning', 'prd-generation', 'documentation'];
+        if (strategicIntents.includes(result.intent.primaryIntent) && score >= 50) {
+            recommend = 'prd';
+        }
+        return {
+            score: Math.min(100, score),
+            recommend,
+            recommendedDepth: recommend === 'improve' ? recommendedDepth : undefined,
+            factors,
+        };
+    }
+}
+//# sourceMappingURL=analyze.js.map

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

@@ -4,8 +4,8 @@ export default class Execute extends Command {
     static examples: string[];
     static flags: {
         latest: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        fast: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-        deep: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        standard: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        comprehensive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;

package/dist/cli/commands/execute.js

@@ -4,12 +4,12 @@ import inquirer from 'inquirer';
 import { PromptManager } from '../../core/prompt-manager.js';
 import { ChecklistParser } from '../../core/checklist-parser.js';
 export default class Execute extends Command {
-    static description = 'Execute a saved prompt from fast/deep optimization';
+    static description = 'Execute a saved prompt from improve optimization';
     static examples = [
         '<%= config.bin %> <%= command.id %> --latest',
-        '<%= config.bin %> <%= command.id %> --latest --fast',
-        '<%= config.bin %> <%= command.id %> --latest --deep',
-        '<%= config.bin %> <%= command.id %> --id fast-20250117-143022-a3f2',
+        '<%= config.bin %> <%= command.id %> --latest --standard',
+        '<%= config.bin %> <%= command.id %> --latest --comprehensive',
+        '<%= config.bin %> <%= command.id %> --id std-20250117-143022-a3f2',
         '<%= config.bin %> <%= command.id %>',
     ];
     static flags = {
@@ -17,12 +17,14 @@ export default class Execute extends Command {
             description: 'Auto-select latest prompt (any type)',
             default: false,
         }),
-        fast: Flags.boolean({
-            description: 'Filter to fast prompts only (use with --latest)',
+        standard: Flags.boolean({
+            char: 's',
+            description: 'Filter to standard depth prompts only (use with --latest)',
             default: false,
         }),
-        deep: Flags.boolean({
-            description: 'Filter to deep prompts only (use with --latest)',
+        comprehensive: Flags.boolean({
+            char: 'c',
+            description: 'Filter to comprehensive depth prompts only (use with --latest)',
             default: false,
         }),
         id: Flags.string({
@@ -38,8 +40,7 @@ export default class Execute extends Command {
             if (allPrompts.length === 0) {
                 console.log(chalk.yellow('\n⚠️  No prompts found\n'));
                 console.log(chalk.cyan('Generate an optimized prompt first:'));
-                console.log(chalk.cyan('  /clavix:fast "your requirement"'));
-                console.log(chalk.cyan('  /clavix:deep "your requirement"'));
+                console.log(chalk.cyan('  /clavix:improve "your requirement"'));
                 console.log();
                 return;
             }
@@ -57,18 +58,18 @@ export default class Execute extends Command {
             // Auto-select latest with optional filtering
             else if (flags.latest) {
                 let filtered = allPrompts;
-                // Apply source filter
-                if (flags.fast && !flags.deep) {
-                    filtered = allPrompts.filter((p) => p.source === 'fast');
+                // Apply depth filter
+                if (flags.standard && !flags.comprehensive) {
+                    filtered = allPrompts.filter((p) => p.depthUsed === 'standard');
                 }
-                else if (flags.deep && !flags.fast) {
-                    filtered = allPrompts.filter((p) => p.source === 'deep');
+                else if (flags.comprehensive && !flags.standard) {
+                    filtered = allPrompts.filter((p) => p.depthUsed === 'comprehensive');
                 }
                 if (filtered.length === 0) {
-                    const source = flags.fast ? 'fast' : flags.deep ? 'deep' : 'any';
-                    console.log(chalk.yellow(`\n⚠️  No ${source} prompts found\n`));
-                    console.log(chalk.cyan(`Generate a ${source} prompt first:`));
-                    console.log(chalk.cyan(`  /clavix:${source === 'any' ? 'fast' : source} "your requirement"`));
+                    const depth = flags.standard ? 'standard' : flags.comprehensive ? 'comprehensive' : 'any';
+                    console.log(chalk.yellow(`\n⚠️  No ${depth} prompts found\n`));
+                    console.log(chalk.cyan(`Generate a prompt first:`));
+                    console.log(chalk.cyan(`  /clavix:improve "your requirement"`));
                     console.log();
                     return;
                 }
@@ -94,8 +95,9 @@ export default class Execute extends Command {
             const status = p.executed ? chalk.green('✓') : chalk.gray('○');
             const age = p.ageInDays === 0 ? 'today' : `${p.ageInDays}d ago`;
             const ageColor = (p.ageInDays || 0) > 30 ? chalk.red : (p.ageInDays || 0) > 7 ? chalk.yellow : chalk.gray;
+            const depthLabel = p.depthUsed === 'comprehensive' ? 'comp' : 'std';
             return {
-                name: `${status} [${p.source}] ${p.originalPrompt.substring(0, 60)}... ${ageColor(`(${age})`)}`,
+                name: `${status} [${depthLabel}] ${p.originalPrompt.substring(0, 60)}... ${ageColor(`(${age})`)}`,
                 value: p.id,
                 short: p.id,
             };
@@ -119,7 +121,7 @@ export default class Execute extends Command {
         }
         // Display prompt header
         console.log(chalk.bold.cyan(`\n🎯 Executing Prompt: ${prompt.id}\n`));
-        console.log(chalk.gray(`Source: ${prompt.source}`));
+        console.log(chalk.gray(`Depth: ${prompt.depthUsed}`));
         console.log(chalk.gray(`Created: ${new Date(prompt.timestamp).toLocaleDateString()}`));
         console.log(chalk.gray(`Age: ${prompt.ageInDays} days\n`));
         // Display full prompt content

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

@@ -0,0 +1,32 @@
+import { Command } from '@oclif/core';
+/**
+ * v4.11: Unified improve command with smart depth auto-detection
+ *
+ * Replaces the old fast/deep commands with intelligent depth selection:
+ * - Quality score >= 75: auto-comprehensive
+ * - Quality score 60-74: ask user (borderline)
+ * - Quality score < 60: auto-standard
+ *
+ * Users can override with --comprehensive or --standard flags.
+ */
+export default class Improve extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        comprehensive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        standard: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'analysis-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        prompt: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+    /**
+     * v4.11: Smart depth auto-detection based on quality score
+     */
+    private autoDetectDepth;
+    private displayOutput;
+    private displayAnalysisOnly;
+    private savePrompt;
+}
+//# sourceMappingURL=improve.d.ts.map

package/dist/cli/commands/improve.js

@@ -0,0 +1,250 @@
+import { Command, Args, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { UniversalOptimizer } from '../../core/intelligence/index.js';
+import { PromptManager } from '../../core/prompt-manager.js';
+/**
+ * v4.11: Unified improve command with smart depth auto-detection
+ *
+ * Replaces the old fast/deep commands with intelligent depth selection:
+ * - Quality score >= 75: auto-comprehensive
+ * - Quality score 60-74: ask user (borderline)
+ * - Quality score < 60: auto-standard
+ *
+ * Users can override with --comprehensive or --standard flags.
+ */
+export default class Improve extends Command {
+    static description = 'Improve a prompt with smart quality-based depth selection (replaces fast/deep)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> "Create a login page"',
+        '<%= config.bin %> <%= command.id %> "Build an API for user management" --comprehensive',
+        '<%= config.bin %> <%= command.id %> "Fix the button styling" --standard',
+        '<%= config.bin %> <%= command.id %> "Design a notification system" --analysis-only',
+    ];
+    static flags = {
+        comprehensive: Flags.boolean({
+            char: 'c',
+            description: 'Force comprehensive depth (alternative approaches, edge cases, validation)',
+            default: false,
+        }),
+        standard: Flags.boolean({
+            char: 's',
+            description: 'Force standard depth (quick improvements)',
+            default: false,
+        }),
+        'analysis-only': Flags.boolean({
+            description: 'Show only quality analysis without improved prompt',
+            default: false,
+        }),
+    };
+    static args = {
+        prompt: Args.string({
+            description: 'The prompt to improve',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Improve);
+        if (!args.prompt || args.prompt.trim().length === 0) {
+            console.log(chalk.red('\n✗ Please provide a prompt to improve\n'));
+            console.log(chalk.gray('Example:'), chalk.cyan('clavix improve "Create a login page"'));
+            return;
+        }
+        // Determine depth level
+        let depthLevel;
+        if (flags.comprehensive && flags.standard) {
+            console.log(chalk.yellow('\n⚠️  Cannot use both --comprehensive and --standard\n'));
+            console.log(chalk.gray('Using smart auto-detection instead...\n'));
+            depthLevel = await this.autoDetectDepth(args.prompt);
+        }
+        else if (flags.comprehensive) {
+            depthLevel = 'comprehensive';
+            console.log(chalk.bold.cyan('\n🔍 Performing comprehensive analysis...\n'));
+            console.log(chalk.gray('This may take up to 15 seconds for thorough exploration\n'));
+        }
+        else if (flags.standard) {
+            depthLevel = 'standard';
+            console.log(chalk.bold.cyan('\n🔍 Performing standard analysis...\n'));
+        }
+        else {
+            depthLevel = await this.autoDetectDepth(args.prompt);
+        }
+        // Run optimization
+        const optimizer = new UniversalOptimizer();
+        const result = await optimizer.optimize(args.prompt, 'improve', { depthLevel });
+        // Handle --analysis-only flag
+        if (flags['analysis-only']) {
+            this.displayAnalysisOnly(result, depthLevel);
+            return;
+        }
+        // Display full output
+        this.displayOutput(result, depthLevel);
+        // Save prompt to file system
+        await this.savePrompt(result, depthLevel);
+    }
+    /**
+     * v4.11: Smart depth auto-detection based on quality score
+     */
+    async autoDetectDepth(prompt) {
+        console.log(chalk.bold.cyan('\n🔍 Analyzing prompt quality...\n'));
+        // Quick analysis to determine depth
+        const optimizer = new UniversalOptimizer();
+        const quickResult = await optimizer.optimize(prompt, 'improve', { depthLevel: 'standard' });
+        const qualityScore = quickResult.quality.overall;
+        // v4.11 thresholds
+        if (qualityScore >= 75) {
+            // High quality - recommend comprehensive for extra polish
+            console.log(chalk.cyan(`Quality score: ${qualityScore.toFixed(0)}% - Recommending comprehensive depth\n`));
+            return 'comprehensive';
+        }
+        else if (qualityScore >= 60) {
+            // Borderline - ask user
+            console.log(chalk.yellow(`Quality score: ${qualityScore.toFixed(0)}% - Borderline quality\n`));
+            const { choice } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'choice',
+                    message: 'Choose analysis depth:',
+                    choices: [
+                        {
+                            name: 'Comprehensive (alternative approaches, edge cases, validation)',
+                            value: 'comprehensive',
+                        },
+                        { name: 'Standard (quick improvements)', value: 'standard' },
+                    ],
+                },
+            ]);
+            console.log();
+            return choice;
+        }
+        else {
+            // Low quality - standard is fine, comprehensive would add noise
+            console.log(chalk.cyan(`Quality score: ${qualityScore.toFixed(0)}% - Using standard depth\n`));
+            return 'standard';
+        }
+    }
+    displayOutput(result, depthLevel) {
+        const modeLabel = depthLevel === 'comprehensive' ? 'Comprehensive' : 'Standard';
+        console.log(chalk.bold.cyan(`🔍 ${modeLabel} Analysis Complete\n`));
+        // Intent Analysis
+        console.log(chalk.bold.cyan('🎯 Intent Analysis:\n'));
+        console.log(chalk.cyan(`  Type: ${result.intent.primaryIntent}`));
+        console.log(chalk.cyan(`  Confidence: ${result.intent.confidence}%`));
+        if (depthLevel === 'comprehensive') {
+            console.log(chalk.cyan(`  Characteristics:`));
+            console.log(chalk.cyan(`    • Has code context: ${result.intent.characteristics.hasCodeContext ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Technical terms: ${result.intent.characteristics.hasTechnicalTerms ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Open-ended: ${result.intent.characteristics.isOpenEnded ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Needs structure: ${result.intent.characteristics.needsStructure ? 'Yes' : 'No'}`));
+        }
+        console.log();
+        // Quality Metrics
+        console.log(chalk.bold('📊 Quality Metrics:\n'));
+        const getScoreColor = (score) => {
+            if (score >= 80)
+                return chalk.green;
+            if (score >= 60)
+                return chalk.yellow;
+            return chalk.red;
+        };
+        console.log(getScoreColor(result.quality.clarity)(`  Clarity: ${result.quality.clarity.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.efficiency)(`  Efficiency: ${result.quality.efficiency.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.structure)(`  Structure: ${result.quality.structure.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.completeness)(`  Completeness: ${result.quality.completeness.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.actionability)(`  Actionability: ${result.quality.actionability.toFixed(0)}%`));
+        console.log(getScoreColor(result.quality.overall).bold(`\n  Overall: ${result.quality.overall.toFixed(0)}%\n`));
+        // Strengths
+        if (result.quality.strengths.length > 0) {
+            console.log(chalk.bold.green('✅ Strengths:\n'));
+            result.quality.strengths.forEach((strength) => {
+                console.log(chalk.green(`  • ${strength}`));
+            });
+            console.log();
+        }
+        // Improvements Applied
+        if (result.improvements.length > 0) {
+            console.log(chalk.bold.magenta('✨ Improvements Applied:\n'));
+            result.improvements.forEach((improvement) => {
+                const emoji = improvement.impact === 'high' ? '🔥' : improvement.impact === 'medium' ? '⚡' : '💡';
+                console.log(chalk.magenta(`  ${emoji} ${improvement.description} [${improvement.dimension}]`));
+            });
+            console.log();
+        }
+        // Enhanced Prompt
+        console.log(chalk.bold.cyan('✨ Enhanced Prompt:\n'));
+        console.log(chalk.dim('─'.repeat(80)));
+        console.log(result.enhanced);
+        console.log(chalk.dim('─'.repeat(80)));
+        console.log();
+        // Patterns Applied (comprehensive mode)
+        if (depthLevel === 'comprehensive' && result.appliedPatterns.length > 0) {
+            console.log(chalk.bold.blue('🧩 Patterns Applied:\n'));
+            result.appliedPatterns.forEach((pattern) => {
+                console.log(chalk.blue(`  • ${pattern.name}: ${pattern.description}`));
+            });
+            console.log();
+        }
+        // Remaining Issues
+        if (result.quality.remainingIssues && result.quality.remainingIssues.length > 0) {
+            console.log(chalk.bold.yellow('⚠️  Remaining Areas for Improvement:\n'));
+            result.quality.remainingIssues.forEach((issue) => {
+                console.log(chalk.yellow(`  • ${issue}`));
+            });
+            console.log();
+        }
+        // Recommendation
+        const recommendation = new UniversalOptimizer().getRecommendation(result);
+        if (recommendation) {
+            console.log(chalk.blue.bold('💡 Recommendation:'));
+            console.log(chalk.blue(`  ${recommendation}\n`));
+        }
+        console.log(chalk.gray(`⚡ Processed in ${result.processingTimeMs}ms\n`));
+        if (depthLevel === 'comprehensive') {
+            console.log(chalk.gray('💡 Tip: The enhanced prompt includes alternative approaches, edge cases, and validation checklist\n'));
+        }
+        else {
+            console.log(chalk.gray('💡 Tip: Copy the enhanced prompt above and use it with your AI agent\n'));
+        }
+    }
+    displayAnalysisOnly(result, depthLevel) {
+        console.log(chalk.bold.cyan('🎯 Intent Analysis:\n'));
+        console.log(chalk.cyan(`  Type: ${result.intent.primaryIntent}`));
+        console.log(chalk.cyan(`  Confidence: ${result.intent.confidence}%`));
+        console.log(chalk.cyan(`  Depth: ${depthLevel}`));
+        if (depthLevel === 'comprehensive') {
+            console.log(chalk.cyan(`  Characteristics:`));
+            console.log(chalk.cyan(`    • Has code context: ${result.intent.characteristics.hasCodeContext ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Technical terms: ${result.intent.characteristics.hasTechnicalTerms ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Open-ended: ${result.intent.characteristics.isOpenEnded ? 'Yes' : 'No'}`));
+            console.log(chalk.cyan(`    • Needs structure: ${result.intent.characteristics.needsStructure ? 'Yes' : 'No'}`));
+        }
+        console.log();
+        console.log(chalk.bold('📊 Quality Scores:\n'));
+        console.log(chalk.white(`  Clarity: ${result.quality.clarity.toFixed(0)}%`));
+        console.log(chalk.white(`  Efficiency: ${result.quality.efficiency.toFixed(0)}%`));
+        console.log(chalk.white(`  Structure: ${result.quality.structure.toFixed(0)}%`));
+        console.log(chalk.white(`  Completeness: ${result.quality.completeness.toFixed(0)}%`));
+        console.log(chalk.white(`  Actionability: ${result.quality.actionability.toFixed(0)}%`));
+        console.log(chalk.bold(`\n  Overall: ${result.quality.overall.toFixed(0)}%\n`));
+        if (result.quality.strengths.length > 0) {
+            console.log(chalk.bold.green('✅ Strengths:\n'));
+            result.quality.strengths.forEach((strength) => {
+                console.log(chalk.green(`  • ${strength}`));
+            });
+            console.log();
+        }
+    }
+    async savePrompt(result, depthLevel) {
+        try {
+            const manager = new PromptManager();
+            const content = result.enhanced;
+            await manager.savePrompt(content, depthLevel, result.original);
+            console.log(chalk.gray(`💾 Saved prompt to .clavix/outputs/prompts/\n`));
+        }
+        catch (error) {
+            console.log(chalk.yellow('⚠️  Could not save prompt to file system'));
+            console.log(chalk.gray('Error: ' + (error instanceof Error ? error.message : 'Unknown error')));
+        }
+    }
+}
+//# sourceMappingURL=improve.js.map