agentic-qe 3.11.0 → 3.11.2

package/dist/cli/chunks/{wrappers-M5C7DONW.js → wrappers-S6EUZBCX.js}

@@ -1,2 +1,2 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.11.0");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v as L,w as M,x as N}from"./chunk-MTSMFEWK.js";import{a as v,b as w,c as x,d as y,e as z,f as A,g as B,h as C,i as D,j as E,k as F,l as G,m as H,n as I,o as J,p as K}from"./chunk-QZQGYSDG.js";import"./chunk-QYXTESM3.js";import"./chunk-L7GQKJLV.js";import"./chunk-C4OYHUJV.js";import"./chunk-F62ZQZQQ.js";import"./chunk-T6KT63NC.js";import"./chunk-Y7TBCHW4.js";import"./chunk-RVQW6CBF.js";import"./chunk-BA4WZIAQ.js";import"./chunk-ZT4NPTML.js";import"./chunk-FGOVDO3R.js";import"./chunk-RKDNLPZM.js";import"./chunk-G5VE3HQW.js";import"./chunk-LCDRRAES.js";import"./chunk-XVQUVCFR.js";import"./chunk-J425SQFE.js";import"./chunk-73EWPVBJ.js";import"./chunk-YQIMO7VJ.js";import"./chunk-ACV2WVMX.js";export{z as GNNLayerFactory,i as QEFlashAttention,x as QEGNNEmbeddingIndex,y as QEGNNIndexFactory,a as QESONA,e as QE_FLASH_ATTENTION_CONFIG,g as QE_PERFORMANCE_TARGETS,f as QE_SONA_CONFIG,A as TensorCompressionFactory,u as batchComputeAttention,K as batchDifferentiableSearch,M as checkRuvectorPackagesAvailable,c as createDomainQESONA,j as createQEFlashAttention,b as createQESONA,D as getDifferentiableSearch,F as getGetCompressionLevel,E as getHierarchicalForward,G as getInit,h as getOptimalBlockConfig,k as getQEFlashAttentionConfig,n as getRuvectorDotProductAttention,m as getRuvectorFlashAttention,p as getRuvectorHyperbolicAttention,B as getRuvectorLayer,q as getRuvectorLinearAttention,r as getRuvectorMoEAttention,o as getRuvectorMultiHeadAttention,L as getRuvectorPackageVersions,C as getTensorCompress,l as getWorkloadTypes,N as initAllRuvectorPackages,w as initGNN,d as isAttentionAvailable,v as isGNNAvailable,s as toFloat32Array,H as toFloat32ArrayGNN,J as toIEmbedding,t as toNumberArrayAttn,I as toNumberArrayGNN};
+import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.11.2");process.exit(0)}
+import{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v as L,w as M,x as N}from"./chunk-KFE6LB4I.js";import{a as v,b as w,c as x,d as y,e as z,f as A,g as B,h as C,i as D,j as E,k as F,l as G,m as H,n as I,o as J,p as K}from"./chunk-OFUF3APC.js";import"./chunk-4PYJCIRO.js";import"./chunk-Y4M2HMPR.js";import"./chunk-72VVTMEL.js";import"./chunk-5BDVFFYF.js";import"./chunk-JCH2FHJ7.js";import"./chunk-LY6PTRVL.js";import"./chunk-IXYF5BZY.js";import"./chunk-FYY7OJ6Y.js";import"./chunk-AZQ6HDPM.js";import"./chunk-Z2QNTRUX.js";import"./chunk-6SOGYNJG.js";import"./chunk-7MKF52GT.js";import"./chunk-XY2B2BEJ.js";import"./chunk-AINAWVGD.js";import"./chunk-NIW4CLN2.js";import"./chunk-UCXW24HY.js";import"./chunk-WKIYYF3G.js";import"./chunk-LIEA5EON.js";export{z as GNNLayerFactory,i as QEFlashAttention,x as QEGNNEmbeddingIndex,y as QEGNNIndexFactory,a as QESONA,e as QE_FLASH_ATTENTION_CONFIG,g as QE_PERFORMANCE_TARGETS,f as QE_SONA_CONFIG,A as TensorCompressionFactory,u as batchComputeAttention,K as batchDifferentiableSearch,M as checkRuvectorPackagesAvailable,c as createDomainQESONA,j as createQEFlashAttention,b as createQESONA,D as getDifferentiableSearch,F as getGetCompressionLevel,E as getHierarchicalForward,G as getInit,h as getOptimalBlockConfig,k as getQEFlashAttentionConfig,n as getRuvectorDotProductAttention,m as getRuvectorFlashAttention,p as getRuvectorHyperbolicAttention,B as getRuvectorLayer,q as getRuvectorLinearAttention,r as getRuvectorMoEAttention,o as getRuvectorMultiHeadAttention,L as getRuvectorPackageVersions,C as getTensorCompress,l as getWorkloadTypes,N as initAllRuvectorPackages,w as initGNN,d as isAttentionAvailable,v as isGNNAvailable,s as toFloat32Array,H as toFloat32ArrayGNN,J as toIEmbedding,t as toNumberArrayAttn,I as toNumberArrayGNN};

