codeseeker 1.4.0

package/dist/cli/services/analysis/user-intentions/llm-intention-detector.d.ts

@@ -0,0 +1,64 @@
+/**
+ * LLM-based Intention Detection Service
+ * Uses existing Claude Code integration to analyze user intentions and assumptions
+ * Provides interactive clarification system for ambiguous requests
+ */
+export type IntentionType = 'feature_implementation' | 'feature_enhancement' | 'new_component' | 'new_service' | 'new_utility' | 'api_development' | 'ui_development' | 'database_changes' | 'integration_development' | 'bug_fix' | 'hotfix' | 'performance_optimization' | 'security_fix' | 'dependency_update' | 'code_cleanup' | 'technical_debt_reduction' | 'legacy_modernization' | 'refactoring' | 'architectural_change' | 'design_pattern_implementation' | 'scalability_improvement' | 'modularity_improvement' | 'abstraction_addition' | 'testing' | 'test_automation' | 'code_review' | 'quality_assurance' | 'performance_testing' | 'security_testing' | 'integration_testing' | 'codebase_analysis' | 'requirement_analysis' | 'feasibility_study' | 'research' | 'documentation_review' | 'impact_analysis' | 'technology_evaluation' | 'documentation' | 'code_documentation' | 'api_documentation' | 'user_documentation' | 'architecture_documentation' | 'process_documentation' | 'knowledge_transfer' | 'deployment' | 'configuration' | 'monitoring_setup' | 'ci_cd_setup' | 'infrastructure_setup' | 'environment_setup' | 'automation_script' | 'learning' | 'proof_of_concept' | 'experimental_feature' | 'technology_spike' | 'prototype_development' | 'concept_validation' | 'planning' | 'estimation' | 'task_breakdown' | 'project_setup' | 'workflow_optimization' | 'process_improvement';
+export type AssumptionCategory = 'scope' | 'approach' | 'technology' | 'architecture' | 'data' | 'integration' | 'behavior' | 'format' | 'timeline' | 'quality' | 'performance' | 'security' | 'testing' | 'deployment' | 'maintenance' | 'compatibility' | 'resources';
+export interface AssumptionDetail {
+    category: AssumptionCategory;
+    description: string;
+    confidence: number;
+    alternatives: string[];
+    impact: 'low' | 'medium' | 'high' | 'critical';
+    userSelectable: boolean;
+}
+export interface AmbiguityDetail {
+    id: string;
+    area: string;
+    reason: string;
+    clarificationNeeded: string;
+    options: string[];
+    allowCustomInput: boolean;
+    priority: 'low' | 'medium' | 'high' | 'critical';
+}
+export interface UserClarification {
+    ambiguityId: string;
+    selectedOption?: number;
+    customInput?: string;
+    timestamp: number;
+}
+export interface IntentionAnalysis {
+    primaryIntent: IntentionType;
+    confidence: number;
+    subIntents: IntentionType[];
+    assumptions: AssumptionDetail[];
+    ambiguities: AmbiguityDetail[];
+    urgency: 'low' | 'medium' | 'high' | 'critical';
+    complexity: 'trivial' | 'simple' | 'moderate' | 'complex' | 'very_complex' | 'unknown';
+    estimatedDuration: 'minutes' | 'hours' | 'days' | 'weeks' | 'unknown';
+    requiredSkills: string[];
+    potentialRisks: string[];
+}
+export interface ClarifiedIntentionAnalysis extends IntentionAnalysis {
+    userClarifications: UserClarification[];
+    finalInstructions: string;
+}
+export declare class LLMIntentionDetector {
+    private enableLLM;
+    constructor(enableLLM?: boolean);
+    analyzeIntention(userInput: string): Promise<IntentionAnalysis | null>;
+    /**
+     * Get all possible intention types grouped by category
+     */
+    getIntentionCategories(): Record<string, IntentionType[]>;
+    /**
+     * Apply user clarifications to create final instructions
+     */
+    applyClarifications(analysis: IntentionAnalysis, clarifications: UserClarification[]): ClarifiedIntentionAnalysis;
+    private buildAnalysisPrompt;
+    private parseResponse;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+}
+//# sourceMappingURL=llm-intention-detector.d.ts.map

package/dist/cli/services/analysis/user-intentions/llm-intention-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-intention-detector.d.ts","sourceRoot":"","sources":["../../../../../src/cli/services/analysis/user-intentions/llm-intention-detector.ts"],"names":[],"mappings":"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"}

package/dist/cli/services/analysis/user-intentions/llm-intention-detector.js

