cntx-ui 2.0.13 → 2.0.15

package/templates/agent-rules/capabilities/vector-search.md

@@ -0,0 +1,135 @@
+# Vector Search Capabilities
+
+## Overview
+Vector search provides semantic code discovery through embedding-based similarity matching. This is the most efficient method for conceptual code exploration.
+
+## When Available
+- Look for vector database endpoints: `/api/vector-db/*`
+- Check database status: `GET /api/vector-db/status`
+- Verify chunk count and model information
+
+## Core Capabilities
+
+### Semantic Search
+**Endpoint**: `POST /api/vector-db/search`
+
+**Use for**:
+- "Find functions that handle user authentication"
+- "Locate error handling patterns"
+- "Discover similar implementations"
+- "Explore feature-related code"
+
+**Query Format**:
+```json
+{
+  "query": "semantic description of what you're looking for",
+  "limit": 5,
+  "minSimilarity": 0.2
+}
+```
+
+**Best Practices**:
+- Use 3-5 descriptive words: "user authentication login session"
+- Be conceptual, not literal: "form validation" not "validateForm function"
+- Lower similarity thresholds (0.1-0.2) for broader discovery
+- Higher limits (5-10) for comprehensive exploration
+
+### Type-Based Search
+**Endpoint**: `POST /api/vector-db/search-by-type`
+
+**Use for**:
+- Finding all React components: `{"type": "react_component"}`
+- Locating API handlers: `{"type": "api_integration"}`
+- Discovering utility functions: `{"type": "utility"}`
+
+### Domain-Based Search  
+**Endpoint**: `POST /api/vector-db/search-by-domain`
+
+**Use for**:
+- Business domain exploration: `{"domain": "authentication"}`
+- Technical domain focus: `{"domain": "user-interface"}`
+- Architectural layer discovery: `{"domain": "api"}`
+
+## Response Interpretation
+
+### Result Structure
+```json
+{
+  "results": [
+    {
+      "id": "functionName",
+      "similarity": 0.85,
+      "metadata": {
+        "content": "actual code",
+        "semanticType": "react_component",
+        "businessDomain": ["authentication"],
+        "technicalPatterns": ["hooks", "async_operations"],
+        "purpose": "User login form",
+        "files": ["src/auth/LoginForm.tsx"],
+        "complexity": {"score": 5, "level": "medium"}
+      }
+    }
+  ]
+}
+```
+
+### Similarity Scores
+- **0.8+**: Highly relevant, direct match
+- **0.6-0.8**: Good relevance, related functionality  
+- **0.4-0.6**: Potentially relevant, worth investigating
+- **0.2-0.4**: Loosely related, may provide context
+- **<0.2**: Probably not relevant
+
+### Metadata Usage
+- **semanticType**: Code classification (component, function, etc.)
+- **businessDomain**: Functional area (auth, ui, api, etc.)
+- **technicalPatterns**: Implementation patterns (async, hooks, etc.)
+- **purpose**: Human-readable function description
+- **complexity**: Cognitive complexity metrics
+
+## Query Optimization Strategies
+
+### Progressive Refinement
+1. Start broad: "user management"
+2. Refine: "user authentication login"
+3. Specific: "user login form validation"
+
+### Multiple Approaches
+- Try different phrasings: "data fetching" vs "API calls" vs "HTTP requests"
+- Use synonyms: "configuration" vs "settings" vs "options"
+- Vary abstraction level: "React hooks" vs "state management" vs "useState"
+
+### Fallback Strategies
+1. **Lower similarity**: Try minSimilarity: 0.1 for broader results
+2. **Increase limit**: Get more results to find relevant matches
+3. **Different endpoints**: Try search-by-type or search-by-domain
+4. **Simpler queries**: Use fewer, more basic terms
+
+## Performance Characteristics
+
+### Speed
+- **Typical response**: 20-50ms
+- **Token efficiency**: ~5k tokens vs 50k+ for file reading
+- **Real-time updates**: Automatically stays current with code changes
+
+### Accuracy
+- **Best for**: Conceptual discovery and pattern matching
+- **Less effective for**: Exact string matching, specific error messages
+- **Coverage**: Function-level granularity across entire codebase
+
+## Integration Patterns
+
+### Vector-First Workflow
+```
+User Query → Semantic Search → [Optional: Type/Domain Refinement] → Traditional Search (if needed)
+```
+
+### Hybrid Discovery
+1. **Vector search** for broad discovery
+2. **Bundle system** for structural context
+3. **Direct file access** for specific implementation details
+
+### Error Handling
+- **Empty results**: Try broader terms or lower similarity threshold
+- **Server error**: Fall back to bundle system or traditional search
+- **Offline**: Use available cached information and traditional methods

