@living-architecture/riviere-cli 0.8.10 → 0.8.12

package/dist/bin.js

@@ -2980,7 +2980,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve6.call(this, root, ref);
+      let _sch = resolve8.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -3007,7 +3007,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve6(root, ref) {
+    function resolve8(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3582,7 +3582,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve6(baseURI, relativeURI, options) {
+    function resolve8(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3809,7 +3809,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve6,
+      resolve: resolve8,
       resolveComponent,
       equal,
       serialize,
@@ -25180,7 +25180,8 @@ import { Command as Command21 } from "commander";
 // src/platform/infra/extraction-config/config-loader.ts
 import {
   dirname as dirname2,
-  resolve as resolve2
+  resolve as resolve2,
+  posix as posix3
 } from "node:path";
 import {
   existsSync as existsSync2,
@@ -25241,7 +25242,7 @@ var extraction_config_schema_default = {
     module: {
       type: "object",
       description: "A module defines extraction rules for a path pattern",
-      required: ["name", "path"],
+      required: ["name", "path", "glob"],
       additionalProperties: false,
       properties: {
         name: {
@@ -25251,7 +25252,12 @@ var extraction_config_schema_default = {
         },
         path: {
           type: "string",
-          description: "Glob pattern for files in this module",
+          description: "Module root directory relative to config file",
+          minLength: 1
+        },
+        glob: {
+          type: "string",
+          description: "Glob pattern for source files within the module directory",
           minLength: 1
         },
         extends: {
@@ -26318,11 +26324,11 @@ function createFunctionComponent(func, filePath, domain2, componentType) {
 function findMatchingModule(filePath, modules, globMatcher, configDir) {
   const normalized = filePath.replaceAll(/\\+/g, "/");
   if (configDir === void 0) {
-    return modules.find((m) => globMatcher(normalized, m.path));
+    return modules.find((m) => globMatcher(normalized, posix.join(m.path, m.glob)));
   }
   const normalizedConfigDir = configDir.replaceAll(/\\+/g, "/");
   const pathToMatch = posix.relative(normalizedConfigDir, normalized);
-  return modules.find((m) => globMatcher(pathToMatch, m.path));
+  return modules.find((m) => globMatcher(pathToMatch, posix.join(m.path, m.glob)));
 }
 
 // ../riviere-extract-ts/dist/features/extraction/domain/config-resolution/config-resolution-errors.js
@@ -26360,6 +26366,7 @@ function resolveModule(moduleConfig, loader) {
   return {
     name: moduleConfig.name,
     path: moduleConfig.path,
+    glob: moduleConfig.glob,
     api: requireRule(moduleConfig.api, "api", moduleConfig.name),
     useCase: requireRule(moduleConfig.useCase, "useCase", moduleConfig.name),
     domainOp: requireRule(moduleConfig.domainOp, "domainOp", moduleConfig.name),
@@ -26379,6 +26386,7 @@ function resolveModuleWithExtends(moduleConfig, extendsSource, loader) {
   return {
     name: moduleConfig.name,
     path: moduleConfig.path,
+    glob: moduleConfig.glob,
     api: moduleConfig.api ?? baseModule.api,
     useCase: moduleConfig.useCase ?? baseModule.useCase,
     domainOp: moduleConfig.domainOp ?? baseModule.domainOp,
@@ -28845,50 +28853,48 @@ function traceNonComponent(project, componentIndex, source, typeName, calledMeth
 }
 
 // ../riviere-extract-ts/dist/features/extraction/domain/connection-detection/async-detection/detect-publish-connections.js
-function detectPublishConnections(project, components, options) {
+function detectPublishConnections(components, options) {
   const publishers = components.filter((c) => c.type === "eventPublisher");
   const events = components.filter((c) => c.type === "event");
   const repository = options.repository;
-  return publishers.flatMap((publisher) => extractPublisherLinks(project, publisher, events, options, repository));
-}
-function extractPublisherLinks(project, publisher, events, options, repository) {
-  const publishedEventType = publisher.metadata["publishedEventType"];
-  if (typeof publishedEventType === "string") {
+  return publishers.flatMap((publisher) => {
+    const publishedEventType = publisher.metadata["publishedEventType"];
     const sourceLocation = {
       repository,
       filePath: publisher.location.file,
       lineNumber: publisher.location.line
     };
-    return resolvePublishTarget(publisher, publishedEventType, events, options, sourceLocation);
-  }
-  const classDecl = findClassInProject(project, publisher);
-  if (classDecl === void 0) {
-    return [];
-  }
-  const methods = classDecl.getMethods();
-  return methods.flatMap((method) => {
-    const firstParam = method.getParameters()[0];
-    if (firstParam === void 0) {
-      return [];
+    if (typeof publishedEventType !== "string") {
+      return [handleMissingMetadata(publisher, options, sourceLocation)];
     }
-    const paramType = firstParam.getType();
-    const paramTypeName = stripGenericArgs(paramType.getText(firstParam));
-    const sourceLocation = {
-      repository,
-      filePath: publisher.location.file,
-      lineNumber: method.getStartLineNumber()
-    };
-    return resolvePublishTarget(publisher, paramTypeName, events, options, sourceLocation);
+    return resolvePublishTarget(publisher, publishedEventType, events, options, sourceLocation);
   });
 }
-function resolvePublishTarget(publisher, paramTypeName, events, options, sourceLocation) {
-  const matchingEvents = events.filter((e) => e.metadata["eventName"] === paramTypeName);
+function handleMissingMetadata(publisher, options, sourceLocation) {
+  if (options.strict) {
+    throw new ConnectionDetectionError({
+      file: sourceLocation.filePath,
+      line: sourceLocation.lineNumber,
+      typeName: publisher.name,
+      reason: 'eventPublisher is missing required "publishedEventType" metadata'
+    });
+  }
+  return {
+    source: componentIdentity(publisher),
+    target: "_unresolved",
+    type: "async",
+    sourceLocation,
+    _uncertain: `eventPublisher "${publisher.name}" is missing required "publishedEventType" metadata`
+  };
+}
+function resolvePublishTarget(publisher, publishedEventType, events, options, sourceLocation) {
+  const matchingEvents = events.filter((e) => e.metadata["eventName"] === publishedEventType);
   if (matchingEvents.length === 0) {
-    return [handleNoMatch(publisher, paramTypeName, options, sourceLocation)];
+    return [handleNoMatch(publisher, publishedEventType, options, sourceLocation)];
   }
   if (matchingEvents.length > 1) {
     return [
-      handleAmbiguousMatch(publisher, paramTypeName, matchingEvents.length, options, sourceLocation)
+      handleAmbiguousMatch(publisher, publishedEventType, matchingEvents.length, options, sourceLocation)
     ];
   }
   return matchingEvents.map((event) => ({
@@ -28898,13 +28904,13 @@ function resolvePublishTarget(publisher, paramTypeName, events, options, sourceL
     sourceLocation
   }));
 }
-function handleAmbiguousMatch(publisher, paramTypeName, matchCount, options, sourceLocation) {
+function handleAmbiguousMatch(publisher, publishedEventType, matchCount, options, sourceLocation) {
   if (options.strict) {
     throw new ConnectionDetectionError({
       file: sourceLocation.filePath,
       line: sourceLocation.lineNumber,
       typeName: publisher.name,
-      reason: `parameter type "${paramTypeName}" matches ${matchCount} Event components (ambiguous)`
+      reason: `publishedEventType "${publishedEventType}" matches ${matchCount} Event components (ambiguous)`
     });
   }
   return {
@@ -28912,16 +28918,16 @@ function handleAmbiguousMatch(publisher, paramTypeName, matchCount, options, sou
     target: "_unresolved",
     type: "async",
     sourceLocation,
-    _uncertain: `ambiguous: ${matchCount} events match parameter type: ${paramTypeName}`
+    _uncertain: `ambiguous: ${matchCount} events match publishedEventType: ${publishedEventType}`
   };
 }
-function handleNoMatch(publisher, paramTypeName, options, sourceLocation) {
+function handleNoMatch(publisher, publishedEventType, options, sourceLocation) {
   if (options.strict) {
     throw new ConnectionDetectionError({
       file: sourceLocation.filePath,
       line: sourceLocation.lineNumber,
       typeName: publisher.name,
-      reason: `parameter type "${paramTypeName}" does not match any Event component`
+      reason: `publishedEventType "${publishedEventType}" does not match any Event component`
     });
   }
   return {
@@ -28929,7 +28935,7 @@ function handleNoMatch(publisher, paramTypeName, options, sourceLocation) {
     target: "_unresolved",
     type: "async",
     sourceLocation,
-    _uncertain: `no event found for parameter type: ${paramTypeName}`
+    _uncertain: `no event found for publishedEventType: ${publishedEventType}`
   };
 }
 
@@ -29238,8 +29244,7 @@ function deduplicateCrossStrategy(links) {
   }
   return [...seen.values()];
 }
-function detectConnections(project, components, options, globMatcher) {
-  const totalStart = performance.now();
+function detectPerModuleConnections(project, components, options, globMatcher) {
   const setupStart = performance.now();
   const componentIndex = new ComponentIndex(components);
   const sourceFilePaths = computeFilteredFilePaths(project, options.moduleGlobs, globMatcher);
@@ -29253,43 +29258,50 @@ function detectConnections(project, components, options, globMatcher) {
     repository
   });
   const callGraphMs = performance.now() - callGraphStart;
+  const patterns = options.patterns ?? [];
+  const { configurableLinks, configurableMs } = runConfigurableDetection(project, patterns, components, componentIndex, strict, repository);
+  return {
+    links: [...syncLinks, ...configurableLinks],
+    timings: {
+      callGraphMs,
+      configurableMs,
+      setupMs
+    }
+  };
+}
+function detectCrossModuleConnections(allComponents, options) {
+  const strict = options.allowIncomplete !== true;
+  const repository = options.repository;
   const asyncStart = performance.now();
-  const publishLinks = detectPublishConnections(project, components, {
+  const publishLinks = detectPublishConnections(allComponents, {
     strict,
     repository
   });
-  const subscribeLinks = detectSubscribeConnections(components, {
+  const subscribeLinks = detectSubscribeConnections(allComponents, {
     strict,
     repository
   });
   const asyncDetectionMs = performance.now() - asyncStart;
-  const patterns = options.patterns ?? [];
-  const { configurableLinks, configurableMs } = patterns.length > 0 ? (() => {
-    const configurableStart = performance.now();
-    const links = detectConfigurableConnections(project, patterns, components, componentIndex, {
-      strict,
-      repository
-    });
+  return {
+    links: [...publishLinks, ...subscribeLinks],
+    timings: { asyncDetectionMs }
+  };
+}
+function runConfigurableDetection(project, patterns, components, componentIndex, strict, repository) {
+  if (patterns.length === 0) {
     return {
-      configurableLinks: links,
-      configurableMs: performance.now() - configurableStart
+      configurableLinks: [],
+      configurableMs: 0
     };
-  })() : {
-    configurableLinks: [],
-    configurableMs: 0
-  };
-  const totalMs = performance.now() - totalStart;
-  const allLinks = [...syncLinks, ...publishLinks, ...subscribeLinks, ...configurableLinks];
-  const deduplicatedLinks = deduplicateCrossStrategy(allLinks);
+  }
+  const configurableStart = performance.now();
+  const links = detectConfigurableConnections(project, patterns, components, componentIndex, {
+    strict,
+    repository
+  });
   return {
-    links: deduplicatedLinks,
-    timings: {
-      callGraphMs,
-      asyncDetectionMs,
-      configurableMs,
-      setupMs,
-      totalMs
-    }
+    configurableLinks: links,
+    configurableMs: performance.now() - configurableStart
   };
 }
 
@@ -29298,7 +29310,7 @@ import { posix as posix2 } from "node:path";
 function findMatchingModule2(filePath, modules, globMatcher, configDir) {
   const normalized = filePath.replaceAll(/\\+/g, "/");
   const pathToMatch = posix2.relative(configDir.replaceAll(/\\+/g, "/"), normalized);
-  return modules.find((m) => globMatcher(pathToMatch, m.path));
+  return modules.find((m) => globMatcher(pathToMatch, posix2.join(m.path, m.glob)));
 }
 function getBuiltInRule(module, componentType) {
   const ruleMap = {
@@ -29520,7 +29532,8 @@ var NOT_USED = { notUsed: true };
 function topLevelRulesToModule(parsed) {
   return {
     name: "extended",
-    path: "**",
+    path: ".",
+    glob: "**",
     api: parsed.api ?? NOT_USED,
     useCase: parsed.useCase ?? NOT_USED,
     domainOp: parsed.domainOp ?? NOT_USED,
@@ -29640,9 +29653,9 @@ function tryExpandModuleRefs(data, configDir) {
   }
 }
 function resolveSourceFiles(resolvedConfig, configDir) {
-  const sourceFilePaths = resolvedConfig.modules.flatMap((module) => globSync(module.path, { cwd: configDir })).map((filePath) => resolve2(configDir, filePath));
+  const sourceFilePaths = resolvedConfig.modules.flatMap((module) => globSync(posix3.join(module.path, module.glob), { cwd: configDir })).map((filePath) => resolve2(configDir, filePath));
   if (sourceFilePaths.length === 0) {
-    const patterns = resolvedConfig.modules.map((m) => m.path).join(", ");
+    const patterns = resolvedConfig.modules.map((m) => posix3.join(m.path, m.glob)).join(", ");
     throw new ConfigValidationError(
       "VALIDATION_ERROR" /* ValidationError */,
       `No files matched extraction patterns: ${patterns}
@@ -29897,111 +29910,6 @@ function validateFlagCombinations(options) {
   validateFormatOption(options);
 }
 
-// src/platform/infra/cli-presentation/format-pr-markdown.ts
-function formatComponentLine(component) {
-  return `- **${component.type}** \`${component.name}\` in \`${component.domain}\` domain`;
-}
-function formatSection(title, components) {
-  const header = `### ${title} (${components.length})`;
-  if (components.length === 0) {
-    return `${header}
-None`;
-  }
-  return `${header}
-${components.map(formatComponentLine).join("\n")}`;
-}
-function formatPrMarkdown(categorized) {
-  const sections = [
-    formatSection("Added Components", categorized.added),
-    formatSection("Modified Components", categorized.modified),
-    formatSection("Removed Components", categorized.removed)
-  ];
-  return `## Architecture Changes
-
-${sections.join("\n\n")}`;
-}
-
-// src/platform/infra/cli-presentation/extract-output-formatter.ts
-function compareByCodePoint2(a, b) {
-  if (a < b) return -1;
-  if (a > b) return 1;
-  return 0;
-}
-function formatDryRunOutput(components) {
-  const countsByDomain = /* @__PURE__ */ new Map();
-  for (const component of components) {
-    const existingTypeCounts = countsByDomain.get(component.domain);
-    const typeCounts = existingTypeCounts ?? /* @__PURE__ */ new Map();
-    if (existingTypeCounts === void 0) {
-      countsByDomain.set(component.domain, typeCounts);
-    }
-    const currentCount = typeCounts.get(component.type) ?? 0;
-    typeCounts.set(component.type, currentCount + 1);
-  }
-  const sortedDomains = [...countsByDomain.entries()].sort(([a], [b]) => compareByCodePoint2(a, b));
-  const lines = [];
-  for (const [domain2, typeCounts] of sortedDomains) {
-    const typeStrings = [...typeCounts.entries()].sort(([a], [b]) => compareByCodePoint2(a, b)).map(([type, count]) => `${type}(${count})`);
-    lines.push(`${domain2}: ${typeStrings.join(", ")}`);
-  }
-  return lines;
-}
-
-// src/platform/infra/cli-presentation/output-writer.ts
-import { writeFileSync } from "node:fs";
-function outputResult(data, options) {
-  if (options.output !== void 0) {
-    try {
-      writeFileSync(options.output, JSON.stringify(data));
-    } catch {
-      console.log(
-        JSON.stringify(
-          formatError2(
-            "VALIDATION_ERROR" /* ValidationError */,
-            "Failed to write output file: " + options.output
-          )
-        )
-      );
-      process.exit(3 /* RuntimeError */);
-    }
-    return;
-  }
-  console.log(JSON.stringify(data));
-}
-
-// src/platform/infra/cli-presentation/format-extraction-stats.ts
-function countLinksByType(componentCount, links) {
-  const syncLinkCount = links.filter((l) => l.type === "sync").length;
-  const asyncLinkCount = links.filter((l) => l.type === "async").length;
-  const uncertainLinkCount = links.filter((l) => l._uncertain !== void 0).length;
-  return {
-    componentCount,
-    linkCount: links.length,
-    syncLinkCount,
-    asyncLinkCount,
-    uncertainLinkCount
-  };
-}
-function formatSeconds(ms) {
-  return (ms / 1e3).toFixed(2) + "s";
-}
-function formatExtractionStats(stats) {
-  const lines = [`Components: ${stats.componentCount}`];
-  if (stats.linkCount !== void 0) {
-    lines.push(
-      `Links: ${stats.linkCount} (sync: ${stats.syncLinkCount}, async: ${stats.asyncLinkCount})`
-    );
-    lines.push(`Uncertain: ${stats.uncertainLinkCount}`);
-  }
-  return lines;
-}
-function formatTimingLine(timings) {
-  return `Extraction completed in ${formatSeconds(timings.totalMs)} (call graph: ${formatSeconds(timings.callGraphMs)}, detection: ${formatSeconds(timings.asyncDetectionMs)}, setup: ${formatSeconds(timings.setupMs)})`;
-}
-
-// src/features/extract/infra/safe-extraction-operations.ts
-import "ts-morph";
-
 // src/platform/infra/extraction-config/draft-component-loader.ts
 import {
   existsSync as existsSync4,
@@ -30040,43 +29948,6 @@ function loadDraftComponentsFromFile(filePath) {
   return parsed;
 }
 
-// src/features/extract/infra/safe-extraction-operations.ts
-function loadOrExtractComponents(project, sourceFilePaths, resolvedConfig, configDir, enrichPath) {
-  if (enrichPath === void 0) {
-    return extractComponents(project, sourceFilePaths, resolvedConfig, matchesGlob, configDir);
-  }
-  return loadDraftComponentsFromFile(enrichPath);
-}
-function enrichComponentsSafe(draftComponents, resolvedConfig, project, configDir, allowIncomplete) {
-  const result = enrichComponents(draftComponents, resolvedConfig, project, matchesGlob, configDir);
-  if (result.failures.length > 0) {
-    const failedFields = result.failures.map((f) => f.field);
-    if (!allowIncomplete) {
-      throw new ExtractionFieldFailureError(failedFields);
-    }
-    console.error(
-      `Warning: Enrichment failed for ${failedFields.length} field(s): ${failedFields.join(", ")}`
-    );
-  }
-  return result;
-}
-function detectConnectionsSafe(project, components, moduleGlobs, repository, allowIncomplete, showStats) {
-  const result = detectConnections(
-    project,
-    components,
-    {
-      allowIncomplete,
-      moduleGlobs,
-      repository
-    },
-    matchesGlob
-  );
-  if (showStats) {
-    console.error(formatTimingLine(result.timings));
-  }
-  return result;
-}
-
 // src/platform/infra/git/git-repository-info.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 var RepositoryUrlParseError = class extends Error {
@@ -30158,31 +30029,316 @@ function getRepositoryInfo(gitBinary = "git", cwd = process.cwd(), executor = de
   }
 }
 
-// src/features/extract/infra/ts-morph/create-configured-project.ts
+// src/features/extract/infra/external-clients/create-module-contexts.ts
+import {
+  posix as posix4,
+  resolve as resolve7
+} from "node:path";
+import { globSync as globSync2 } from "glob";
+
+// src/features/extract/infra/external-clients/find-module-tsconfig-dir.ts
 import { existsSync as existsSync5 } from "node:fs";
 import { resolve as resolve5 } from "node:path";
-import { Project as Project3 } from "ts-morph";
+function findModuleTsConfigDir(configDir, modulePath) {
+  const moduleTsConfigPath = resolve5(configDir, modulePath, "tsconfig.json");
+  if (existsSync5(moduleTsConfigPath)) {
+    return resolve5(configDir, modulePath);
+  }
+  return configDir;
+}
+
+// src/features/extract/infra/external-clients/create-configured-project.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
+import { Project as Project2 } from "ts-morph";
 function createConfiguredProject(configDir, skipTsConfig) {
   if (skipTsConfig) {
-    return new Project3();
+    return new Project2();
   }
-  const tsConfigPath = resolve5(configDir, "tsconfig.json");
-  if (!existsSync5(tsConfigPath)) {
-    return new Project3();
+  const tsConfigPath = resolve6(configDir, "tsconfig.json");
+  if (!existsSync6(tsConfigPath)) {
+    return new Project2();
   }
-  return new Project3({
+  return new Project2({
     tsConfigFilePath: tsConfigPath,
     skipAddingFilesFromTsConfig: true
   });
 }
 
-// src/features/extract/infra/load-extraction-project.ts
+// src/features/extract/infra/external-clients/load-extraction-project.ts
 function loadExtractionProject(configDir, sourceFilePaths, skipTsConfig) {
   const project = createConfiguredProject(configDir, skipTsConfig);
   project.addSourceFilesAtPaths(sourceFilePaths);
   return project;
 }
 
+// src/features/extract/infra/external-clients/create-module-contexts.ts
+function createModuleContexts(resolvedConfig, configDir, sourceFilePaths, skipTsConfig) {
+  const sourceFileSet = new Set(sourceFilePaths);
+  return resolvedConfig.modules.map((module) => {
+    const allModuleFiles = globSync2(posix4.join(module.path, module.glob), { cwd: configDir }).map(
+      (f) => resolve7(configDir, f)
+    );
+    const moduleFiles = allModuleFiles.filter((f) => sourceFileSet.has(f));
+    const tsConfigDir = findModuleTsConfigDir(configDir, module.path);
+    const project = loadExtractionProject(tsConfigDir, moduleFiles, skipTsConfig);
+    return {
+      module,
+      files: moduleFiles,
+      project
+    };
+  });
+}
+
+// src/features/extract/domain/extract-draft-components.ts
+function extractDraftComponents(moduleContexts, resolvedConfig, configDir) {
+  return moduleContexts.flatMap(
+    (ctx) => extractComponents(ctx.project, ctx.files, resolvedConfig, matchesGlob, configDir)
+  );
+}
+
+// src/features/extract/domain/enrich-per-module.ts
+var OrphanedDraftComponentError = class extends Error {
+  constructor(orphanedModules, knownModules) {
+    super(
+      `Draft components reference unknown modules: [${orphanedModules.join(", ")}]. Known modules: [${knownModules.join(", ")}]`
+    );
+    this.name = "OrphanedDraftComponentError";
+  }
+};
+function enrichPerModule(moduleContexts, draftComponents, resolvedConfig, configDir) {
+  const moduleNames = new Set(moduleContexts.map((ctx) => ctx.module.name));
+  const draftsByModule = groupDraftsByModule(draftComponents);
+  assertAllDraftsMatchModules(draftsByModule, moduleNames);
+  const components = [];
+  const failedFieldSet = /* @__PURE__ */ new Set();
+  for (const ctx of moduleContexts) {
+    const moduleDrafts = draftsByModule.get(ctx.module.name) ?? [];
+    if (moduleDrafts.length === 0) {
+      continue;
+    }
+    const result = enrichComponents(
+      moduleDrafts,
+      resolvedConfig,
+      ctx.project,
+      matchesGlob,
+      configDir
+    );
+    components.push(...result.components);
+    for (const f of result.failures) {
+      failedFieldSet.add(f.field);
+    }
+  }
+  return {
+    components,
+    failedFields: [...failedFieldSet]
+  };
+}
+function assertAllDraftsMatchModules(draftsByModule, moduleNames) {
+  const orphanedModules = [...draftsByModule.keys()].filter((name) => !moduleNames.has(name));
+  if (orphanedModules.length > 0) {
+    throw new OrphanedDraftComponentError(orphanedModules, [...moduleNames]);
+  }
+}
+function groupDraftsByModule(drafts) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const draft of drafts) {
+    const existing = grouped.get(draft.domain);
+    if (existing) {
+      existing.push(draft);
+    } else {
+      grouped.set(draft.domain, [draft]);
+    }
+  }
+  return grouped;
+}
+
+// src/features/extract/domain/detect-connections-per-module.ts
+import { posix as posix5 } from "node:path";
+function detectConnectionsPerModule(moduleContexts, enrichedComponents, repositoryName, allowIncomplete) {
+  const links = [];
+  const timings = [];
+  for (const ctx of moduleContexts) {
+    const moduleComponents = enrichedComponents.filter((c) => c.domain === ctx.module.name);
+    if (moduleComponents.length === 0) {
+      continue;
+    }
+    const result = detectPerModuleConnections(
+      ctx.project,
+      moduleComponents,
+      {
+        allowIncomplete,
+        moduleGlobs: [posix5.join(ctx.module.path, ctx.module.glob)],
+        repository: repositoryName
+      },
+      matchesGlob
+    );
+    links.push(...result.links);
+    timings.push({
+      callGraphMs: result.timings.callGraphMs,
+      asyncDetectionMs: 0,
+      configurableMs: result.timings.configurableMs,
+      setupMs: result.timings.setupMs,
+      totalMs: result.timings.callGraphMs + result.timings.configurableMs + result.timings.setupMs
+    });
+  }
+  const crossResult = detectCrossModuleConnections(enrichedComponents, {
+    allowIncomplete,
+    repository: repositoryName
+  });
+  links.push(...crossResult.links);
+  timings.push({
+    callGraphMs: 0,
+    asyncDetectionMs: crossResult.timings.asyncDetectionMs,
+    configurableMs: 0,
+    setupMs: 0,
+    totalMs: crossResult.timings.asyncDetectionMs
+  });
+  return {
+    links: deduplicateCrossStrategy(links),
+    timings
+  };
+}
+
+// src/features/extract/commands/run-extraction.ts
+function runExtraction(options, resolvedConfig, configDir, sourceFilePaths) {
+  const skipTsConfig = options.tsConfig === false;
+  const moduleContexts = createModuleContexts(
+    resolvedConfig,
+    configDir,
+    sourceFilePaths,
+    skipTsConfig
+  );
+  const draftComponents = options.enrich === void 0 ? extractDraftComponents(moduleContexts, resolvedConfig, configDir) : loadDraftComponentsFromFile(options.enrich);
+  if (options.dryRun || options.format === "markdown" || options.componentsOnly) {
+    return {
+      kind: "draftOnly",
+      components: draftComponents
+    };
+  }
+  const allowIncomplete = options.allowIncomplete === true;
+  const enrichment = enrichPerModule(moduleContexts, draftComponents, resolvedConfig, configDir);
+  if (enrichment.failedFields.length > 0 && !allowIncomplete) {
+    throw new ExtractionFieldFailureError(enrichment.failedFields);
+  }
+  const repositoryInfo = getRepositoryInfo();
+  const connectionResult = detectConnectionsPerModule(
+    moduleContexts,
+    enrichment.components,
+    repositoryInfo.name,
+    allowIncomplete
+  );
+  return {
+    kind: "full",
+    components: enrichment.components,
+    links: connectionResult.links,
+    timings: connectionResult.timings,
+    failedFields: enrichment.failedFields
+  };
+}
+
+// src/platform/infra/cli-presentation/format-pr-markdown.ts
+function formatComponentLine(component) {
+  return `- **${component.type}** \`${component.name}\` in \`${component.domain}\` domain`;
+}
+function formatSection(title, components) {
+  const header = `### ${title} (${components.length})`;
+  if (components.length === 0) {
+    return `${header}
+None`;
+  }
+  return `${header}
+${components.map(formatComponentLine).join("\n")}`;
+}
+function formatPrMarkdown(categorized) {
+  const sections = [
+    formatSection("Added Components", categorized.added),
+    formatSection("Modified Components", categorized.modified),
+    formatSection("Removed Components", categorized.removed)
+  ];
+  return `## Architecture Changes
+
+${sections.join("\n\n")}`;
+}
+
+// src/platform/infra/cli-presentation/extract-output-formatter.ts
+function compareByCodePoint2(a, b) {
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}
+function formatDryRunOutput(components) {
+  const countsByDomain = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    const existingTypeCounts = countsByDomain.get(component.domain);
+    const typeCounts = existingTypeCounts ?? /* @__PURE__ */ new Map();
+    if (existingTypeCounts === void 0) {
+      countsByDomain.set(component.domain, typeCounts);
+    }
+    const currentCount = typeCounts.get(component.type) ?? 0;
+    typeCounts.set(component.type, currentCount + 1);
+  }
+  const sortedDomains = [...countsByDomain.entries()].sort(([a], [b]) => compareByCodePoint2(a, b));
+  const lines = [];
+  for (const [domain2, typeCounts] of sortedDomains) {
+    const typeStrings = [...typeCounts.entries()].sort(([a], [b]) => compareByCodePoint2(a, b)).map(([type, count]) => `${type}(${count})`);
+    lines.push(`${domain2}: ${typeStrings.join(", ")}`);
+  }
+  return lines;
+}
+
+// src/platform/infra/cli-presentation/output-writer.ts
+import { writeFileSync } from "node:fs";
+function outputResult(data, options) {
+  if (options.output !== void 0) {
+    try {
+      writeFileSync(options.output, JSON.stringify(data));
+    } catch {
+      console.log(
+        JSON.stringify(
+          formatError2(
+            "VALIDATION_ERROR" /* ValidationError */,
+            "Failed to write output file: " + options.output
+          )
+        )
+      );
+      process.exit(3 /* RuntimeError */);
+    }
+    return;
+  }
+  console.log(JSON.stringify(data));
+}
+
+// src/platform/infra/cli-presentation/format-extraction-stats.ts
+function countLinksByType(componentCount, links) {
+  const syncLinkCount = links.filter((l) => l.type === "sync").length;
+  const asyncLinkCount = links.filter((l) => l.type === "async").length;
+  const uncertainLinkCount = links.filter((l) => l._uncertain !== void 0).length;
+  return {
+    componentCount,
+    linkCount: links.length,
+    syncLinkCount,
+    asyncLinkCount,
+    uncertainLinkCount
+  };
+}
+function formatSeconds(ms) {
+  return (ms / 1e3).toFixed(2) + "s";
+}
+function formatExtractionStats(stats) {
+  const lines = [`Components: ${stats.componentCount}`];
+  if (stats.linkCount !== void 0) {
+    lines.push(
+      `Links: ${stats.linkCount} (sync: ${stats.syncLinkCount}, async: ${stats.asyncLinkCount})`
+    );
+    lines.push(`Uncertain: ${stats.uncertainLinkCount}`);
+  }
+  return lines;
+}
+function formatTimingLine(timings) {
+  return `Extraction completed in ${formatSeconds(timings.totalMs)} (call graph: ${formatSeconds(timings.callGraphMs)}, detection: ${formatSeconds(timings.asyncDetectionMs)}, setup: ${formatSeconds(timings.setupMs)})`;
+}
+
 // src/platform/infra/cli-presentation/categorize-components.ts
 function componentKey(component) {
   return `${component.domain}:${component.type}:${component.name}`;
@@ -30213,61 +30369,50 @@ function categorizeComponents(current, baseline) {
   };
 }
 
-// src/features/extract/commands/run-extraction.ts
-function runExtraction(options, resolvedConfig, configDir, sourceFilePaths) {
-  const project = loadExtractionProject(configDir, sourceFilePaths, options.tsConfig === false);
-  const draftComponents = loadOrExtractComponents(
-    project,
-    sourceFilePaths,
-    resolvedConfig,
-    configDir,
-    options.enrich
-  );
+// src/features/extract/infra/mappers/present-extraction-result.ts
+function presentExtractionResult(result, options) {
+  if (result.kind === "draftOnly") {
+    presentDraftResult(result.components, options);
+    return;
+  }
+  presentFullResult(result, options);
+}
+function presentDraftResult(components, options) {
   if (options.dryRun) {
-    for (const line of formatDryRunOutput(draftComponents)) {
+    for (const line of formatDryRunOutput(components)) {
       console.log(line);
     }
     return;
   }
   if (options.format === "markdown") {
-    const categorized = categorizeComponents(draftComponents, void 0);
+    const categorized = categorizeComponents(components, void 0);
     const markdown = formatPrMarkdown(categorized);
     console.log(markdown);
     return;
   }
-  if (options.componentsOnly) {
-    outputResult(formatSuccess(draftComponents), options);
-    return;
+  outputResult(formatSuccess(components), { output: options.output });
+}
+function presentFullResult(result, options) {
+  if (result.failedFields.length > 0) {
+    console.error(
+      `Warning: Enrichment failed for ${result.failedFields.length} field(s): ${result.failedFields.join(", ")}`
+    );
   }
-  const enrichmentResult = enrichComponentsSafe(
-    draftComponents,
-    resolvedConfig,
-    project,
-    configDir,
-    options.allowIncomplete === true
-  );
-  const repositoryInfo = getRepositoryInfo();
-  const { links } = detectConnectionsSafe(
-    project,
-    enrichmentResult.components,
-    resolvedConfig.modules.map((m) => m.path),
-    repositoryInfo.name,
-    options.allowIncomplete === true,
-    options.stats === true
-  );
   if (options.stats === true) {
-    const stats = countLinksByType(enrichmentResult.components.length, links);
+    for (const timing of result.timings) {
+      console.error(formatTimingLine(timing));
+    }
+    const stats = countLinksByType(result.components.length, result.links);
     for (const line of formatExtractionStats(stats)) {
       console.error(line);
     }
   }
-  const outputOptions = options.output === void 0 ? {} : { output: options.output };
   outputResult(
     formatSuccess({
-      components: enrichmentResult.components,
-      links
+      components: result.components,
+      links: result.links
     }),
-    outputOptions
+    { output: options.output }
   );
 }
 
@@ -30281,7 +30426,8 @@ function createExtractCommand() {
     } = loadAndValidateConfig(options.config);
     const allSourceFilePaths = resolveSourceFiles(resolvedConfig, configDir);
     const sourceFilePaths = resolveFilteredSourceFiles(allSourceFilePaths, options);
-    runExtraction(options, resolvedConfig, configDir, sourceFilePaths);
+    const result = runExtraction(options, resolvedConfig, configDir, sourceFilePaths);
+    presentExtractionResult(result, options);
   });
 }
 
@@ -30297,7 +30443,7 @@ function parsePackageJson(pkg) {
 }
 function loadPackageJson() {
   if (true) {
-    return { version: "0.8.9" };
+    return { version: "0.8.11" };
   }
   const require2 = createRequire2(import.meta.url);
   return parsePackageJson(require2("../../package.json"));
@@ -30395,8 +30541,8 @@ program.parseAsync().catch(handleGlobalError);
 /* v8 ignore next -- @preserve: error is always Error from yaml parser; defensive guard */
 /* v8 ignore start -- @preserve: default executor delegates to execFileSync; tested via CLI integration */
 /* v8 ignore start -- @preserve: detectChangedTypeScriptFiles only throws GitError; non-GitError path is unreachable */
-/* v8 ignore start -- @preserve: trivial comparator, Map keys guarantee a !== b */
-/* v8 ignore start -- @preserve: dry-run output formatting; tested via CLI integration */
 /* v8 ignore start -- @preserve: git execution; mocked in all integration tests */
 /* v8 ignore start -- @preserve: defensive check; regex ([^/]+) requires non-empty groups */
+/* v8 ignore start -- @preserve: trivial comparator, Map keys guarantee a !== b */
+/* v8 ignore start -- @preserve: dry-run output formatting; tested via CLI integration */
 /* v8 ignore start -- @preserve: dry-run tested via CLI integration */