package/dist/cli/commands/code.js

@@ -10,12 +10,13 @@ import { writeOutput, toJSON } from '../utils/ci-output.js';
 export function createCodeCommand(context, cleanupAndExit, ensureInitialized) {
     const codeCmd = new Command('code')
         .description('Code intelligence analysis')
-        .argument('<action>', 'Action (index|search|impact|deps|complexity)')
+        .argument('<action>', 'Action (index|search|impact|deps|complexity|c4)')
         .argument('[target]', 'Target path or query')
         .option('--depth <depth>', 'Analysis depth', '3')
         .option('--include-tests', 'Include test files')
         .option('--incremental', 'Incremental indexing (index action only)')
         .option('--git-since <ref>', 'Index changes since git ref (index action only)')
+        .option('--level <level>', 'C4 level for c4 action (context|container|component|all)', 'all')
         .option('-F, --format <format>', 'Output format (text|json)', 'text')
         .option('-o, --output <path>', 'Write output to file')
         .addHelpText('after', `
@@ -27,6 +28,9 @@ Examples:
   aqe code impact src/auth/            Analyze change impact
   aqe code deps src/                   Map dependencies
   aqe code complexity src/             Analyze code complexity metrics
+  aqe code c4 .                        Generate C4 architecture diagrams (Mermaid)
+  aqe code c4 src/ --level component   Only the C4 component diagram
+  aqe code c4 . --format json -o c4.json   Full C4 result as JSON
 `)
         .action(async (action, target, options) => {
         if (!await ensureInitialized())
@@ -328,9 +332,81 @@ Examples:
                     }
                 }
             }
+            else if (action === 'c4') {
+                const targetPath = path.resolve(target || '.');
+                const level = String(options.level || 'all').toLowerCase();
+                const validLevels = ['context', 'container', 'component', 'all'];
+                if (!validLevels.includes(level)) {
+                    console.log(chalk.red(`Invalid --level: "${level}" (must be ${validLevels.join('|')})`));
+                    return await cleanupAndExit(1);
+                }
+                if (typeof codeAPI.getCoordinator !== 'function' || !codeAPI.getCoordinator()) {
+                    console.log(chalk.red('C4 generation not available — ensure the fleet is initialized'));
+                    return await cleanupAndExit(1);
+                }
+                console.log(chalk.blue(`\n Generating C4 diagrams for ${targetPath} (level: ${level})...\n`));
+                const want = (l) => level === 'all' || level === l;
+                const result = await codeAPI.getCoordinator().generateC4Diagrams(targetPath, {
+                    includeContext: want('context'),
+                    includeContainer: want('container'),
+                    includeComponent: want('component'),
+                    includeDependency: level === 'all',
+                    analyzeComponents: true,
+                    detectExternalSystems: true,
+                    analyzeCoupling: true,
+                });
+                if (!result.success || !result.value) {
+                    console.log(chalk.red(`Failed: ${result.error?.message || 'Unknown error'}`));
+                    return await cleanupAndExit(1);
+                }
+                const c4 = result.value;
+                const confidence = c4.metadata.analysisMetadata?.confidence;
+                if (format === 'json') {
+                    writeOutput(toJSON(c4), options.output);
+                }
+                else {
+                    // Build the Markdown (fenced mermaid blocks) — copy-paste into GitHub/IDE.
+                    const blocks = [];
+                    const add = (titleLevel, code) => {
+                        if (code)
+                            blocks.push(`### C4 ${titleLevel}\n\n\`\`\`mermaid\n${code.trim()}\n\`\`\``);
+                    };
+                    add('Context', c4.diagrams.context);
+                    add('Container', c4.diagrams.container);
+                    add('Component', c4.diagrams.component);
+                    if (c4.diagrams.dependency)
+                        blocks.push(`### Dependency Graph\n\n\`\`\`mermaid\n${c4.diagrams.dependency.trim()}\n\`\`\``);
+                    const markdown = `# C4 Architecture — ${c4.metadata.projectName}\n\n${blocks.join('\n\n')}\n`;
+                    if (options.output) {
+                        writeOutput(markdown, options.output);
+                    }
+                    else {
+                        console.log(markdown);
+                    }
+                    // Confidence banner (ADR-112 quality gate) — always to stderr-style console.
+                    if (confidence) {
+                        const color = confidence.level === 'high' ? chalk.green : confidence.level === 'medium' ? chalk.yellow : chalk.red;
+                        console.log(color(`Confidence: ${confidence.level.toUpperCase()} (${(confidence.score * 100).toFixed(0)}%)`));
+                        if (confidence.level !== 'high') {
+                            for (const reason of confidence.reasons) {
+                                console.log(chalk.gray(`  - ${reason}`));
+                            }
+                        }
+                    }
+                    // Architecture analysis (coupling/cycles).
+                    const coupling = c4.couplingAnalysis ?? [];
+                    const circular = coupling.filter((c) => c.isCircular);
+                    console.log(chalk.cyan(`\n  Components: ${chalk.white(c4.components.length)}  External systems: ${chalk.white(c4.externalSystems.length)}  Relationships: ${chalk.white(c4.relationships.length)}`));
+                    if (circular.length > 0) {
+                        console.log(chalk.red(`  Circular dependencies: ${circular.length}`));
+                        for (const c of circular.slice(0, 3))
+                            console.log(chalk.red(`    ${c.moduleA} <-> ${c.moduleB}`));
+                    }
+                }
+            }
             else {
                 console.log(chalk.red(`\nUnknown action: ${action}`));
-                console.log(chalk.gray('  Available: index, search, impact, deps, complexity\n'));
+                console.log(chalk.gray('  Available: index, search, impact, deps, complexity, c4\n'));
                 await cleanupAndExit(1);
             }
             console.log('');