package/templates/agent-rules/core/codebase-navigation.md

@@ -0,0 +1,91 @@
+# Codebase Navigation - Universal Discovery Patterns
+
+## Core Navigation Principles
+
+### 1. Progressive Disclosure
+Start high-level, offer to dive deeper:
+- Project overview → Module details → Function specifics
+- Architecture patterns → Implementation details → Code examples
+- Never overwhelm with unnecessary detail
+
+### 2. Context-Aware Exploration
+- Understand the user's current focus and intent
+- Provide relevant surrounding context
+- Explain relationships between components
+- Reference architectural boundaries and patterns
+
+### 3. Evidence-Based Responses
+Always include:
+- **Specific locations**: `path/to/file.js:23-67`
+- **Confidence indicators**: "Found 3 definitive matches" vs "This appears related"
+- **Source of evidence**: Vector search, AST analysis, or pattern matching
+- **Next step options**: Specific follow-up actions
+
+## Operating Modes
+
+### Discovery Mode
+*"Tell me about this codebase"*
+- Start with project structure and bundle organization
+- Identify key architectural patterns and frameworks
+- Report complexity metrics and code organization
+- Highlight important entry points and main components
+
+### Query Mode  
+*"Where is user authentication handled?"*
+- Use semantic search for conceptual discovery
+- Provide specific file paths and line numbers
+- Explain component relationships and data flow
+- Cross-reference with project structure
+
+### Investigation Mode
+*"I want to add feature X - what exists already?"*
+- Search for related patterns and implementations
+- Use format: ✅ Existing, ⚠️ Partial, ❌ Missing
+- Identify integration points and extension opportunities
+- Recommend extend vs. create new approaches
+
+### Collaboration Mode
+*"Let's discuss the architecture before making changes"*
+- Ask clarifying questions about requirements
+- Suggest alternatives and trade-offs
+- Plan implementation approaches collaboratively
+- Consider project constraints and patterns
+
+## Response Structure Template
+
+```
+Based on [analysis method] of your codebase:
+
+[Direct answer to the question]
+
+Key locations:
+1. Primary implementation in `file.js:lines`
+2. Related functionality in `other.js:lines`  
+3. Configuration in `config.js:lines`
+
+[Brief explanation of relationships and data flow]
+
+Next steps:
+- [Specific actionable options]
+- Would you like me to explore [related area]?
+```
+
+## Navigation Efficiency Rules
+
+### Bundle-Aware Exploration
+- Start with bundle boundaries to understand project organization
+- Respect existing architectural patterns and conventions
+- Use bundle relationships to scope queries appropriately
+- Reference bundle context in explanations
+
+### Semantic Relationships
+- Look for code that works together functionally
+- Identify data flow and dependency patterns  
+- Understand abstraction layers and boundaries
+- Map conceptual relationships to actual code structure
+
+### User Intent Recognition
+- Classify the type of help needed (learning, debugging, extending)
+- Adjust depth and technical detail appropriately
+- Provide context-sensitive suggestions
+- Offer multiple pathways forward based on user goals

package/templates/agent-rules/core/performance-hierarchy.md