@@ -0,0 +1,269 @@
+"use strict";
+/**
+ * LLM-based Intention Detection Service
+ * Uses existing Claude Code integration to analyze user intentions and assumptions
+ * Provides interactive clarification system for ambiguous requests
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMIntentionDetector = void 0;
+const command_processor_1 = require("../../../managers/command-processor");
+class LLMIntentionDetector {
+    enableLLM;
+    constructor(enableLLM = true) {
+        this.enableLLM = enableLLM;
+    }
+    async analyzeIntention(userInput) {
+        if (!this.enableLLM) {
+            return null;
+        }
+        try {
+            const prompt = this.buildAnalysisPrompt(userInput);
+            const response = await command_processor_1.CommandProcessor.executeClaudeCode(prompt, {
+                maxTokens: 12000, // Increased for comprehensive analysis
+                outputFormat: 'text',
+                timeout: 90000
+            });
+            if (!response.success) {
+                throw new Error(`Claude Code request failed: ${response.error}`);
+            }
+            return this.parseResponse(response.data || '');
+        }
+        catch (error) {
+            console.warn(`LLM intention detection failed: ${error.message}`);
+            return null;
+        }
+    }
+    /**
+     * Get all possible intention types grouped by category
+     */
+    getIntentionCategories() {
+        return {
+            'Development': [
+                'feature_implementation', 'feature_enhancement', 'new_component', 'new_service', 'new_utility',
+                'api_development', 'ui_development', 'database_changes', 'integration_development'
+            ],
+            'Maintenance': [
+                'bug_fix', 'hotfix', 'performance_optimization', 'security_fix', 'dependency_update',
+                'code_cleanup', 'technical_debt_reduction', 'legacy_modernization'
+            ],
+            'Architecture & Design': [
+                'refactoring', 'architectural_change', 'design_pattern_implementation',
+                'scalability_improvement', 'modularity_improvement', 'abstraction_addition'
+            ],
+            'Quality & Testing': [
+                'testing', 'test_automation', 'code_review', 'quality_assurance',
+                'performance_testing', 'security_testing', 'integration_testing'
+            ],
+            'Research & Analysis': [
+                'codebase_analysis', 'requirement_analysis', 'feasibility_study', 'research',
+                'documentation_review', 'impact_analysis', 'technology_evaluation'
+            ],
+            'Documentation': [
+                'documentation', 'code_documentation', 'api_documentation', 'user_documentation',
+                'architecture_documentation', 'process_documentation', 'knowledge_transfer'
+            ],
+            'DevOps & Operations': [
+                'deployment', 'configuration', 'monitoring_setup', 'ci_cd_setup',
+                'infrastructure_setup', 'environment_setup', 'automation_script'
+            ],
+            'Learning & Exploration': [
+                'learning', 'proof_of_concept', 'experimental_feature', 'technology_spike',
+                'prototype_development', 'concept_validation'
+            ],
+            'Project Management': [
+                'planning', 'estimation', 'task_breakdown', 'project_setup',
+                'workflow_optimization', 'process_improvement'
+            ]
+        };
+    }
+    /**
+     * Apply user clarifications to create final instructions
+     */
+    applyClarifications(analysis, clarifications) {
+        const instructions = [];
+        // Add primary intent
+        instructions.push(`PRIMARY INTENTION: ${analysis.primaryIntent}`);
+        // Add sub-intents if any
+        if (analysis.subIntents.length > 0) {
+            instructions.push(`SECONDARY INTENTIONS: ${analysis.subIntents.join(', ')}`);
+        }
+        // Process clarifications
+        instructions.push('\nUSER CLARIFICATIONS:');
+        for (const clarification of clarifications) {
+            const ambiguity = analysis.ambiguities.find(a => a.id === clarification.ambiguityId);
+            if (ambiguity) {
+                if (clarification.selectedOption !== undefined) {
+                    const selectedOption = ambiguity.options[clarification.selectedOption];
+                    instructions.push(`- ${ambiguity.area}: ${selectedOption}`);
+                }
+                else if (clarification.customInput) {
+                    instructions.push(`- ${ambiguity.area}: ${clarification.customInput}`);
+                }
+            }
+        }
+        // Add confirmed assumptions
+        instructions.push('\nCONFIRMED ASSUMPTIONS:');
+        analysis.assumptions.forEach(assumption => {
+            instructions.push(`- ${assumption.category}: ${assumption.description}`);
+        });
+        // Add constraints
+        instructions.push('\nCONSTRAINTS:');
+        instructions.push(`- Urgency: ${analysis.urgency}`);
+        instructions.push(`- Complexity: ${analysis.complexity}`);
+        instructions.push(`- Estimated Duration: ${analysis.estimatedDuration}`);
+        if (analysis.requiredSkills.length > 0) {
+            instructions.push(`- Required Skills: ${analysis.requiredSkills.join(', ')}`);
+        }
+        if (analysis.potentialRisks.length > 0) {
+            instructions.push(`- Potential Risks: ${analysis.potentialRisks.join(', ')}`);
+        }
+        return {
+            ...analysis,
+            userClarifications: clarifications,
+            finalInstructions: instructions.join('\n')
+        };
+    }
+    buildAnalysisPrompt(userInput) {
+        const intentionTypes = Object.values(this.getIntentionCategories()).flat();
+        return `
+You are an expert software development analyst. Analyze the user request comprehensively and identify all intentions, assumptions, and ambiguities.
+
+USER REQUEST: "${userInput}"
+
+Note: Project context and session continuity are handled automatically by Claude Code CLI.
+
+AVAILABLE INTENTION TYPES:
+${intentionTypes.map(type => `- ${type}`).join('\n')}
+
+ANALYSIS REQUIREMENTS:
+
+1. **Primary Intent**: Select the most specific intention type from the list above
+2. **Confidence**: How confident are you (0-1 scale)
+3. **Sub-intents**: Additional secondary intentions (up to 3)
+4. **Assumptions**: Identify assumptions in these categories:
+   - scope, approach, technology, architecture, data, integration, behavior, format
+   - timeline, quality, performance, security, testing, deployment, maintenance, compatibility, resources
+5. **Ambiguities**: Create numbered options for user selection
+6. **Urgency**: low/medium/high/critical
+7. **Complexity**: trivial/simple/moderate/complex/very_complex/unknown
+8. **Duration**: minutes/hours/days/weeks/unknown
+9. **Skills**: Required technical skills
+10. **Risks**: Potential implementation risks
+
+FOR AMBIGUITIES: Create specific selectable options with IDs. Each ambiguity should have:
+- Unique ID (amb_1, amb_2, etc.)
+- 3-5 specific options user can choose from
+- Allow custom input option
+
+RESPOND WITH VALID JSON ONLY:
+
+{
+  "primaryIntent": "specific_intention_type_from_list",
+  "confidence": 0.85,
+  "subIntents": ["secondary_intention_1", "secondary_intention_2"],
+  "assumptions": [
+    {
+      "category": "scope",
+      "description": "Specific assumption description",
+      "confidence": 0.8,
+      "alternatives": ["alternative 1", "alternative 2", "alternative 3"],
+      "impact": "medium",
+      "userSelectable": true
+    }
+  ],
+  "ambiguities": [
+    {
+      "id": "amb_1",
+      "area": "Implementation Scope",
+      "reason": "Request doesn't specify complete vs minimal implementation",
+      "clarificationNeeded": "What level of implementation do you want?",
+      "options": [
+        "Minimal working prototype",
+        "Basic functionality with error handling",
+        "Production-ready with full features",
+        "Enterprise-grade with comprehensive testing"
+      ],
+      "allowCustomInput": true,
+      "priority": "high"
+    }
+  ],
+  "urgency": "medium",
+  "complexity": "moderate",
+  "estimatedDuration": "hours",
+  "requiredSkills": ["TypeScript", "Node.js", "Database Design"],
+  "potentialRisks": ["Breaking changes to existing API", "Performance impact on large datasets"]
+}
+
+Remember: Use exact intention types from the provided list. Create actionable ambiguities with clear options.
+`;
+    }
+    parseResponse(response) {
+        try {
+            // Clean the response to extract JSON
+            let cleanedResponse = response.trim();
+            // Remove markdown code blocks if present
+            cleanedResponse = cleanedResponse.replace(/```(?:json)?\s*([\s\S]*?)\s*```/g, '$1');
+            // Find JSON object boundaries
+            const jsonStart = cleanedResponse.indexOf('{');
+            const jsonEnd = cleanedResponse.lastIndexOf('}') + 1;
+            if (jsonStart >= 0 && jsonEnd > jsonStart) {
+                cleanedResponse = cleanedResponse.substring(jsonStart, jsonEnd);
+            }
+            const parsed = JSON.parse(cleanedResponse);
+            // Validate required fields
+            if (!parsed.primaryIntent || typeof parsed.confidence !== 'number') {
+                throw new Error('Invalid response structure from LLM - missing required fields');
+            }
+            // Ensure confidence is in valid range
+            parsed.confidence = Math.max(0, Math.min(1, parsed.confidence));
+            // Ensure arrays exist
+            parsed.subIntents = parsed.subIntents || [];
+            parsed.assumptions = parsed.assumptions || [];
+            parsed.ambiguities = parsed.ambiguities || [];
+            parsed.requiredSkills = parsed.requiredSkills || [];
+            parsed.potentialRisks = parsed.potentialRisks || [];
+            // Validate and normalize assumptions
+            parsed.assumptions = parsed.assumptions.map((assumption) => ({
+                category: assumption.category || 'scope',
+                description: assumption.description || '',
+                confidence: Math.max(0, Math.min(1, assumption.confidence || 0.5)),
+                alternatives: assumption.alternatives || [],
+                impact: assumption.impact || 'medium',
+                userSelectable: assumption.userSelectable || false
+            }));
+            // Validate and normalize ambiguities
+            parsed.ambiguities = parsed.ambiguities.map((ambiguity, index) => ({
+                id: ambiguity.id || `amb_${index + 1}`,
+                area: ambiguity.area || 'Unspecified Area',
+                reason: ambiguity.reason || '',
+                clarificationNeeded: ambiguity.clarificationNeeded || '',
+                options: ambiguity.options || [],
+                allowCustomInput: ambiguity.allowCustomInput || true,
+                priority: ambiguity.priority || 'medium'
+            }));
+            return {
+                primaryIntent: parsed.primaryIntent,
+                confidence: parsed.confidence,
+                subIntents: parsed.subIntents,
+                assumptions: parsed.assumptions,
+                ambiguities: parsed.ambiguities,
+                urgency: parsed.urgency || 'medium',
+                complexity: parsed.complexity || 'unknown',
+                estimatedDuration: parsed.estimatedDuration || 'unknown',
+                requiredSkills: parsed.requiredSkills,
+                potentialRisks: parsed.potentialRisks
+            };
+        }
+        catch (error) {
+            throw new Error(`Failed to parse LLM response: ${error.message}`);
+        }
+    }
+    setEnabled(enabled) {
+        this.enableLLM = enabled;
+    }
+    isEnabled() {
+        return this.enableLLM;
+    }
+}
+exports.LLMIntentionDetector = LLMIntentionDetector;
+//# sourceMappingURL=llm-intention-detector.js.map

