agentic-qe 3.11.1 → 3.11.2

package/dist/domains/code-intelligence/services/product-factors-bridge.js

@@ -18,8 +18,10 @@ import * as fs from 'fs/promises';
 import { ok, err } from '../../../shared/types';
 import { CodeIntelligenceEvents, createEvent, } from '../../../shared/events/domain-events';
 import { toError } from '../../../shared/error-utils.js';
-import { isCacheValid, sanitizeId, inferComponentType, } from '../../../shared/c4-model';
+import { isCacheValid, sanitizeId, inferComponentType, assessC4Confidence, } from '../../../shared/c4-model';
 import { safeJsonParse } from '../../../shared/safe-json.js';
+import { C4ModelService } from './c4-model';
+import { toContextRequest, toContainerRequest, toComponentRequest, } from './c4-model/from-detected';
 const DEFAULT_CONFIG = {
     cacheTtlMs: 3600000, // 1 hour
     publishEvents: true,
@@ -96,11 +98,26 @@ export class ProductFactorsBridgeService {
     config;
     initialized = false;
     eventSubscriptions = [];
+    /** ADR-112: the consolidated render+analyze+store engine (lazily built). */
+    c4Service;
     constructor(eventBus, memory, config = {}) {
         this.eventBus = eventBus;
         this.memory = memory;
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
+    /**
+     * ADR-112: lazily construct the shared C4ModelService.
+     * Embeddings are OFF on this internal product-factors path (keeps it offline +
+     * fast); the CLI/MCP surfaces opt embeddings in when semantic search is wanted.
+     */
+    getC4Service() {
+        if (!this.c4Service) {
+            this.c4Service = new C4ModelService(this.memory, {
+                enableEmbeddings: this.config.enableC4Embeddings ?? false,
+            });
+        }
+        return this.c4Service;
+    }
     // ==========================================================================
     // Lifecycle
     // ==========================================================================
@@ -130,7 +147,7 @@ export class ProductFactorsBridgeService {
         const sub2 = this.eventBus.subscribe(CodeIntelligenceEvents.ImpactAnalysisCompleted, this.handleImpactAnalysisCompleted.bind(this));
         this.eventSubscriptions.push(sub2);
     }
-    async handleKnowledgeGraphUpdated(event) {
+    async handleKnowledgeGraphUpdated(_event) {
         // Invalidate relevant caches when knowledge graph is updated
         logger.info('[ProductFactorsBridge] Knowledge graph updated, considering cache invalidation');
         // Note: We don't have project path in this event, so we rely on hash-based invalidation
@@ -198,30 +215,40 @@ export class ProductFactorsBridgeService {
             if (request.analyzeCoupling && components.length > 1) {
                 couplingAnalysis = this.analyzeCoupling(components, relationships);
             }
-            // Generate diagrams
+            // Generate diagrams. ADR-112: the three C4 levels render through the
+            // consolidated C4ModelService (richer + stored + searchable); the bridge
+            // keeps only detection. Inline generators remain as a safety fallback.
             const diagrams = {};
             if (request.includeContext !== false) {
-                diagrams.context = this.generateContextDiagram(projectInfo, externalSystems);
+                diagrams.context = await this.renderContext(projectInfo, externalSystems);
             }
             if (request.includeContainer !== false) {
-                diagrams.container = this.generateContainerDiagram(projectInfo, externalSystems);
+                diagrams.container = await this.renderContainer(projectInfo, externalSystems);
             }
             if (request.includeComponent !== false && components.length > 0) {
-                diagrams.component = this.generateComponentDiagram(projectInfo.name, components, relationships);
+                diagrams.component = await this.renderComponent(projectInfo, components, relationships);
             }
             if (request.includeDependency && components.length > 0) {
                 diagrams.dependency = this.generateDependencyGraph(components, relationships);
             }
+            const filesAnalyzed = components.reduce((sum, c) => sum + c.files.length, 0);
             const metadata = {
                 projectName: projectInfo.name,
                 projectDescription: projectInfo.description,
                 generatedAt: new Date(),
                 source: 'codebase-analysis',
                 analysisMetadata: {
-                    filesAnalyzed: components.reduce((sum, c) => sum + c.files.length, 0),
+                    filesAnalyzed,
                     componentsDetected: components.length,
                     externalSystemsDetected: externalSystems.length,
                     analysisTimeMs: Date.now() - startTime,
+                    // ADR-112: deterministic confidence gate — never present a wrong diagram as truth.
+                    confidence: assessC4Confidence({
+                        componentsDetected: components.length,
+                        relationshipsDetected: relationships.length,
+                        externalSystemsDetected: externalSystems.length,
+                        filesAnalyzed,
+                    }),
                 },
             };
             return ok({
@@ -239,70 +266,37 @@ export class ProductFactorsBridgeService {
         }
     }
     // ==========================================================================
-    // IC4DiagramGenerator Implementation
+    // ADR-112: render via the consolidated C4ModelService (the single engine).
+    // On failure we FAIL LOUD — propagate the error so the caller surfaces it —
+    // rather than silently degrading to a weaker inline diagram. A masked render
+    // failure is worse than a surfaced one (ADR-050: no silent degradation).
     // ==========================================================================
-    generateContextDiagram(project, externalSystems) {
-        let mermaid = `C4Context
-  title System Context diagram for ${project.name}
-
-  Person(user, "User", "A user of the system")
-  System(system, "${project.name}", "${project.description}")
-`;
-        for (const sys of externalSystems) {
-            mermaid += `  System_Ext(${sys.id}, "${sys.name}", "${sys.type}")
-`;
-        }
-        mermaid += `
-  Rel(user, system, "Uses")
-`;
-        for (const sys of externalSystems) {
-            mermaid += `  Rel(system, ${sys.id}, "${sys.relationship}")
-`;
+    async renderContext(projectInfo, externalSystems) {
+        const res = await this.getC4Service().buildContext(toContextRequest(projectInfo, externalSystems));
+        if (!res.success) {
+            logger.error('[ProductFactorsBridge] C4 context render failed', res.error);
+            throw res.error;
         }
-        return mermaid;
+        return res.value.mermaid;
     }
-    generateContainerDiagram(project, externalSystems) {
-        let mermaid = `C4Container
-  title Container diagram for ${project.name}
-
-  Person(user, "User", "A user of the system")
-
-  Container_Boundary(c1, "${project.name}") {
-    Container(app, "Application", "TypeScript", "Main application")
-  }
-`;
-        for (const sys of externalSystems) {
-            mermaid += `  System_Ext(${sys.id}, "${sys.name}", "${sys.type}")
-`;
-        }
-        mermaid += `
-  Rel(user, app, "Uses")
-`;
-        for (const sys of externalSystems) {
-            mermaid += `  Rel(app, ${sys.id}, "${sys.relationship}")
-`;
+    async renderContainer(projectInfo, externalSystems) {
+        const res = await this.getC4Service().buildContainer(toContainerRequest(projectInfo, externalSystems));
+        if (!res.success) {
+            logger.error('[ProductFactorsBridge] C4 container render failed', res.error);
+            throw res.error;
         }
-        return mermaid;
+        return res.value.mermaid;
     }
-    generateComponentDiagram(projectName, components, relationships) {
-        let mermaid = `C4Component
-  title Component diagram for ${projectName}
-
-  Container_Boundary(app, "Application") {
-`;
-        for (const comp of components) {
-            const responsibility = comp.responsibilities?.[0] || '';
-            mermaid += `    Component(${comp.id}, "${comp.name}", "${comp.technology || 'TypeScript'}", "${responsibility}")
-`;
-        }
-        mermaid += `  }
-`;
-        for (const rel of relationships) {
-            mermaid += `  Rel(${rel.sourceId}, ${rel.targetId}, "${rel.type}")
-`;
+    async renderComponent(projectInfo, components, relationships) {
+        const res = await this.getC4Service().buildComponent(toComponentRequest(components, relationships));
+        if (!res.success) {
+            logger.error('[ProductFactorsBridge] C4 component render failed', res.error);
+            throw res.error;
         }
-        return mermaid;
+        return res.value.mermaid;
     }
+    // The dependency graph is NOT a C4 level and C4ModelService does not render
+    // it, so this stays as the bridge's own renderer.
     generateDependencyGraph(components, relationships) {
         let mermaid = `graph TD
 `;
@@ -439,6 +433,19 @@ export class ProductFactorsBridgeService {
         catch (error) {
             logger.error('Component analysis failed:', error instanceof Error ? error : undefined);
         }
+        // ADR-112 C2: prefer REAL KG-derived edges (AST import/call graph) over the
+        // naming heuristic. The resolver returns null on any miss → heuristic stands.
+        if (this.config.relationshipResolver && components.length > 0) {
+            try {
+                const resolved = await this.config.relationshipResolver(components, projectPath);
+                if (resolved && resolved.length > 0) {
+                    return { components, relationships: resolved };
+                }
+            }
+            catch (error) {
+                logger.debug(`KG relationship resolver failed; using heuristic: ${toError(error).message}`);
+            }
+        }
         return { components, relationships };
     }
     shouldExclude(name) {
@@ -473,7 +480,7 @@ export class ProductFactorsBridgeService {
                     }
                 }
             }
-            catch (error) {
+            catch {
                 // Non-critical: permission errors when scanning directories
                 logger.debug('Directory scan error:');
             }