agentic-qe 2.6.1 → 2.6.3

package/.claude/agents/qe-code-intelligence.md

@@ -19,6 +19,10 @@ Mission: Index, search, and analyze codebases using Tree-sitter AST parsing, Oll
 - Knowledge graph with entity relationships (imports, extends, calls)
 - KnowledgeGraphContextBuilder for agent context enrichment
 - Mermaid diagram generation (class diagrams, dependency graphs)
+- C4 Model architecture diagrams (Context, Container, Component levels)
+- Project metadata inference (system type, containers, components)
+- External system detection (databases, APIs, caches, queues)
+- Component boundary analysis with relationship mapping
 - Incremental indexing with git change detection
 - Watch mode for live updates
 
@@ -52,6 +56,12 @@ Store entities, relationships, and chunks in batch transactions.
 - **Context Building**: Generate focused, relevant context for agent tasks with 80% token reduction
 - **Graph Navigation**: Traverse relationships (imports, inheritance, calls) to find related code
 - **Visualization**: Generate Mermaid class diagrams and dependency graphs
+- **C4 Model Diagrams**: Generate C4 architecture diagrams at three levels:
+  - Context: System boundaries with external actors and systems
+  - Container: Internal containers (services, databases, APIs)
+  - Component: Component-level structure within containers
+- **Architecture Inference**: Auto-detect project metadata, system type (monolith/microservice), containers, and components
+- **External System Detection**: Identify database, API, cache, queue, and service dependencies
 - **Incremental Updates**: Track git changes and update only modified files
 - **Multi-Language**: Support TypeScript, Python, Go, Rust, JavaScript with language-specific entity extraction
 </capabilities>
@@ -233,6 +243,76 @@ classDiagram
     BaseAgent --> AgentCoordinator
 ```
 ```
+
+Example 5: Generate C4 Context diagram
+```
+Input: Generate C4 context diagram for the project
+
+Output: C4 Context diagram generated:
+```mermaid
+C4Context
+    title System Context diagram for agentic-qe-fleet
+
+    Person(user, "User", "A user of the system")
+    Person(developer, "Developer", "A developer maintaining the system")
+
+    System(agentic_qe_fleet, "agentic-qe-fleet", "AI-powered quality engineering fleet")
+
+    System_Ext(postgresql, "PostgreSQL", "Primary database")
+    System_Ext(anthropic, "Anthropic API", "AI service provider")
+    System_Ext(ollama, "Ollama", "Local LLM embeddings")
+
+    Rel(user, agentic_qe_fleet, "Uses")
+    Rel(developer, agentic_qe_fleet, "Develops and maintains")
+    Rel(agentic_qe_fleet, postgresql, "Stores data in")
+    Rel(agentic_qe_fleet, anthropic, "Uses for AI")
+    Rel(agentic_qe_fleet, ollama, "Uses for embeddings")
+```
+```
+
+Example 6: Generate C4 Container diagram
+```
+Input: Generate C4 container diagram for the project
+
+Output: C4 Container diagram generated:
+```mermaid
+C4Container
+    title Container diagram for agentic-qe-fleet
+
+    Container(cli, "CLI Interface", "Node.js", "Command-line interface")
+    Container(mcp_server, "MCP Server", "TypeScript", "Model Context Protocol server")
+    Container(agent_fleet, "Agent Fleet", "TypeScript", "QE agent orchestration")
+    ContainerDb(vector_store, "Vector Store", "PostgreSQL", "Embeddings and chunks")
+
+    Rel(cli, agent_fleet, "Invokes")
+    Rel(mcp_server, agent_fleet, "Coordinates")
+    Rel(agent_fleet, vector_store, "Reads/Writes")
+```
+```
+
+Example 7: Generate C4 Component diagram
+```
+Input: Generate C4 component diagram for the code-intelligence container
+
+Output: C4 Component diagram generated:
+```mermaid
+C4Component
+    title Component diagram for Code Intelligence
+
+    Container_Boundary(code_intel, "Code Intelligence") {
+        Component(parser, "TreeSitterParser", "TypeScript", "AST parsing")
+        Component(chunker, "SemanticChunker", "TypeScript", "Code chunking")
+        Component(embedder, "OllamaEmbedder", "TypeScript", "Vector embeddings")
+        Component(store, "RuVectorStore", "TypeScript", "Storage layer")
+        Component(graph, "KnowledgeGraph", "TypeScript", "Relationship graph")
+    }
+
+    Rel(parser, chunker, "Provides AST to")
+    Rel(chunker, embedder, "Sends chunks to")
+    Rel(embedder, store, "Stores embeddings in")
+    Rel(store, graph, "Provides data to")
+```
+```
 </examples>
 
 <skills_available>