@@ -0,0 +1,48 @@
+# Performance Hierarchy - Universal Tool Usage Priority
+
+## Core Principle
+Always use the fastest, most efficient tool available for each task. Optimize for both response time and token efficiency.
+
+## Priority Order
+
+### 1. Vector Database (PRIMARY - if available)
+- **Response time**: ~20ms
+- **Token efficiency**: 90% savings vs traditional search
+- **Best for**: Semantic discovery, pattern matching, "find functions that..."
+- **Query format**: Semantic descriptions (3-5 descriptive words)
+- **Example**: "React component state management"
+
+### 2. Structured APIs (SECONDARY - if available)
+- **Response time**: ~50ms
+- **Token efficiency**: High (pre-processed data)
+- **Best for**: Project structure, metadata, organized information
+- **Examples**: Bundle systems, AST parsing, configuration APIs
+
+### 3. Traditional Search (FALLBACK ONLY)
+- **Response time**: 100ms+
+- **Token efficiency**: Low (raw file content)
+- **Best for**: Exact string matching, specific error messages
+- **Use only when**: Vector search fails or exact keywords needed
+
+## Decision Matrix
+
+| Task Type | Primary Tool | Secondary | Fallback |
+|-----------|-------------|-----------|----------|
+| Code discovery | Vector search | Bundle API | grep/rg |
+| Pattern matching | Vector search | AST parsing | file scanning |
+| Architecture overview | Bundle API | Vector search | directory listing |
+| Exact string search | grep/rg | Vector search | manual search |
+| Error investigation | Vector search | log parsing | file reading |
+
+## Performance Metrics
+- **Vector search**: ~5k tokens per query
+- **Structured APIs**: ~2k tokens per query  
+- **File reading**: ~50k+ tokens per file
+- **Directory scanning**: ~20k tokens per scan
+
+## Universal Guidelines
+1. **Always try semantic search first** for discovery tasks
+2. **Use structured data when available** for metadata
+3. **Reserve traditional search** for exact matches only
+4. **Combine methods intelligently** (vector discovery → precise lookup)
+5. **Fail gracefully** with clear explanations when tools are unavailable

package/templates/agent-rules/core/response-formatting.md

@@ -0,0 +1,120 @@
+# Response Formatting - Universal Communication Standards
+
+## Core Communication Principles
+
+### 1. Clarity and Precision
+- Lead with direct answers to the user's question
+- Use specific, actionable language
+- Avoid unnecessary jargon or complexity
+- Structure information logically
+
+### 2. Evidence and Confidence
+- Always cite specific sources and locations
+- Indicate confidence levels in findings
+- Distinguish between definitive facts and reasonable inferences
+- Acknowledge limitations and uncertainty when appropriate
+
+### 3. Actionable Guidance
+- Provide clear next steps or options
+- Offer specific follow-up questions or actions
+- Help users make informed decisions
+- Enable users to take immediate action
+
+## Response Structure Standards
+
+### Standard Response Template
+```markdown
+## [Direct Answer]
+
+Based on [analysis method]:
+
+### Key Findings:
+1. **Primary location**: `path/file.js:lines` - [brief description]
+2. **Related code**: `path/other.js:lines` - [relationship]
+3. **Configuration**: `path/config.js:lines` - [purpose]
+
+### How it works:
+[Brief explanation of relationships and data flow]
+
+### Next steps:
+- [ ] [Specific actionable option 1]
+- [ ] [Specific actionable option 2]
+- [ ] Would you like me to explore [related area]?
+```
+
+### Confidence Indicators
+
+#### High Confidence (90%+)
+- "Found definitive implementation in..."
+- "The code clearly shows..."
+- "Based on direct analysis of..."
+
+#### Medium Confidence (60-90%)
+- "Analysis suggests this is handled by..."
+- "Appears to be implemented in..."
+- "Evidence points to..."
+
+#### Low Confidence (40-60%)
+- "This might be related to..."
+- "Could potentially be found in..."
+- "Based on naming patterns, likely..."
+
+#### Uncertain (<40%)
+- "No clear evidence found for..."
+- "Unable to locate specific implementation..."
+- "Would need additional investigation to..."
+
+## Code Reference Standards
+
+### File References
+- Always use relative paths from project root
+- Include line numbers when specific: `src/utils.js:45-67`
+- Use descriptive anchor text: `user authentication logic in auth.js:120`
+
+### Code Snippets
+- Include only relevant portions
+- Add context comments when helpful
+- Use syntax highlighting when possible
+- Keep snippets focused and readable
+
+### Evidence Attribution
+- Cite the analysis method used: "Vector search found...", "AST analysis shows..."
+- Reference confidence scores when available: "85% similarity match"
+- Distinguish between different types of evidence
+
+## Formatting Guidelines
+
+### Information Hierarchy
+1. **Direct answer** (what the user asked for)
+2. **Evidence** (where/how you found it)
+3. **Context** (how it fits together)
+4. **Actions** (what to do next)
+
+### Visual Organization
+- Use headers and bullet points for scanability
+- Employ consistent formatting patterns
+- Group related information together
+- Use whitespace effectively for readability
+
+### Technical Precision
+- Use exact function/variable names
+- Reference specific frameworks and patterns correctly
+- Include relevant technical details without overwhelming
+- Provide accurate line numbers and file paths
+
+## Error Communication
+
+### When Tools Fail
+- Clearly state what was attempted: "Vector search returned no results for..."
+- Explain the fallback approach: "Using directory structure analysis instead..."
+- Set appropriate expectations: "Limited to file-based pattern matching..."
+
+### When Information is Incomplete
+- Acknowledge gaps honestly: "Partial implementation found..."
+- Suggest investigation approaches: "You may want to check..."
+- Offer alternative perspectives: "Another approach might be..."
+
+### When Uncertain
+- Express uncertainty clearly: "No definitive evidence found..."
+- Suggest validation steps: "You can verify this by..."
+- Provide multiple possibilities: "This could be handled by either X or Y..."