package/dist/cli/services/analysis/user-intentions/llm-intention-detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm-intention-detector.js","sourceRoot":"","sources":["../../../../../src/cli/services/analysis/user-intentions/llm-intention-detector.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,2EAAuE;AAwFvE,MAAa,oBAAoB;IACvB,SAAS,CAAU;IAE3B,YAAY,YAAqB,IAAI;QACnC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,SAAiB;QACtC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,CAAC;YAEnD,MAAM,QAAQ,GAAG,MAAM,oCAAgB,CAAC,iBAAiB,CAAC,MAAM,EAAE;gBAChE,SAAS,EAAE,KAAK,EAAE,uCAAuC;gBACzD,YAAY,EAAE,MAAM;gBACpB,OAAO,EAAE,KAAK;aACf,CAAC,CAAC;YAEH,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CAAC,+BAA+B,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;YACnE,CAAC;YAED,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QACjD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,IAAI,CAAC,mCAAmC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACjE,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACH,sBAAsB;QACpB,OAAO;YACL,aAAa,EAAE;gBACb,wBAAwB,EAAE,qBAAqB,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa;gBAC9F,iBAAiB,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,yBAAyB;aACnF;YACD,aAAa,EAAE;gBACb,SAAS,EAAE,QAAQ,EAAE,0BAA0B,EAAE,cAAc,EAAE,mBAAmB;gBACpF,cAAc,EAAE,0BAA0B,EAAE,sBAAsB;aACnE;YACD,uBAAuB,EAAE;gBACvB,aAAa,EAAE,sBAAsB,EAAE,+BAA+B;gBACtE,yBAAyB,EAAE,wBAAwB,EAAE,sBAAsB;aAC5E;YACD,mBAAmB,EAAE;gBACnB,SAAS,EAAE,iBAAiB,EAAE,aAAa,EAAE,mBAAmB;gBAChE,qBAAqB,EAAE,kBAAkB,EAAE,qBAAqB;aACjE;YACD,qBAAqB,EAAE;gBACrB,mBAAmB,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,UAAU;gBAC5E,sBAAsB,EAAE,iBAAiB,EAAE,uBAAuB;aACnE;YACD,eAAe,EAAE;gBACf,eAAe,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,oBAAoB;gBAChF,4BAA4B,EAAE,uBAAuB,EAAE,oBAAoB;aAC5E;YACD,qBAAqB,EAAE;gBACrB,YAAY,EAAE,eAAe,EAAE,kBAAkB,EAAE,aAAa;gBAChE,sBAAsB,EAAE,mBAAmB,EAAE,mBAAmB;aACjE;YACD,wBAAwB,EAAE;gBACxB,UAAU,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,kBAAkB;gBAC1E,uBAAuB,EAAE,oBAAoB;aAC9C;YACD,oBAAoB,EAAE;gBACpB,UAAU,EAAE,YAAY,EAAE,gBAAgB,EAAE,eAAe;gBAC3D,uBAAuB,EAAE,qBAAqB;aAC/C;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,mBAAmB,CACjB,QAA2B,EAC3B,cAAmC;QAEnC,MAAM,YAAY,GAAa,EAAE,CAAC;QAElC,qBAAqB;QACrB,YAAY,CAAC,IAAI,CAAC,sBAAsB,QAAQ,CAAC,aAAa,EAAE,CAAC,CAAC;QAElE,yBAAyB;QACzB,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnC,YAAY,CAAC,IAAI,CAAC,yBAAyB,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC/E,CAAC;QAED,yBAAyB;QACzB,YAAY,CAAC,IAAI,CAAC,wBAAwB,CAAC,CAAC;QAC5C,KAAK,MAAM,aAAa,IAAI,cAAc,EAAE,CAAC;YAC3C,MAAM,SAAS,GAAG,QAAQ,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,aAAa,CAAC,WAAW,CAAC,CAAC;YACrF,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,aAAa,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;oBAC/C,MAAM,cAAc,GAAG,SAAS,CAAC,OAAO,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;oBACvE,YAAY,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC,CAAC;gBAC9D,CAAC;qBAAM,IAAI,aAAa,CAAC,WAAW,EAAE,CAAC;oBACrC,YAAY,CAAC,IAAI,CAAC,KAAK,SAAS,CAAC,IAAI,KAAK,aAAa,CAAC,WAAW,EAAE,CAAC,CAAC;gBACzE,CAAC;YACH,CAAC;QACH,CAAC;QAED,4BAA4B;QAC5B,YAAY,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;QAC9C,QAAQ,CAAC,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;YACxC,YAAY,CAAC,IAAI,CAAC,KAAK,UAAU,CAAC,QAAQ,KAAK,UAAU,CAAC,WAAW,EAAE,CAAC,CAAC;QAC3E,CAAC,CAAC,CAAC;QAEH,kBAAkB;QAClB,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACpC,YAAY,CAAC,IAAI,CAAC,cAAc,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;QACpD,YAAY,CAAC,IAAI,CAAC,iBAAiB,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC;QAC1D,YAAY,CAAC,IAAI,CAAC,yBAAyB,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CAAC;QAEzE,IAAI,QAAQ,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvC,YAAY,CAAC,IAAI,CAAC,sBAAsB,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAChF,CAAC;QAED,IAAI,QAAQ,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACvC,YAAY,CAAC,IAAI,CAAC,sBAAsB,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAChF,CAAC;QAED,OAAO;YACL,GAAG,QAAQ;YACX,kBAAkB,EAAE,cAAc;YAClC,iBAAiB,EAAE,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC;SAC3C,CAAC;IACJ,CAAC;IAEO,mBAAmB,CAAC,SAAiB;QAC3C,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QAE3E,OAAO;;;iBAGM,SAAS;;;;;EAKxB,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8DnD,CAAC;IACA,CAAC;IAEO,aAAa,CAAC,QAAgB;QACpC,IAAI,CAAC;YACH,qCAAqC;YACrC,IAAI,eAAe,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;YAEtC,yCAAyC;YACzC,eAAe,GAAG,eAAe,CAAC,OAAO,CAAC,kCAAkC,EAAE,IAAI,CAAC,CAAC;YAEpF,8BAA8B;YAC9B,MAAM,SAAS,GAAG,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC/C,MAAM,OAAO,GAAG,eAAe,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAErD,IAAI,SAAS,IAAI,CAAC,IAAI,OAAO,GAAG,SAAS,EAAE,CAAC;gBAC1C,eAAe,GAAG,eAAe,CAAC,SAAS,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;YAClE,CAAC;YAED,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;YAE3C,2BAA2B;YAC3B,IAAI,CAAC,MAAM,CAAC,aAAa,IAAI,OAAO,MAAM,CAAC,UAAU,KAAK,QAAQ,EAAE,CAAC;gBACnE,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;YACnF,CAAC;YAED,sCAAsC;YACtC,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;YAEhE,sBAAsB;YACtB,MAAM,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC;YAC5C,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,EAAE,CAAC;YAC9C,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,IAAI,EAAE,CAAC;YAC9C,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,IAAI,EAAE,CAAC;YACpD,MAAM,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,IAAI,EAAE,CAAC;YAEpD,qCAAqC;YACrC,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,UAAe,EAAE,EAAE,CAAC,CAAC;gBAChE,QAAQ,EAAE,UAAU,CAAC,QAAQ,IAAI,OAAO;gBACxC,WAAW,EAAE,UAAU,CAAC,WAAW,IAAI,EAAE;gBACzC,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,UAAU,IAAI,GAAG,CAAC,CAAC;gBAClE,YAAY,EAAE,UAAU,CAAC,YAAY,IAAI,EAAE;gBAC3C,MAAM,EAAE,UAAU,CAAC,MAAM,IAAI,QAAQ;gBACrC,cAAc,EAAE,UAAU,CAAC,cAAc,IAAI,KAAK;aACnD,CAAC,CAAC,CAAC;YAEJ,qCAAqC;YACrC,MAAM,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,SAAc,EAAE,KAAa,EAAE,EAAE,CAAC,CAAC;gBAC9E,EAAE,EAAE,SAAS,CAAC,EAAE,IAAI,OAAO,KAAK,GAAG,CAAC,EAAE;gBACtC,IAAI,EAAE,SAAS,CAAC,IAAI,IAAI,kBAAkB;gBAC1C,MAAM,EAAE,SAAS,CAAC,MAAM,IAAI,EAAE;gBAC9B,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,IAAI,EAAE;gBACxD,OAAO,EAAE,SAAS,CAAC,OAAO,IAAI,EAAE;gBAChC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,IAAI,IAAI;gBACpD,QAAQ,EAAE,SAAS,CAAC,QAAQ,IAAI,QAAQ;aACzC,CAAC,CAAC,CAAC;YAEJ,OAAO;gBACL,aAAa,EAAE,MAAM,CAAC,aAAa;gBACnC,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,WAAW,EAAE,MAAM,CAAC,WAAW;gBAC/B,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,QAAQ;gBACnC,UAAU,EAAE,MAAM,CAAC,UAAU,IAAI,SAAS;gBAC1C,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,IAAI,SAAS;gBACxD,cAAc,EAAE,MAAM,CAAC,cAAc;gBACrC,cAAc,EAAE,MAAM,CAAC,cAAc;aACtC,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,iCAAiC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACpE,CAAC;IACH,CAAC;IAED,UAAU,CAAC,OAAgB;QACzB,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC;IAC3B,CAAC;IAED,SAAS;QACP,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;CACF;AAhSD,oDAgSC"}