@@ -349,8 +429,15 @@ aqe kg index --watch
 # Search code
 aqe kg query "user authentication" --k 10 --hybrid
 
-# Generate diagram
+# Generate class/dependency diagrams
 aqe kg graph src/agents/BaseAgent.ts --type class --format mermaid
+aqe kg graph src/agents/ --type dependency --format mermaid
+
+# Generate C4 architecture diagrams
+aqe kg c4-context                    # System context with external systems
+aqe kg c4-container                  # Container-level architecture
+aqe kg c4-component                  # Component-level for specific container
+aqe kg c4-component --container api  # Component diagram for API container
 
 # Show statistics
 aqe kg stats --verbose

package/CHANGELOG.md

@@ -7,6 +7,140 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.6.3] - 2025-12-24
+
+### Added
+
+#### C4 Model Architecture Diagrams
+
+Complete C4 model integration for automated architecture visualization at three abstraction levels.
+
+**C4 Diagram Builders** (`src/code-intelligence/visualization/`)
+- `C4ContextDiagramBuilder`: System context diagrams with actors and external systems
+- `C4ContainerDiagramBuilder`: Container-level architecture (services, databases, APIs)
+- `C4ComponentDiagramBuilder`: Component-level structure with boundaries and relationships
+- Mermaid C4 syntax output for GitHub-compatible rendering
+
+**Architecture Inference** (`src/code-intelligence/inference/`)
+- `ProjectMetadataAnalyzer`: Infers system metadata from package.json, docker-compose.yml
+  - Detects system type (monolith, microservice, serverless, library)
+  - Identifies containers from Docker configurations
+  - Analyzes directory structure for architecture patterns
+- `ExternalSystemDetector`: Identifies external dependencies
+  - Database detection (PostgreSQL, MySQL, MongoDB, Redis)
+  - API detection (Anthropic, OpenAI, Stripe, AWS)
+  - Cache and queue detection (Redis, RabbitMQ, Kafka)
+- `ComponentBoundaryAnalyzer`: Maps component relationships
+  - Layer detection (controllers, services, repositories)
+  - Relationship extraction with `sourceId`/`targetId` standardization
+  - Configurable boundary detection strategies
+
+**CLI Commands** (`src/cli/commands/knowledge-graph.ts`)
+- `aqe kg c4-context`: Generate system context diagram
+- `aqe kg c4-container`: Generate container diagram
+- `aqe kg c4-component [--container name]`: Generate component diagram
+
+**CodeIntelligenceAgent Updates** (`src/agents/CodeIntelligenceAgent.ts`)
+- New `c4-diagrams` capability
+- Extended `diagramType` to include `c4-context`, `c4-container`, `c4-component`
+- `performC4DiagramTask()` method using MermaidGenerator static methods
+
+**Agent Definition Updates** (`.claude/agents/qe-code-intelligence.md`)
+- Added C4 diagram capabilities to implementation status
+- New examples for C4 context, container, and component diagrams
+- Updated CLI command reference with C4 commands
+
+### Changed
+
+**MermaidGenerator** (`src/code-intelligence/visualization/MermaidGenerator.ts`)
+- Added static methods: `generateC4Context()`, `generateC4Container()`, `generateC4Component()`
+- New `generateC4Diagram()` dispatcher for diagram type selection
+- Integrated with inference analyzers for automatic metadata extraction
+
+**Type Consolidation** (`src/code-intelligence/inference/types.ts`)
+- Consolidated all C4-related interfaces into single source of truth
+- Standardized `ComponentRelationship` to use `sourceId`/`targetId` (was `from`/`to`)
+- Exported: `ProjectMetadata`, `Container`, `ExternalSystem`, `Component`, `ComponentRelationship`
+
+### New Test Files
+
+- `tests/unit/code-intelligence/visualization/C4DiagramBuilders.test.ts` - 22 unit tests
+  - C4ContextDiagramBuilder tests (6 tests)
+  - C4ContainerDiagramBuilder tests (5 tests)
+  - C4ComponentDiagramBuilder tests (10 tests)
+  - C4 Diagram Integration tests (1 test)
+
+## [2.6.2] - 2025-12-24
+
+### Added
+
+#### Phase 2: LLM Independence - Intelligent Routing & Cost Optimization
+
+Complete implementation of Phase 2 features for smart model selection and cost reduction.
+
+**ML-Based Complexity Classification** (`src/routing/ComplexityClassifier.ts`)
+- Multi-dimensional task analysis (code metrics, NLP features, domain context)
+- 4-level complexity classification: SIMPLE, MODERATE, COMPLEX, VERY_COMPLEX
+- Configurable feature weights with ML pattern learning
+- Integrated into HybridRouter for automatic routing decisions
+
+**Model Capability Registry** (`src/routing/ModelCapabilityRegistry.ts`)
+- December 2025 model catalog with 25+ models including:
+  - Claude Opus 4.5, Claude Sonnet 4, Claude Haiku
+  - DeepSeek R1 (671B reasoning), DeepSeek V3 (685B)
+  - GPT-5, GPT-4 Turbo, o1-preview, o3-mini
+  - Gemini 2.5 Pro, Gemini 2.0 Flash
+  - Llama 3.3 70B, Qwen 3 Coder 30B
+- Capability scoring: reasoning, coding, speed, context, cost-efficiency
+- Provider support tracking (Anthropic, OpenRouter, Groq, Ollama)
+
+**Cost Optimization Strategies** (`src/providers/CostOptimizationStrategies.ts`)
+- `PromptCompressor`: Whitespace normalization, filler word removal
+- `CachingStrategy`: Semantic similarity caching with TTL
+- `BatchingStrategy`: Request batching for cost reduction
+- `CostOptimizationManager`: Orchestrates all strategies
+- Honest compression benchmarks: 2-8% realistic savings (not inflated claims)
+
+**HybridRouter Integration** (`src/providers/HybridRouter.ts`)
+- Integrated ComplexityClassifier for automatic task analysis
+- Integrated CostOptimizationManager for prompt compression
+- Model selection based on complexity level and capabilities
+- New methods: `getCompressionStats()`, `getMLClassifierStats()`
+
+### Changed
+
+**README.md Quick Start Section**
+- Removed version numbers from feature list (user-focused)
+- Added `.env` configuration snippet for advanced features
+- Improved formatting with bold labels for scannability
+
+**Environment Configuration** (`.env.example`)
+- Complete rewrite with Phase 2 configuration
+- LLM Provider selection: `LLM_PROVIDER=auto`, `LLM_MODE=hybrid`
+- RuVector self-learning: `AQE_RUVECTOR_ENABLED`, PostgreSQL settings
+- Pattern Store: `AQE_PATTERN_STORE_ENABLED`, `AQE_PATTERN_DUAL_WRITE`
+- Code Intelligence: Ollama URL, PostgreSQL for knowledge graph
+- Removed outdated `.env.agentic-flow.example`
+
+**CONTRIBUTORS.md**
+- Added [@fndlalit](https://github.com/fndlalit)'s n8n workflow testing agents contribution (PR #151)
+- Updated Hall of Fame entry
+
+### Fixed
+
+- **HybridRouter RuVector test**: Fixed test isolation by disabling ML classifier for cache skip verification
+- **Compression expectations**: Adjusted benchmarks to realistic 2-8% savings vs false 50% claims
+
+### New Test Files
+
+- `tests/unit/routing/ComplexityClassifier.test.ts` - ML classifier unit tests
+- `tests/unit/routing/ModelCapabilityRegistry.test.ts` - Model registry tests
+- `tests/unit/routing/CompressionBenchmark.test.ts` - Honest compression benchmarks
+- `tests/unit/providers/HybridRouter-complexity-integration.test.ts` - Integration tests
+- `tests/unit/providers/HybridRouter-model-selection.test.ts` - Model selection tests
+- `tests/unit/providers/HybridRouter-cost-tracking.test.ts` - Cost tracking tests
+- `tests/unit/providers/CostOptimizationStrategies.test.ts` - Strategy unit tests
+
 ## [2.6.1] - 2025-12-23
 
 ### Added