package/templates/agent-rules/project-specific/architecture.md

@@ -0,0 +1,145 @@
+# Project Architecture - cntx-ui Specific
+
+## Project Overview
+cntx-ui is a semantic code analysis and bundle management system with integrated vector search capabilities, designed to help agents and developers understand and navigate codebases intelligently.
+
+## Technology Stack
+
+### Backend
+- **Node.js**: Server runtime and API layer
+- **Express-style routing**: Custom HTTP request handling
+- **File system operations**: Direct fs module usage for file management
+- **Vector embeddings**: @xenova/transformers for local semantic search
+- **WebSocket**: Real-time updates and communication
+
+### Frontend  
+- **React + TypeScript**: Modern component-based UI
+- **Vite**: Build tool and development server
+- **TanStack Query**: Data fetching and state management
+- **shadcn/ui**: Component library with Radix UI primitives
+- **Tailwind CSS**: Utility-first styling system
+
+### Analysis Engine
+- **Semantic splitter**: Function-level code analysis
+- **Tree-sitter**: AST parsing for precise code understanding
+- **Vector store**: Embedding-based similarity search
+- **Heuristics engine**: Configurable code categorization rules
+
+## Key Architectural Patterns
+
+### Bundle-Driven Organization
+- **Logical groupings**: Files organized by purpose (frontend, backend, ui-components)
+- **Bundle API**: RESTful endpoints for bundle management
+- **Real-time updates**: File watching and automatic regeneration
+- **XML export**: Structured output for external tool consumption
+
+### Semantic Analysis Pipeline
+```
+Source Code → Tree-sitter Parsing → Function Extraction → 
+Semantic Classification → Vector Embedding → Search Index
+```
+
+### Agent-Centric Design
+- **Vector-first discovery**: Semantic search as primary exploration method
+- **Modular instructions**: Composable agent rules and capabilities
+- **Activity system**: Structured task management for complex work
+- **Progressive disclosure**: Start high-level, drill down as needed
+
+## Directory Structure
+
+```
+cntx-ui/
+├── lib/                          # Core analysis engines
+│   ├── semantic-splitter.js      # Function-level code analysis
+│   ├── simple-vector-store.js    # Local embedding search
+│   ├── heuristics-manager.js     # Configurable code classification
+│   └── mcp-server.js             # Model Context Protocol integration
+├── web/                          # React frontend application
+│   ├── src/components/           # UI components
+│   ├── src/lib/                  # Client-side utilities
+│   └── dist/                     # Built static assets
+├── .cntx/                        # Configuration and cache
+│   ├── activities/               # Agent task definitions
+│   ├── agent-rules/              # Modular agent instructions
+│   ├── bundles.json             # Bundle configuration
+│   └── semantic-cache.json      # Analysis cache
+└── server.js                    # Main HTTP server and API
+```
+
+## Key Components and Responsibilities
+
+### Server Layer (`server.js`)
+- **HTTP API**: RESTful endpoints for all functionality
+- **File watching**: Real-time change detection and cache invalidation
+- **Bundle management**: File organization and generation
+- **Vector integration**: Embedding generation and search
+- **Static serving**: Frontend application hosting
+
+### Analysis Engine (`lib/`)
+- **Semantic splitter**: Extracts functions with context and metadata
+- **Vector store**: Manages embeddings and similarity search
+- **Heuristics manager**: Applies configurable classification rules
+- **MCP server**: Provides agent-friendly API access
+
+### Frontend (`web/src/`)
+- **Bundle interface**: Visual bundle management and exploration
+- **Activities dashboard**: Agent task monitoring and file viewing
+- **Semantic visualization**: Vector search and analysis results
+- **Settings management**: Configuration and preferences
+
+## Data Flow Patterns
+
+### Code Analysis Flow
+1. **File change detection** → Cache invalidation
+2. **Semantic analysis** → Function extraction + classification  
+3. **Vector embedding** → Search index update
+4. **Bundle regeneration** → Updated file groupings
+5. **Client notification** → Real-time UI updates
+
+### Agent Discovery Flow
+1. **Vector search** → Semantic code discovery
+2. **Bundle context** → Architectural understanding
+3. **Activity reference** → Task and progress context
+4. **Precise lookup** → Specific implementation details
+
+## Performance Characteristics
+
+### Analysis Performance
+- **Semantic analysis**: ~2-5 seconds for full codebase
+- **Vector embedding**: ~100ms per code chunk
+- **Search queries**: ~20ms response time
+- **Bundle generation**: ~500ms for large bundles
+
+### Caching Strategy
+- **Semantic cache**: 24-hour TTL with change invalidation
+- **Vector index**: In-memory with disk persistence
+- **Bundle cache**: Real-time updates with file watching
+- **Client cache**: React Query with 5-minute TTL
+
+## Integration Points
+
+### Agent Tool Integration
+- **Vector search API**: Semantic code discovery
+- **Bundle API**: Structural project understanding
+- **Activities API**: Task management and progress tracking
+- **MCP protocol**: Standardized agent communication
+
+### External Tool Support
+- **Cursor integration**: .cursorrules file support
+- **GitHub integration**: Repository analysis and understanding
+- **Export formats**: XML bundles for external tool consumption
+- **CLI interface**: Command-line bundle generation
+
+## Development Patterns
+
+### Configuration-Driven Development
+- **Heuristics config**: JSON-based code classification rules
+- **Bundle patterns**: Glob-based file organization
+- **Agent rules**: Modular instruction composition
+- **Environment config**: Flexible deployment options
+
+### Real-Time Architecture
+- **WebSocket communication**: Live updates between server and client
+- **File watching**: Immediate response to code changes
+- **Cache invalidation**: Automatic refresh of stale data
+- **Progressive enhancement**: Graceful degradation when features unavailable