package/dist/cli/services/analysis/user-intentions/user-clarification-service.d.ts

@@ -0,0 +1,52 @@
+/**
+ * User Clarification Service
+ * Handles user interaction for assumption clarification
+ * Integrates with readline interface for real-time feedback
+ */
+import * as readline from 'readline';
+import { AmbiguityAnalysis, DetectedAssumption } from './assumption-detector';
+export interface ClarificationResponse {
+    originalRequest: string;
+    assumptions: DetectedAssumption[];
+    userChoices: Map<string, string>;
+    clarifiedPrompt: string;
+    shouldProceed: boolean;
+}
+export declare class UserClarificationService {
+    private rl;
+    constructor(rl: readline.Interface);
+    /**
+     * Present assumptions to user and collect clarifications (streamlined)
+     */
+    requestClarification(originalRequest: string, analysis: AmbiguityAnalysis): Promise<ClarificationResponse>;
+    /**
+     * Simple prompt for user input
+     */
+    private promptUser;
+    /**
+     * Confirm if user wants to proceed
+     */
+    private confirmProceed;
+    /**
+     * Build simple clarified prompt for Claude Code
+     */
+    private buildSimpleClarifiedPrompt;
+    /**
+     * Generate final approach summary based on user choices
+     */
+    private generateFinalApproach;
+    /**
+     * Build enhanced prompt with clarifications for Claude Code
+     */
+    private buildClarifiedPrompt;
+    /**
+     * Quick yes/no confirmation
+     */
+    quickConfirm(message: string): Promise<boolean>;
+    /**
+     * Present simple multiple choice
+     */
+    multipleChoice(question: string, choices: string[]): Promise<number>;
+}
+export default UserClarificationService;
+//# sourceMappingURL=user-clarification-service.d.ts.map