package/dist/cli/completions/index.js

@@ -349,7 +349,7 @@ _aqe_completions() {
     local protocol_subcmds="run"
     local completions_subcmds="bash zsh fish powershell install"
     local brain_subcmds="export import info diff search witness-backfill"
-    local code_actions="index search impact deps"
+    local code_actions="index search impact deps complexity c4"
     local test_actions="generate execute"
 
     # Domains
@@ -1287,6 +1287,9 @@ complete -c aqe -n "__fish_seen_subcommand_from code; and not __fish_seen_subcom
 complete -c aqe -n "__fish_seen_subcommand_from code; and not __fish_seen_subcommand_from index search impact deps" -a "search" -d "Search code"
 complete -c aqe -n "__fish_seen_subcommand_from code; and not __fish_seen_subcommand_from index search impact deps" -a "impact" -d "Analyze impact"
 complete -c aqe -n "__fish_seen_subcommand_from code; and not __fish_seen_subcommand_from index search impact deps" -a "deps" -d "Map dependencies"
+complete -c aqe -n "__fish_seen_subcommand_from code; and not __fish_seen_subcommand_from index search impact deps complexity c4" -a "complexity" -d "Code complexity metrics"
+complete -c aqe -n "__fish_seen_subcommand_from code; and not __fish_seen_subcommand_from index search impact deps complexity c4" -a "c4" -d "Generate C4 architecture diagrams"
+complete -c aqe -n "__fish_seen_subcommand_from code; and __fish_seen_subcommand_from c4" -l level -d "C4 level" -xa "context container component all"
 complete -c aqe -n "__fish_seen_subcommand_from code" -l depth -d "Analysis depth" -xa "1 2 3 4 5"
 complete -c aqe -n "__fish_seen_subcommand_from code" -l include-tests -d "Include test files"
 # Directory completion for code actions

package/dist/domains/code-intelligence/coordinator.js

@@ -6,12 +6,14 @@
  * - QEGNNEmbeddingIndex: Code graph embeddings with HNSW for fast similarity search
  * - QESONA: Learns and adapts code patterns for improved intelligence
  */
+import { existsSync } from 'node:fs';
 import { LoggerFactory } from '../../logging/index.js';
 import { v4 as uuidv4 } from 'uuid';
 import { err } from '../../shared/types';
 import { toError } from '../../shared/error-utils.js';
 import { CodeIntelligenceEvents, createEvent, } from '../../shared/events/domain-events';
 import { ProductFactorsBridgeService, } from './services/product-factors-bridge';
+import { createKnowledgeGraphRelationshipResolver } from './services/c4-model/kg-relationships';
 import { KnowledgeGraphService, } from './services/knowledge-graph';
 import { SemanticAnalyzerService, } from './services/semantic-analyzer';
 import { ImpactAnalyzerService, } from './services/impact-analyzer';
@@ -85,9 +87,12 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
         this.semanticAnalyzer = new SemanticAnalyzerService(memory);
         this.impactAnalyzer = new ImpactAnalyzerService(memory, this.knowledgeGraph);
         this.fileReader = new FileReader();
-        // Initialize Product Factors Bridge
+        // Initialize Product Factors Bridge.
+        // ADR-112 C2: inject a KG-backed relationship resolver so C4 component
+        // diagrams use REAL import/call edges (not the naming heuristic).
         this.productFactorsBridge = new ProductFactorsBridgeService(eventBus, memory, {
             publishEvents: this.config.publishEvents,
+            relationshipResolver: createKnowledgeGraphRelationshipResolver((projectPath) => new KnowledgeGraphService({ memory, llmRouter }, { basePath: projectPath })),
         });
     }
     // ==========================================================================