package/templates/config.json

@@ -0,0 +1,76 @@
+{
+  "bundles": {
+    "core-server": [
+      "server.js",
+      "lib/configuration-manager.js",
+      "lib/api-router.js",
+      "lib/websocket-manager.js"
+    ],
+    "bundle-system": [
+      "lib/bundle-manager.js",
+      "lib/file-system-manager.js",
+      "lib/heuristics-manager.js",
+      "heuristics-config.json"
+    ],
+    "ai-processing": [
+      "lib/semantic-splitter.js",
+      "lib/simple-vector-store.js",
+      "lib/function-level-chunker.js",
+      "lib/treesitter-semantic-chunker.js",
+      "lib/agent-runtime.js",
+      "lib/agent-tools.js"
+    ],
+    "mcp-integration": [
+      "lib/mcp-server.js",
+      "lib/mcp-transport.js",
+      "mcp-config-example.json"
+    ],
+    "react-components": [
+      "web/src/App.tsx",
+      "web/src/main.tsx",
+      "web/src/components/BundleList.tsx",
+      "web/src/components/BundleListNew.tsx",
+      "web/src/components/SystemSettings.tsx",
+      "web/src/components/ProjectFiles.tsx",
+      "web/src/components/FileAnalysis.tsx"
+    ],
+    "bundle-ui": [
+      "web/src/components/bundles/**/*.tsx",
+      "web/src/components/bundles/**/*.ts"
+    ],
+    "ui-system": [
+      "web/src/components/ui/**/*.tsx",
+      "web/src/components/theme-provider.tsx",
+      "web/src/components/theme-toggle.tsx",
+      "web/src/lib/**/*.ts",
+      "web/src/hooks/**/*.ts",
+      "web/src/utils/**/*.tsx"
+    ],
+    "config": [
+      "package.json",
+      "web/package.json",
+      "web/vite.config.ts",
+      "web/tsconfig*.json",
+      "web/eslint.config.js",
+      "web/components.json",
+      "build.sh"
+    ],
+    "testing": [
+      "tests/**/*.js",
+      "tests/**/*.mjs",
+      "debug/**/*.mjs",
+      "web/test-query.mjs",
+      "web/simple-test.mjs"
+    ],
+    "docs": [
+      "README.md",
+      "web/README.md",
+      "VISION.md",
+      "examples/**/*.sh"
+    ],
+    "master": [
+      "**/*"
+    ]
+  },
+  "editor": "cursor"
+}