package/dist/cli/services/analysis/user-intentions/user-clarification-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-clarification-service.d.ts","sourceRoot":"","sources":["../../../../../src/cli/services/analysis/user-intentions/user-clarification-service.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAC;AAErC,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE9E,MAAM,WAAW,qBAAqB;IACpC,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,kBAAkB,EAAE,CAAC;IAClC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,qBAAa,wBAAwB;IACnC,OAAO,CAAC,EAAE,CAAqB;gBAEnB,EAAE,EAAE,QAAQ,CAAC,SAAS;IAIlC;;OAEG;IACG,oBAAoB,CACxB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,iBAAiB,GAC1B,OAAO,CAAC,qBAAqB,CAAC;IAwCjC;;OAEG;YACW,UAAU;IAYxB;;OAEG;YACW,cAAc;IAwB5B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAclC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAuC7B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA8B5B;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAoBrD;;OAEG;IACG,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;CA0B3E;AAED,eAAe,wBAAwB,CAAC"}

package/dist/cli/services/analysis/user-intentions/user-clarification-service.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * User Clarification Service
+ * Handles user interaction for assumption clarification
+ * Integrates with readline interface for real-time feedback
+ */
+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.UserClarificationService = void 0;
+const readline = __importStar(require("readline"));
+const theme_1 = require("../../../ui/theme");
+class UserClarificationService {
+    rl;
+    constructor(rl) {
+        this.rl = rl;
+    }
+    /**
+     * Present assumptions to user and collect clarifications (streamlined)
+     */
+    async requestClarification(originalRequest, analysis) {
+        if (!analysis.hasAmbiguities) {
+            return {
+                originalRequest,
+                assumptions: [],
+                userChoices: new Map(),
+                clarifiedPrompt: originalRequest,
+                shouldProceed: true
+            };
+        }
+        // Streamlined output - one line per key assumption
+        console.log(theme_1.Theme.colors.info(`🔍 Intention: ${analysis.assumptions[0]?.assumption || 'Processing request'}`));
+        // Quick proceed/cancel check instead of detailed clarification
+        const shouldProceed = await this.quickConfirm('Proceed with this approach?');
+        if (!shouldProceed) {
+            console.log(theme_1.Theme.colors.muted('Please refine your request and try again.'));
+            return {
+                originalRequest,
+                assumptions: analysis.assumptions,
+                userChoices: new Map(),
+                clarifiedPrompt: originalRequest,
+                shouldProceed: false
+            };
+        }
+        // Return original request without modification to avoid confusion
+        const clarifiedPrompt = originalRequest;
+        return {
+            originalRequest,
+            assumptions: analysis.assumptions,
+            userChoices: new Map(),
+            clarifiedPrompt,
+            shouldProceed: true
+        };
+    }
+    /**
+     * Simple prompt for user input
+     */
+    async promptUser() {
+        return new Promise((resolve) => {
+            // Temporarily pause the main prompt
+            this.rl.pause();
+            this.rl.question(theme_1.Theme.colors.prompt('   Your preference: '), (answer) => {
+                // Resume the main prompt after getting input
+                this.rl.resume();
+                resolve(answer.trim());
+            });
+        });
+    }
+    /**
+     * Confirm if user wants to proceed
+     */
+    async confirmProceed() {
+        return new Promise((resolve) => {
+            // Temporarily pause the main prompt
+            this.rl.pause();
+            this.rl.question(theme_1.Theme.colors.prompt('\n✅ Proceed with this approach? [Y/n]: '), (answer) => {
+                const proceed = answer.trim().toLowerCase();
+                const shouldProceed = proceed === '' || proceed === 'y' || proceed === 'yes';
+                if (shouldProceed) {
+                    console.log(theme_1.Theme.colors.success('🚀 Great! Sending clarified request to Claude Code...'));
+                }
+                else {
+                    console.log(theme_1.Theme.colors.info('🔄 Let\'s refine the request. Please rephrase your original request.'));
+                }
+                // Resume the main prompt after getting input
+                this.rl.resume();
+                resolve(shouldProceed);
+            });
+        });
+    }
+    /**
+     * Build simple clarified prompt for Claude Code
+     */
+    buildSimpleClarifiedPrompt(originalRequest, analysis) {
+        let clarifiedPrompt = originalRequest;
+        // Add brief context about assumptions
+        if (analysis.assumptions.length > 0) {
+            clarifiedPrompt += '\n\n**Context:** User confirmed proceeding with standard approach for this request.';
+        }
+        return clarifiedPrompt;
+    }
+    /**
+     * Generate final approach summary based on user choices
+     */
+    generateFinalApproach(analysis, userChoices) {
+        const approach = [];
+        // Add interpretations based on user choices
+        for (const [question, answer] of userChoices) {
+            if (answer.toLowerCase().includes('existing') || answer.toLowerCase().includes('current')) {
+                approach.push('Use existing codebase patterns and integrate with current architecture');
+            }
+            else if (answer.toLowerCase().includes('new') || answer.toLowerCase().includes('scratch')) {
+                approach.push('Create new implementation from scratch');
+            }
+            else if (answer.toLowerCase().includes('minimal') || answer.toLowerCase().includes('simple')) {
+                approach.push('Create minimal working implementation');
+            }
+            else if (answer.toLowerCase().includes('complete') || answer.toLowerCase().includes('full')) {
+                approach.push('Build complete production-ready feature');
+            }
+            else if (answer.toLowerCase().includes('mock') || answer.toLowerCase().includes('placeholder')) {
+                approach.push('Use mock data and placeholder implementations');
+            }
+            else if (answer.toLowerCase().includes('real') || answer.toLowerCase().includes('actual')) {
+                approach.push('Connect to real data sources and services');
+            }
+            else {
+                approach.push(`Follow user preference: "${answer}"`);
+            }
+        }
+        // Add default assumptions that weren't clarified
+        const unclarifiedAssumptions = analysis.assumptions.filter(assumption => !Array.from(userChoices.keys()).some(question => question.toLowerCase().includes(assumption.category)));
+        unclarifiedAssumptions.forEach(assumption => {
+            approach.push(`Default assumption: ${assumption.assumption}`);
+        });
+        return approach;
+    }
+    /**
+     * Build enhanced prompt with clarifications for Claude Code
+     */
+    buildClarifiedPrompt(originalRequest, analysis, userChoices) {
+        let clarifiedPrompt = originalRequest;
+        // Add clarification section
+        clarifiedPrompt += '\n\n**USER CLARIFICATIONS:**\n';
+        for (const [question, answer] of userChoices) {
+            clarifiedPrompt += `- ${question}\n  → ${answer}\n\n`;
+        }
+        // Add structured requirements
+        clarifiedPrompt += '**IMPORTANT REQUIREMENTS:**\n';
+        clarifiedPrompt += '1. Please acknowledge these clarifications in your response\n';
+        clarifiedPrompt += '2. Include an "assumptions" field in your JSON response listing any remaining assumptions\n';
+        clarifiedPrompt += '3. If you still need clarification on anything, ask specific questions before implementing\n';
+        clarifiedPrompt += '4. Structure your response to be clear about what you\'re building\n\n';
+        // Add assumption context
+        clarifiedPrompt += '**DETECTED ASSUMPTIONS (for context):**\n';
+        analysis.assumptions.forEach((assumption, index) => {
+            clarifiedPrompt += `${index + 1}. [${assumption.category}] ${assumption.assumption}\n`;
+        });
+        return clarifiedPrompt;
+    }
+    /**
+     * Quick yes/no confirmation
+     */
+    async quickConfirm(message) {
+        return new Promise((resolve) => {
+            // Create a temporary interface to avoid conflicts with the main CLI loop
+            const tempRl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            tempRl.question(theme_1.Theme.colors.prompt(`${message} [Y/n]: `), (answer) => {
+                const confirmed = answer.trim().toLowerCase();
+                const shouldProceed = confirmed === '' || confirmed === 'y' || confirmed === 'yes';
+                tempRl.close();
+                resolve(shouldProceed);
+            });
+        });
+    }
+    /**
+     * Present simple multiple choice
+     */
+    async multipleChoice(question, choices) {
+        console.log(theme_1.Theme.colors.secondary(question));
+        choices.forEach((choice, index) => {
+            console.log(theme_1.Theme.colors.info(`${index + 1}. ${choice}`));
+        });
+        return new Promise((resolve) => {
+            // Temporarily pause the main prompt
+            this.rl.pause();
+            this.rl.question(theme_1.Theme.colors.prompt(`Choose [1-${choices.length}]: `), (answer) => {
+                const choice = parseInt(answer.trim());
+                if (choice >= 1 && choice <= choices.length) {
+                    console.log(theme_1.Theme.colors.success(`✓ Selected: ${choices[choice - 1]}`));
+                    resolve(choice - 1);
+                }
+                else {
+                    console.log(theme_1.Theme.colors.error('Invalid choice. Defaulting to option 1.'));
+                    resolve(0);
+                }
+                // Resume the main prompt after getting input
+                this.rl.resume();
+            });
+        });
+    }
+}
+exports.UserClarificationService = UserClarificationService;
+exports.default = UserClarificationService;
+//# sourceMappingURL=user-clarification-service.js.map