@@ -949,9 +954,8 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
             for (const marker of markers) {
                 try {
                     const markerPath = `${currentPath}/${marker}`;
-                    // Use synchronous check (since we're in async context anyway)
-                    const fs = require('fs');
-                    if (fs.existsSync(markerPath)) {
+                    // Synchronous existence check (we're in an async context anyway).
+                    if (existsSync(markerPath)) {
                         return currentPath;
                     }
                 }

package/dist/domains/code-intelligence/services/c4-model/from-detected.d.ts

@@ -0,0 +1,41 @@
+/**
+ * ADR-112 — Detected → C4 spec mapping.
+ *
+ * Pure, dependency-free functions that convert the code-intelligence DETECTOR
+ * output (shared `Detected*` types, produced by ProductFactorsBridgeService's
+ * filesystem scan) into the `C4ModelService` Build*Request specs.
+ *
+ * This is the consolidation seam: the bridge keeps detection; the rich
+ * `C4ModelService` does all rendering/analysis/storage. Keeping the mapping pure
+ * makes the C1 parity test (every detected element survives into a spec) trivial
+ * and keeps zero coupling to the service's async/embedding/memory machinery.
+ */
+import type { C4ProjectInfo, DetectedExternalSystem, DetectedComponent, DetectedRelationship, ExternalSystemType, C4ComponentType, C4RelationshipType as SharedC4RelationshipType } from '../../../../shared/c4-model';
+import type { BuildContextRequest, BuildContainerRequest, BuildComponentRequest, ExternalSystemSpec, ComponentSpec, ComponentRelationshipSpec, SystemType, ComponentType, C4RelationshipType as DomainC4RelationshipType } from './types';
+/** The single application container the detector models today (mirrors the
+ * legacy bridge, which hardcoded one "Application" container). Real multi-
+ * container detection is future work (ADR-112 G-ABORT note). */
+export declare const DEFAULT_CONTAINER_NAME = "Application";
+export declare function mapExternalSystemType(type: ExternalSystemType): SystemType;
+export declare function mapComponentType(type: C4ComponentType): ComponentType;
+export declare function mapRelationshipType(type: SharedC4RelationshipType): DomainC4RelationshipType;
+/** Detected external systems → C4 ExternalSystemSpec[]. */
+export declare function toExternalSystemSpecs(externalSystems: DetectedExternalSystem[]): ExternalSystemSpec[];
+/** Detected components → C4 ComponentSpec[]. */
+export declare function toComponentSpecs(components: DetectedComponent[]): ComponentSpec[];
+/**
+ * Detected relationships → C4 ComponentRelationshipSpec[].
+ *
+ * `DetectedRelationship` references components by `id`; the service re-derives
+ * ids by sanitizing the spec's `from`/`to` NAMES. So we translate ids back to
+ * names via the component set; relationships whose endpoints aren't in the set
+ * are dropped (they can't render) — surfaced by the caller's count delta.
+ */
+export declare function toComponentRelationshipSpecs(components: DetectedComponent[], relationships: DetectedRelationship[]): ComponentRelationshipSpec[];
+/** Project + detected external systems → BuildContextRequest. */
+export declare function toContextRequest(project: C4ProjectInfo, externalSystems: DetectedExternalSystem[]): BuildContextRequest;
+/** Project + detected external systems → BuildContainerRequest (single app container). */
+export declare function toContainerRequest(project: C4ProjectInfo, externalSystems: DetectedExternalSystem[]): BuildContainerRequest;
+/** Detected components + relationships → BuildComponentRequest. */
+export declare function toComponentRequest(components: DetectedComponent[], relationships: DetectedRelationship[], containerName?: string): BuildComponentRequest;
+//# sourceMappingURL=from-detected.d.ts.map

package/dist/domains/code-intelligence/services/c4-model/from-detected.js

@@ -0,0 +1,152 @@
+/**
+ * ADR-112 — Detected → C4 spec mapping.
+ *
+ * Pure, dependency-free functions that convert the code-intelligence DETECTOR
+ * output (shared `Detected*` types, produced by ProductFactorsBridgeService's
+ * filesystem scan) into the `C4ModelService` Build*Request specs.
+ *
+ * This is the consolidation seam: the bridge keeps detection; the rich
+ * `C4ModelService` does all rendering/analysis/storage. Keeping the mapping pure
+ * makes the C1 parity test (every detected element survives into a spec) trivial
+ * and keeps zero coupling to the service's async/embedding/memory machinery.
+ */
+/** The single application container the detector models today (mirrors the
+ * legacy bridge, which hardcoded one "Application" container). Real multi-
+ * container detection is future work (ADR-112 G-ABORT note). */
+export const DEFAULT_CONTAINER_NAME = 'Application';
+/** shared ExternalSystemType → domain SystemType (C4ModelService vocabulary). */
+const EXTERNAL_SYSTEM_TYPE_MAP = {
+    database: 'database',
+    cache: 'cache',
+    queue: 'message_queue',
+    api: 'api',
+    storage: 'storage',
+    auth: 'authentication',
+    monitoring: 'monitoring',
+    cloud: 'third_party',
+};
+/** shared C4ComponentType → domain ComponentType (C4ModelService vocabulary).
+ * Types the service lacks (transformer/layer/feature/package/other) fold to the
+ * nearest supported concept so no component is dropped. */
+const COMPONENT_TYPE_MAP = {
+    controller: 'controller',
+    service: 'service',
+    repository: 'repository',
+    facade: 'facade',
+    factory: 'factory',
+    adapter: 'adapter',
+    gateway: 'gateway',
+    handler: 'handler',
+    validator: 'validator',
+    transformer: 'adapter',
+    utility: 'utility',
+    module: 'module',
+    layer: 'module',
+    feature: 'module',
+    package: 'module',
+    other: 'module',
+};
+export function mapExternalSystemType(type) {
+    return EXTERNAL_SYSTEM_TYPE_MAP[type] ?? 'third_party';
+}
+export function mapComponentType(type) {
+    return COMPONENT_TYPE_MAP[type] ?? 'module';
+}
+/** shared C4RelationshipType → domain C4RelationshipType (C4ModelService vocabulary).
+ * The two unions diverge (shared `sends`/`reads`/`writes`/`imports`/`stores_data_in`
+ * vs domain `sends_to`/`reads_from`/`writes_to`); fold to the nearest domain verb. */
+const RELATIONSHIP_TYPE_MAP = {
+    uses: 'uses',
+    calls: 'calls',
+    imports: 'depends_on',
+    depends_on: 'depends_on',
+    extends: 'extends',
+    implements: 'implements',
+    sends: 'sends_to',
+    reads: 'reads_from',
+    writes: 'writes_to',
+    stores_data_in: 'writes_to',
+    authenticates_with: 'authenticates_with',
+};
+export function mapRelationshipType(type) {
+    return RELATIONSHIP_TYPE_MAP[type] ?? 'uses';
+}
+/** Detected external systems → C4 ExternalSystemSpec[]. */
+export function toExternalSystemSpecs(externalSystems) {
+    return externalSystems.map((es) => ({
+        name: es.name,
+        type: mapExternalSystemType(es.type),
+        technology: es.technology,
+        relationshipDescription: es.relationship,
+    }));
+}
+/** Detected components → C4 ComponentSpec[]. */
+export function toComponentSpecs(components) {
+    return components.map((c) => ({
+        name: c.name,
+        type: mapComponentType(c.type),
+        technology: c.technology,
+        boundary: c.boundary,
+        files: c.files,
+        responsibilities: c.responsibilities,
+    }));
+}
+/**
+ * Detected relationships → C4 ComponentRelationshipSpec[].
+ *
+ * `DetectedRelationship` references components by `id`; the service re-derives
+ * ids by sanitizing the spec's `from`/`to` NAMES. So we translate ids back to
+ * names via the component set; relationships whose endpoints aren't in the set
+ * are dropped (they can't render) — surfaced by the caller's count delta.
+ */
+export function toComponentRelationshipSpecs(components, relationships) {
+    const nameById = new Map(components.map((c) => [c.id, c.name]));
+    const specs = [];
+    for (const rel of relationships) {
+        const from = nameById.get(rel.sourceId);
+        const to = nameById.get(rel.targetId);
+        if (from === undefined || to === undefined)
+            continue;
+        specs.push({ from, to, type: mapRelationshipType(rel.type) });
+    }
+    return specs;
+}
+/** Project + detected external systems → BuildContextRequest. */
+export function toContextRequest(project, externalSystems) {
+    return {
+        systemName: project.name,
+        systemDescription: project.description,
+        externalSystems: toExternalSystemSpecs(externalSystems),
+    };
+}
+/** Project + detected external systems → BuildContainerRequest (single app container). */
+export function toContainerRequest(project, externalSystems) {
+    const externalSpecs = toExternalSystemSpecs(externalSystems);
+    return {
+        systemName: project.name,
+        containers: [
+            {
+                name: DEFAULT_CONTAINER_NAME,
+                type: 'web_application',
+                technology: 'TypeScript',
+                description: 'Main application',
+            },
+        ],
+        externalSystems: externalSpecs,
+        // The legacy bridge drew Rel(app, <external>) for each external system.
+        dependencies: externalSpecs.map((es) => ({
+            from: DEFAULT_CONTAINER_NAME,
+            to: es.name,
+            description: es.relationshipDescription,
+        })),
+    };
+}
+/** Detected components + relationships → BuildComponentRequest. */
+export function toComponentRequest(components, relationships, containerName = DEFAULT_CONTAINER_NAME) {
+    return {
+        containerName,
+        components: toComponentSpecs(components),
+        relationships: toComponentRelationshipSpecs(components, relationships),
+    };
+}
+//# sourceMappingURL=from-detected.js.map

package/dist/domains/code-intelligence/services/c4-model/kg-relationships.d.ts

@@ -0,0 +1,71 @@
+/**
+ * ADR-112 C2 — real component relationships from the Knowledge Graph.
+ *
+ * The detector models components as top-level `src/` directories but its edge
+ * detection is a NAMING heuristic (`likelyHasRelationship`) that never reads the
+ * code. This module folds the KnowledgeGraph's REAL file-level import/call edges
+ * (extracted from the AST by the TS parser — no LLM needed) up to
+ * component→component relationships.
+ *
+ * Pure aggregation + a resolver that drives the existing KG. The resolver
+ * returns `null` on any miss so the bridge falls back to the heuristic — C2 can
+ * only improve accuracy, never break generation.
+ */
+import type { DetectedComponent, DetectedRelationship } from '../../../../shared/c4-model';
+/** Minimal shape of the KG `mapDependencies` result we consume. */
+export interface DependencyMapLike {
+    nodes: Array<{
+        id: string;
+        path: string;
+    }>;
+    edges: Array<{
+        source: string;
+        target: string;
+    }>;
+}
+/** Minimal slice of the KnowledgeGraph the resolver needs (keeps this decoupled). */
+export interface KnowledgeGraphSlice {
+    index(req: {
+        paths: string[];
+        incremental?: boolean;
+    }): Promise<{
+        success: boolean;
+    }>;
+    mapDependencies(req: {
+        files: string[];
+        direction: 'incoming' | 'outgoing' | 'both';
+        depth?: number;
+    }): Promise<{
+        success: boolean;
+        value?: DependencyMapLike;
+    }>;
+}
+/**
+ * Resolve real component relationships for a set of detected components.
+ * Returns `null` when it cannot (no files, KG miss, no cross-component edges) so
+ * the caller keeps the heuristic.
+ */
+export type RelationshipResolver = (components: DetectedComponent[], projectPath: string) => Promise<DetectedRelationship[] | null>;
+/**
+ * PURE: fold file-level dependency edges into component→component relationships.
+ * An edge counts only when both endpoints map to *different* components; weight =
+ * number of underlying file edges. Exported for direct testing.
+ */
+export declare function aggregateDependencyMapToComponentRelationships(components: DetectedComponent[], dependencyMap: DependencyMapLike, projectPath: string): DetectedRelationship[];
+/**
+ * A KG factory scoped to a project root. Building the KG per-call lets us set
+ * the FileReader base directory to `projectPath`, so analyzing a repo outside
+ * cwd doesn't trip the path-traversal guard.
+ */
+export type KnowledgeGraphFactory = (projectPath: string) => KnowledgeGraphSlice;
+/**
+ * Build a resolver backed by the existing KnowledgeGraph. It (incrementally)
+ * indexes the component files so edges exist regardless of prior `aqe code
+ * index`, maps their dependencies, and aggregates to component edges.
+ *
+ * Accepts a project-scoped factory (preferred) or a single pre-built KG.
+ */
+export declare function createKnowledgeGraphRelationshipResolver(kgOrFactory: KnowledgeGraphSlice | KnowledgeGraphFactory, opts?: {
+    autoIndex?: boolean;
+}): RelationshipResolver;
+//# sourceMappingURL=kg-relationships.d.ts.map

package/dist/domains/code-intelligence/services/c4-model/kg-relationships.js

@@ -0,0 +1,87 @@
+/**
+ * ADR-112 C2 — real component relationships from the Knowledge Graph.
+ *
+ * The detector models components as top-level `src/` directories but its edge
+ * detection is a NAMING heuristic (`likelyHasRelationship`) that never reads the
+ * code. This module folds the KnowledgeGraph's REAL file-level import/call edges
+ * (extracted from the AST by the TS parser — no LLM needed) up to
+ * component→component relationships.
+ *
+ * Pure aggregation + a resolver that drives the existing KG. The resolver
+ * returns `null` on any miss so the bridge falls back to the heuristic — C2 can
+ * only improve accuracy, never break generation.
+ */
+import * as path from 'path';
+const normalize = (projectPath, p) => path.resolve(projectPath, p).replace(/\\/g, '/');
+/**
+ * PURE: fold file-level dependency edges into component→component relationships.
+ * An edge counts only when both endpoints map to *different* components; weight =
+ * number of underlying file edges. Exported for direct testing.
+ */
+export function aggregateDependencyMapToComponentRelationships(components, dependencyMap, projectPath) {
+    // normalized file path → componentId
+    const fileToComponent = new Map();
+    for (const c of components) {
+        for (const f of c.files ?? [])
+            fileToComponent.set(normalize(projectPath, f), c.id);
+    }
+    const idToPath = new Map(dependencyMap.nodes.map((n) => [n.id, normalize(projectPath, n.path)]));
+    const componentOf = (nodeId) => {
+        const p = idToPath.get(nodeId);
+        if (!p)
+            return undefined;
+        const exact = fileToComponent.get(p);
+        if (exact)
+            return exact;
+        // Tolerate abs/rel divergence from the parser via a suffix match.
+        for (const [file, cid] of fileToComponent) {
+            if (p.endsWith(file) || file.endsWith(p))
+                return cid;
+        }
+        return undefined;
+    };
+    const byKey = new Map();
+    for (const e of dependencyMap.edges) {
+        const cs = componentOf(e.source);
+        const ct = componentOf(e.target);
+        if (!cs || !ct || cs === ct)
+            continue;
+        const key = `${cs}->${ct}`;
+        const existing = byKey.get(key);
+        if (existing)
+            existing.weight = (existing.weight ?? 1) + 1;
+        else
+            byKey.set(key, { sourceId: cs, targetId: ct, type: 'depends_on', weight: 1 });
+    }
+    return [...byKey.values()];
+}
+/**
+ * Build a resolver backed by the existing KnowledgeGraph. It (incrementally)
+ * indexes the component files so edges exist regardless of prior `aqe code
+ * index`, maps their dependencies, and aggregates to component edges.
+ *
+ * Accepts a project-scoped factory (preferred) or a single pre-built KG.
+ */
+export function createKnowledgeGraphRelationshipResolver(kgOrFactory, opts = {}) {
+    const autoIndex = opts.autoIndex ?? true;
+    const factory = typeof kgOrFactory === 'function' ? kgOrFactory : () => kgOrFactory;
+    return async (components, projectPath) => {
+        const absFiles = components.flatMap((c) => (c.files ?? []).map((f) => path.resolve(projectPath, f)));
+        if (absFiles.length === 0)
+            return null;
+        try {
+            const kg = factory(projectPath);
+            if (autoIndex)
+                await kg.index({ paths: absFiles, incremental: true });
+            const dep = await kg.mapDependencies({ files: absFiles, direction: 'both' });
+            if (!dep.success || !dep.value)
+                return null;
+            const rels = aggregateDependencyMapToComponentRelationships(components, dep.value, projectPath);
+            return rels.length > 0 ? rels : null;
+        }
+        catch {
+            return null; // any failure → heuristic fallback
+        }
+    };
+}
+//# sourceMappingURL=kg-relationships.js.map

package/dist/domains/code-intelligence/services/knowledge-graph.d.ts

@@ -40,6 +40,12 @@ export interface KnowledgeGraphConfig {
     llmModelTier?: number;
     /** ADR-051: Max tokens for LLM responses */
     llmMaxTokens?: number;
+    /**
+     * ADR-112 C2: base directory for file reads. Defaults to cwd. Set to a
+     * project root so analyzing a repo OUTSIDE cwd (e.g. `aqe code c4 /other`)
+     * doesn't trip the FileReader path-traversal guard.
+     */
+    basePath?: string;
 }
 /**
  * Dependencies for KnowledgeGraphService

package/dist/domains/code-intelligence/services/knowledge-graph.js

@@ -72,7 +72,7 @@ export class KnowledgeGraphService {
             this.llmRouter = undefined;
         }
         this.tsParser = new TypeScriptParser();
-        this.fileReader = new FileReader();
+        this.fileReader = new FileReader(this.config.basePath ? { basePath: this.config.basePath } : undefined);
         this.embedder = new NomicEmbedder({
             enableFallback: true,
         });
@@ -390,7 +390,7 @@ Be precise and only report high-confidence findings.`,
             }
             return { semanticRelationships: [], designPatterns: [], architecturalBoundaries: [], dependencyImpacts: [] };
         }
-        catch (error) {
+        catch {
             logger.warn('LLM relationship extraction failed:');
             return { semanticRelationships: [], designPatterns: [], architecturalBoundaries: [], dependencyImpacts: [] };
         }
@@ -501,7 +501,7 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
             }
             return { enhancedResults: results, insights: [] };
         }
-        catch (error) {
+        catch {
             logger.warn('LLM query enhancement failed:');
             return { enhancedResults: results, insights: [] };
         }

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

@@ -13,7 +13,8 @@
  */
 import { Result } from '../../../shared/types';
 import { EventBus, MemoryBackend } from '../../../kernel/interfaces';
-import { C4DiagramResult, C4DiagramRequest, C4ProjectInfo, DetectedExternalSystem, DetectedComponent, DetectedRelationship, IC4DiagramGenerator } from '../../../shared/c4-model';
+import { C4DiagramResult, C4DiagramRequest, DetectedExternalSystem, DetectedComponent, DetectedRelationship } from '../../../shared/c4-model';
+import type { RelationshipResolver } from './c4-model/kg-relationships';
 export interface ProductFactorsBridgeConfig {
     /** Cache TTL in milliseconds (default: 1 hour) */
     cacheTtlMs: number;
@@ -23,6 +24,18 @@ export interface ProductFactorsBridgeConfig {
     excludePatterns: string[];
     /** Maximum files to analyze */
     maxFiles: number;
+    /**
+     * ADR-112 C2: optional resolver that returns REAL component relationships
+     * from the Knowledge Graph. When it yields edges, they replace the naming
+     * heuristic; otherwise the heuristic stands. Off by default (no resolver).
+     */
+    relationshipResolver?: RelationshipResolver;
+    /**
+     * ADR-112: persist diagram embeddings so they're semantically searchable
+     * (`qe/code/c4 search`). Off by default — the internal product-factors path
+     * stays fast/offline; surfaces that expose search (MCP) turn it on.
+     */
+    enableC4Embeddings?: boolean;
 }
 export interface IProductFactorsBridge {
     /** Initialize the bridge and subscribe to events */
@@ -40,13 +53,21 @@ export interface IProductFactorsBridge {
     /** Get components for a project */
     getComponents(projectPath: string): Promise<Result<DetectedComponent[], Error>>;
 }
-export declare class ProductFactorsBridgeService implements IProductFactorsBridge, IC4DiagramGenerator {
+export declare class ProductFactorsBridgeService implements IProductFactorsBridge {
     private readonly eventBus;
     private readonly memory;
     private readonly config;
     private initialized;
     private eventSubscriptions;
+    /** ADR-112: the consolidated render+analyze+store engine (lazily built). */
+    private c4Service?;
     constructor(eventBus: EventBus, memory: MemoryBackend, config?: Partial<ProductFactorsBridgeConfig>);
+    /**
+     * 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.
+     */
+    private getC4Service;
     initialize(): Promise<void>;
     dispose(): Promise<void>;
     private subscribeToEvents;
@@ -54,9 +75,9 @@ export declare class ProductFactorsBridgeService implements IProductFactorsBridg
     private handleImpactAnalysisCompleted;
     requestC4Diagrams(request: C4DiagramRequest): Promise<Result<C4DiagramResult, Error>>;
     private generateC4Diagrams;
-    generateContextDiagram(project: C4ProjectInfo, externalSystems: DetectedExternalSystem[]): string;
-    generateContainerDiagram(project: C4ProjectInfo, externalSystems: DetectedExternalSystem[]): string;
-    generateComponentDiagram(projectName: string, components: DetectedComponent[], relationships: DetectedRelationship[]): string;
+    private renderContext;
+    private renderContainer;
+    private renderComponent;
     generateDependencyGraph(components: DetectedComponent[], relationships: DetectedRelationship[]): string;
     private getProjectMetadata;
     private detectExternalSystems;