package/templates/hidden-files.json

@@ -0,0 +1,14 @@
+{
+  "globalHidden": [],
+  "bundleSpecific": {
+    "debugging": [],
+    "server": [],
+    "frontend": [],
+    "config": [],
+    "activities": [],
+    "tests": [],
+    "docs": []
+  },
+  "userIgnorePatterns": [],
+  "disabledSystemPatterns": []
+}

package/web/dist/assets/heuristics-manager-browser-DfonOP5I.js

@@ -0,0 +1 @@
+class u{constructor(e="http://localhost:3333/api/heuristics/config"){this.configUrl=e,this.config=null,this.cache=new Map,this.lastLoaded=null,this.loadPromise=null}async loadConfig(){return this.loadPromise?this.loadPromise:(this.loadPromise=this._loadConfigInternal(),this.loadPromise)}async _loadConfigInternal(){try{const e=await fetch(this.configUrl);if(!e.ok){if(e.status===404){console.warn("Heuristics config not found at API, using fallback"),this.config=this.getFallbackConfig();return}throw new Error(`HTTP ${e.status}: ${e.statusText}`)}const t=await e.json();this.validateConfig(t),this.config=t,this.lastLoaded=Date.now(),this.cache.clear(),console.log("✅ Heuristics configuration loaded successfully")}catch(e){console.error("❌ Failed to load heuristics config:",e.message),console.log("📦 Falling back to hardcoded heuristics"),this.config=this.getFallbackConfig()}finally{this.loadPromise=null}}validateConfig(e){const t=["purposeHeuristics","bundleHeuristics","semanticTypeMapping"];for(const a of t)if(!e[a])throw new Error(`Missing required field: ${a}`);if(!e.purposeHeuristics.patterns||!e.purposeHeuristics.fallback)throw new Error("Invalid purposeHeuristics structure");if(!e.bundleHeuristics.patterns||!e.bundleHeuristics.fallback)throw new Error("Invalid bundleHeuristics structure")}async getConfig(){return this.config||await this.loadConfig(),this.config}async determinePurpose(e){const t=await this.getConfig(),a=e.name.toLowerCase();for(const[s,n]of Object.entries(t.purposeHeuristics.patterns))if(this.evaluateConditions(n.conditions,{func:e,name:a}))return n.purpose;return t.purposeHeuristics.fallback.purpose}async suggestBundlesForFile(e){const t=await this.getConfig(),a=e.toLowerCase(),s=a.split("/"),n=[];for(const[r,c]of Object.entries(t.bundleHeuristics.patterns))if(this.evaluateConditions(c.conditions,{fileName:a,filePath:e,pathParts:s})&&(n.push(c.bundle),c.subPatterns))for(const[i,o]of Object.entries(c.subPatterns))this.evaluateConditions(o.conditions,{fileName:a,filePath:e,pathParts:s})&&n.push(o.bundle);if(n.length===0){const r=t.bundleHeuristics.fallback;r.webFallback&&this.evaluateConditions(r.webFallback.conditions,{fileName:a,filePath:e,pathParts:s})?n.push(r.webFallback.bundle):r.defaultFallback&&n.push(...r.defaultFallback.bundles)}return[...new Set(n)]}async getSemanticTypeMapping(){const e=await this.getConfig(),t={};for(const[a,s]of Object.entries(e.semanticTypeMapping.clusters))for(const n of s.types)t[n]=s.clusterId;return t}evaluateConditions(e,t){return Array.isArray(e)||(e=[e]),this.requiresAndLogic(e)?e.every(s=>{try{return this.evaluateCondition(s,t)}catch(n){return console.warn(`Failed to evaluate condition: ${s}`,n),!1}}):e.some(s=>{try{return this.evaluateCondition(s,t)}catch(n){return console.warn(`Failed to evaluate condition: ${s}`,n),!1}})}requiresAndLogic(e){return!!(e.length===2&&e.some(t=>t.includes("name.startsWith"))&&e.some(t=>t.includes("func.type"))||e.length===2&&e.some(t=>t.includes("pathParts.includes('web')"))&&e.some(t=>t.includes("pathParts.includes('src')")))}evaluateCondition(e,t){const{func:a,name:s,fileName:n,filePath:r,pathParts:c}=t;if(e.includes("func.type ===")){const i=e.match(/func\.type === ['"]([^'"]+)['"]/);if(i&&a)return a.type===i[1]}if(e.includes("name.startsWith(")){const i=e.match(/name\.startsWith\(['"]([^'"]+)['"]\)/);if(i&&s)return s.startsWith(i[1])}if(e.includes("name.includes(")){const i=e.match(/name\.includes\(['"]([^'"]+)['"]\)/);if(i&&s)return s.includes(i[1])}if(e.includes("fileName.includes(")){const i=e.match(/fileName\.includes\(['"]([^'"]+)['"]\)/);if(i&&n)return n.includes(i[1])}if(e.includes("fileName.endsWith(")){const i=e.match(/fileName\.endsWith\(['"]([^'"]+)['"]\)/);if(i&&n)return n.endsWith(i[1])}if(e.includes("pathParts.includes(")){const i=e.match(/pathParts\.includes\(['"]([^'"]+)['"]\)/);if(i&&c)return c.includes(i[1])}return!1}getFallbackConfig(){return{version:"1.0.0",purposeHeuristics:{patterns:{reactComponent:{conditions:["func.type === 'react_component'"],purpose:"React component",confidence:.95},reactHook:{conditions:["name.startsWith('use')","func.type === 'function'"],purpose:"React hook",confidence:.9},apiHandler:{conditions:["name.includes('api')","name.includes('endpoint')"],purpose:"API handler",confidence:.85},dataRetrieval:{conditions:["name.includes('get')","name.includes('fetch')"],purpose:"Data retrieval",confidence:.8},dataCreation:{conditions:["name.includes('create')","name.includes('add')"],purpose:"Data creation",confidence:.8},dataModification:{conditions:["name.includes('update')","name.includes('edit')"],purpose:"Data modification",confidence:.8},dataDeletion:{conditions:["name.includes('delete')","name.includes('remove')"],purpose:"Data deletion",confidence:.8},validation:{conditions:["name.includes('validate')","name.includes('check')"],purpose:"Validation",confidence:.75},dataProcessing:{conditions:["name.includes('parse')","name.includes('format')"],purpose:"Data processing",confidence:.75}},fallback:{purpose:"Utility function",confidence:.5}},bundleHeuristics:{patterns:{frontend:{conditions:["pathParts.includes('web')","pathParts.includes('src')"],bundle:"frontend",confidence:.8,subPatterns:{uiComponents:{conditions:["pathParts.includes('components')"],bundle:"ui-components",confidence:.9}}},server:{conditions:["fileName.includes('server')","fileName.includes('api')","pathParts.includes('bin')"],bundle:"server",confidence:.85},configuration:{conditions:["fileName.includes('config')","fileName.includes('setup')","fileName.endsWith('.json')","fileName.endsWith('.sh')","fileName.includes('package')"],bundle:"config",confidence:.9},documentation:{conditions:["fileName.endsWith('.md')","fileName.includes('doc')","fileName.includes('readme')"],bundle:"docs",confidence:.95}},fallback:{webFallback:{conditions:["pathParts.includes('web')"],bundle:"frontend",confidence:.6},defaultFallback:{bundles:["server","config"],confidence:.4}}},semanticTypeMapping:{clusters:{businessLogic:{types:["business_logic","algorithm"],clusterId:0},dataLayer:{types:["data_processing","database"],clusterId:1},apiLayer:{types:["api_integration","middleware","routing"],clusterId:2},uiLayer:{types:["ui_component","page_component","layout_component","hook"],clusterId:3},utilities:{types:["utility","configuration","function","type_definition"],clusterId:4},testing:{types:["testing","documentation","monitoring"],clusterId:5},infrastructure:{types:["error_handling","performance","security"],clusterId:6},unknown:{types:["unknown"],clusterId:7}}}}}async updateConfig(e){this.validateConfig(e);try{const t=await fetch(this.configUrl,{method:"PUT",headers:{"Content-Type":"application/json"},body:JSON.stringify(e)});if(!t.ok)throw new Error(`HTTP ${t.status}: ${t.statusText}`);return this.config=e,this.cache.clear(),this.lastLoaded=Date.now(),!0}catch(t){throw console.error("Failed to update heuristics config:",t.message),t}}getPerformanceMetrics(){return{totalEvaluations:0,accuracyScore:0,lastUpdated:this.lastLoaded}}}export{u as default};