@living-architecture/riviere-cli 0.8.0 → 0.8.1

package/dist/bin.js

@@ -25075,8 +25075,9 @@ Examples:
 
 // src/features/extract/entrypoint/extract.ts
 import {
-  existsSync as existsSync3,
-  readFileSync as readFileSync3
+  existsSync as existsSync4,
+  readFileSync as readFileSync4,
+  writeFileSync
 } from "node:fs";
 import {
   dirname as dirname3,
@@ -26153,14 +26154,192 @@ function requireRule(rule, ruleName, moduleName) {
   return rule;
 }
 
+// ../riviere-extract-ts/dist/platform/domain/string-transforms/transforms.js
+function stripSuffix(value, suffix) {
+  if (value.endsWith(suffix)) {
+    return value.slice(0, -suffix.length);
+  }
+  return value;
+}
+function stripPrefix(value, prefix) {
+  if (value.startsWith(prefix)) {
+    return value.slice(prefix.length);
+  }
+  return value;
+}
+function toLowerCase(value) {
+  return value.toLowerCase();
+}
+function toUpperCase(value) {
+  return value.toUpperCase();
+}
+function kebabToPascal(value) {
+  return value.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function pascalToKebab(value) {
+  const transformed = value.replaceAll(/([A-Z])/g, "-$1").toLowerCase();
+  return transformed.startsWith("-") ? transformed.slice(1) : transformed;
+}
+function applyTransforms(value, transform2) {
+  const transformers = [];
+  if (transform2.stripSuffix !== void 0) {
+    const suffix = transform2.stripSuffix;
+    transformers.push((v) => stripSuffix(v, suffix));
+  }
+  if (transform2.stripPrefix !== void 0) {
+    const prefix = transform2.stripPrefix;
+    transformers.push((v) => stripPrefix(v, prefix));
+  }
+  if (transform2.toLowerCase === true) {
+    transformers.push(toLowerCase);
+  }
+  if (transform2.toUpperCase === true) {
+    transformers.push(toUpperCase);
+  }
+  if (transform2.kebabToPascal === true) {
+    transformers.push(kebabToPascal);
+  }
+  if (transform2.pascalToKebab === true) {
+    transformers.push(pascalToKebab);
+  }
+  return transformers.reduce((acc, fn) => fn(acc), value);
+}
+
 // ../riviere-extract-ts/dist/platform/domain/ast-literals/literal-detection.js
 import { SyntaxKind } from "ts-morph";
+var ExtractionError = class extends Error {
+  location;
+  constructor(message, file2, line) {
+    super(`${message} at ${file2}:${line}`);
+    this.name = "ExtractionError";
+    this.location = {
+      file: file2,
+      line
+    };
+  }
+};
+function extractString(expression) {
+  return expression.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+}
+function extractNumber(expression) {
+  return Number(expression.getText());
+}
+function buildExtractionResult(expression) {
+  const syntaxKind = expression.getKind();
+  switch (syntaxKind) {
+    case SyntaxKind.StringLiteral:
+      return {
+        kind: "string",
+        value: extractString(expression)
+      };
+    case SyntaxKind.NumericLiteral:
+      return {
+        kind: "number",
+        value: extractNumber(expression)
+      };
+    case SyntaxKind.TrueKeyword:
+      return {
+        kind: "boolean",
+        value: true
+      };
+    case SyntaxKind.FalseKeyword:
+      return {
+        kind: "boolean",
+        value: false
+      };
+    default:
+      return void 0;
+  }
+}
+function throwMissingInitializer(file2, line) {
+  throw new ExtractionError("No initializer found", file2, line);
+}
+function throwNonLiteralValue(expression, file2, line) {
+  throw new ExtractionError(`Non-literal value detected (${expression.getKindName()}): ${expression.getText()}. Only inline literals (strings, numbers, booleans) are supported`, file2, line);
+}
+function extractLiteralValue(expression, file2, line) {
+  if (expression === void 0) {
+    throwMissingInitializer(file2, line);
+  }
+  const result = buildExtractionResult(expression);
+  if (result === void 0) {
+    throwNonLiteralValue(expression, file2, line);
+  }
+  return result;
+}
 
 // ../riviere-extract-ts/dist/domain/value-extraction/evaluate-extraction-rule-generic.js
 import { SyntaxKind as SyntaxKind2 } from "ts-morph";
 
 // ../riviere-extract-ts/dist/domain/value-extraction/evaluate-extraction-rule.js
 import { SyntaxKind as SyntaxKind3 } from "ts-morph";
+function literal2(value) {
+  return { value };
+}
+function evaluateLiteralRule(rule) {
+  return literal2(rule.literal);
+}
+function evaluateFromClassNameRule(rule, classDecl) {
+  const className = classDecl.getName() ?? "";
+  if (rule.fromClassName === true) {
+    return { value: className };
+  }
+  const transform2 = rule.fromClassName.transform;
+  if (transform2 === void 0) {
+    return { value: className };
+  }
+  return { value: applyTransforms(className, transform2) };
+}
+function evaluateFromFilePathRule(rule, filePath) {
+  const { pattern, capture, transform: transform2 } = rule.fromFilePath;
+  const regex = new RegExp(pattern);
+  const match2 = regex.exec(filePath);
+  if (match2 === null) {
+    throw new ExtractionError(`Pattern '${pattern}' did not match file path '${filePath}'`, filePath, 0);
+  }
+  const capturedValue = match2[capture];
+  if (capturedValue === void 0) {
+    throw new ExtractionError(`Capture group ${capture} out of bounds. Pattern has ${match2.length - 1} capture groups`, filePath, 0);
+  }
+  if (transform2 === void 0) {
+    return { value: capturedValue };
+  }
+  return { value: applyTransforms(capturedValue, transform2) };
+}
+function findPropertyInHierarchy(classDecl, propertyName, isStatic) {
+  const properties = isStatic ? classDecl.getStaticProperties() : classDecl.getInstanceProperties();
+  const property = properties.find((p) => p.getName() === propertyName);
+  if (property !== void 0 && "getInitializer" in property) {
+    const sourceFile = classDecl.getSourceFile();
+    return {
+      initializer: property.getInitializer(),
+      filePath: sourceFile.getFilePath(),
+      line: property.getStartLineNumber()
+    };
+  }
+  const baseClass = classDecl.getBaseClass();
+  if (baseClass === void 0) {
+    return void 0;
+  }
+  return findPropertyInHierarchy(baseClass, propertyName, isStatic);
+}
+function evaluateFromPropertyRule(rule, classDecl) {
+  const { name, kind, transform: transform2 } = rule.fromProperty;
+  const isStatic = kind === "static";
+  const propertyInfo = findPropertyInHierarchy(classDecl, name, isStatic);
+  if (propertyInfo === void 0) {
+    const sourceFile = classDecl.getSourceFile();
+    throw new ExtractionError(`Property '${name}' not found on class '${classDecl.getName() ?? "anonymous"}'`, sourceFile.getFilePath(), classDecl.getStartLineNumber());
+  }
+  const literalResult = extractLiteralValue(propertyInfo.initializer, propertyInfo.filePath, propertyInfo.line);
+  if (transform2 === void 0) {
+    return { value: literalResult.value };
+  }
+  if (typeof literalResult.value !== "string") {
+    return { value: literalResult.value };
+  }
+  return { value: applyTransforms(literalResult.value, transform2) };
+}
 
 // ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -27719,6 +27898,158 @@ function matchesGlob(path2, pattern) {
   return minimatch(path2, pattern);
 }
 
+// ../riviere-extract-ts/dist/domain/value-extraction/enrich-components.js
+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));
+}
+function isDetectionRule2(rule) {
+  if (typeof rule !== "object" || rule === null) {
+    return false;
+  }
+  return "find" in rule && "where" in rule;
+}
+function getBuiltInRule(module, componentType) {
+  const ruleMap = {
+    api: module.api,
+    useCase: module.useCase,
+    domainOp: module.domainOp,
+    event: module.event,
+    eventHandler: module.eventHandler,
+    ui: module.ui
+  };
+  const rule = ruleMap[componentType];
+  if (isDetectionRule2(rule)) {
+    return rule;
+  }
+  return void 0;
+}
+function findDetectionRule(module, componentType) {
+  const builtInTypes = [
+    "api",
+    "useCase",
+    "domainOp",
+    "event",
+    "eventHandler",
+    "ui"
+  ];
+  if (builtInTypes.includes(componentType)) {
+    return getBuiltInRule(module, componentType);
+  }
+  return module.customTypes?.[componentType];
+}
+function isLiteralRule(rule) {
+  return "literal" in rule;
+}
+function isFromClassNameRule(rule) {
+  return "fromClassName" in rule;
+}
+function isFromFilePathRule(rule) {
+  return "fromFilePath" in rule;
+}
+function isFromPropertyRule(rule) {
+  return "fromProperty" in rule;
+}
+function findClassAtLine(project, draft) {
+  const sourceFile = project.getSourceFile(draft.location.file);
+  if (sourceFile === void 0) {
+    throw new ExtractionError(`Source file '${draft.location.file}' not found in project`, draft.location.file, draft.location.line);
+  }
+  const classDecl = sourceFile.getClasses().find((c) => c.getStartLineNumber() === draft.location.line);
+  if (classDecl === void 0) {
+    throw new ExtractionError(`No class declaration found at line ${draft.location.line}`, draft.location.file, draft.location.line);
+  }
+  return classDecl;
+}
+function evaluateClassRule(rule, classDecl) {
+  if (isFromClassNameRule(rule)) {
+    return evaluateFromClassNameRule(rule, classDecl);
+  }
+  if (!isFromPropertyRule(rule)) {
+    throw new ExtractionError("Unsupported extraction rule type for class-based component", classDecl.getSourceFile().getFilePath(), classDecl.getStartLineNumber());
+  }
+  return evaluateFromPropertyRule(rule, classDecl);
+}
+function evaluateRule(rule, draft, project) {
+  if (isLiteralRule(rule)) {
+    return evaluateLiteralRule(rule);
+  }
+  if (isFromFilePathRule(rule)) {
+    return evaluateFromFilePathRule(rule, draft.location.file);
+  }
+  const classDecl = findClassAtLine(project, draft);
+  return evaluateClassRule(rule, classDecl);
+}
+function componentWithEmptyMetadata(draft) {
+  return {
+    enriched: {
+      ...draft,
+      metadata: {}
+    },
+    failures: []
+  };
+}
+function extractMetadataFields(extractBlock, draft, project) {
+  const metadata = {};
+  const missing = [];
+  const failures = [];
+  for (const [fieldName, extractionRule] of Object.entries(extractBlock)) {
+    try {
+      metadata[fieldName] = evaluateRule(extractionRule, draft, project).value;
+    } catch (error48) {
+      const errorMessage = error48 instanceof Error ? error48.message : String(error48);
+      failures.push({
+        component: draft,
+        field: fieldName,
+        error: errorMessage
+      });
+      missing.push(fieldName);
+    }
+  }
+  return {
+    metadata,
+    missing,
+    failures
+  };
+}
+function enrichSingleComponent(draft, config2, project, globMatcher, configDir) {
+  const module = findMatchingModule2(draft.location.file, config2.modules, globMatcher, configDir);
+  if (module === void 0) {
+    return componentWithEmptyMetadata(draft);
+  }
+  const detectionRule = findDetectionRule(module, draft.type);
+  if (detectionRule?.extract === void 0) {
+    return componentWithEmptyMetadata(draft);
+  }
+  const extracted = extractMetadataFields(detectionRule.extract, draft, project);
+  const enriched = {
+    ...draft,
+    metadata: extracted.metadata
+  };
+  if (extracted.missing.length > 0) {
+    enriched._missing = extracted.missing;
+  }
+  return {
+    enriched,
+    failures: extracted.failures
+  };
+}
+function enrichComponents(draftComponents, config2, project, globMatcher, configDir) {
+  const allComponents = [];
+  const allFailures = [];
+  for (const draft of draftComponents) {
+    const result = enrichSingleComponent(draft, config2, project, globMatcher, configDir);
+    allComponents.push(result.enriched);
+    allFailures.push(...result.failures);
+  }
+  return {
+    components: allComponents,
+    failures: allFailures
+  };
+}
+
 // src/features/extract/commands/config-loader.ts
 import {
   dirname as dirname2,
@@ -27850,6 +28181,44 @@ function expandModuleRefs(config2, configDir) {
   };
 }
 
+// src/features/extract/commands/draft-component-loader.ts
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync3
+} from "node:fs";
+var DraftComponentLoadError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DraftComponentLoadError";
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+function isDraftComponentArray(value) {
+  if (!Array.isArray(value)) return false;
+  return value.every(
+    (item) => typeof item === "object" && item !== null && "type" in item && "name" in item && "domain" in item && "location" in item
+  );
+}
+function parseJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync3(filePath, "utf-8"));
+  } catch {
+    throw new DraftComponentLoadError(`Enrich file contains invalid JSON: ${filePath}`);
+  }
+}
+function loadDraftComponentsFromFile(filePath) {
+  if (!existsSync3(filePath)) {
+    throw new DraftComponentLoadError(`Enrich file not found: ${filePath}`);
+  }
+  const parsed = parseJsonFile(filePath);
+  if (!isDraftComponentArray(parsed)) {
+    throw new DraftComponentLoadError(
+      `Enrich file does not contain valid draft components: ${filePath}`
+    );
+  }
+  return parsed;
+}
+
 // src/features/extract/entrypoint/extract.ts
 function compareByCodePoint2(a, b) {
   if (a < b) return -1;
@@ -27909,87 +28278,145 @@ function tryExpandModuleRefs(data, configDir) {
     };
   }
 }
-function createExtractCommand() {
-  return new Command21("extract").description("Extract architectural components from source code").requiredOption("--config <path>", "Path to extraction config file").option("--dry-run", "Show component counts per domain without full output").action((options) => {
-    if (!existsSync3(options.config)) {
-      console.log(
-        JSON.stringify(
-          formatError2("CONFIG_NOT_FOUND" /* ConfigNotFound */, `Config file not found: ${options.config}`)
-        )
-      );
-      process.exit(1);
-    }
-    const content = readFileSync3(options.config, "utf-8");
-    const parseResult = parseConfigFile(content);
-    if (!parseResult.success) {
-      console.log(
-        JSON.stringify(
-          formatError2("VALIDATION_ERROR" /* ValidationError */, `Invalid config file: ${parseResult.error}`)
-        )
-      );
-      process.exit(1);
-    }
-    const configDir = dirname3(resolve3(options.config));
-    const expansionResult = tryExpandModuleRefs(parseResult.data, configDir);
-    if (!expansionResult.success) {
+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 */,
-            `Error expanding module references: ${expansionResult.error}`
+            "Failed to write output file: " + options.output
           )
         )
       );
-      process.exit(1);
+      process.exit(3 /* RuntimeError */);
     }
-    const expandedData = expansionResult.data;
-    if (!isValidExtractionConfig(expandedData)) {
-      const validationResult = validateExtractionConfig(expandedData);
-      console.log(
-        JSON.stringify(
-          formatError2(
-            "VALIDATION_ERROR" /* ValidationError */,
-            `Invalid extraction config:
-${formatValidationErrors2(validationResult.errors)}`
-          )
-        )
-      );
-      process.exit(1);
-    }
-    const unresolvedConfig = expandedData;
-    const configLoader = createConfigLoader(configDir);
-    const resolvedConfig = resolveConfig(unresolvedConfig, configLoader);
-    const sourceFilePaths = resolvedConfig.modules.flatMap((module) => globSync(module.path, { cwd: configDir })).map((filePath) => resolve3(configDir, filePath));
-    if (sourceFilePaths.length === 0) {
-      const patterns = resolvedConfig.modules.map((m) => m.path).join(", ");
-      console.log(
-        JSON.stringify(
-          formatError2(
-            "VALIDATION_ERROR" /* ValidationError */,
-            `No files matched extraction patterns: ${patterns}
+    return;
+  }
+  console.log(JSON.stringify(data));
+}
+function exitWithRuntimeError(message) {
+  console.log(JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, message)));
+  process.exit(3 /* RuntimeError */);
+}
+function exitWithConfigValidation(code, message) {
+  console.log(JSON.stringify(formatError2(code, message)));
+  process.exit(2 /* ConfigValidation */);
+}
+function exitWithExtractionFailure(fieldNames) {
+  const uniqueFields = [...new Set(fieldNames)];
+  console.log(
+    JSON.stringify(
+      formatError2(
+        "VALIDATION_ERROR" /* ValidationError */,
+        `Extraction failed for fields: ${uniqueFields.join(", ")}`
+      )
+    )
+  );
+  process.exit(1 /* ExtractionFailure */);
+}
+function resolveSourceFiles(resolvedConfig, configDir) {
+  const sourceFilePaths = resolvedConfig.modules.flatMap((module) => globSync(module.path, { cwd: configDir })).map((filePath) => resolve3(configDir, filePath));
+  if (sourceFilePaths.length === 0) {
+    const patterns = resolvedConfig.modules.map((m) => m.path).join(", ");
+    exitWithConfigValidation(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `No files matched extraction patterns: ${patterns}
 Config directory: ${configDir}`
-          )
-        )
+    );
+  }
+  return sourceFilePaths;
+}
+function loadAndValidateConfig(configPath) {
+  if (!existsSync4(configPath)) {
+    exitWithConfigValidation("CONFIG_NOT_FOUND" /* ConfigNotFound */, `Config file not found: ${configPath}`);
+  }
+  const content = readFileSync4(configPath, "utf-8");
+  const parseResult = parseConfigFile(content);
+  if (!parseResult.success) {
+    exitWithConfigValidation(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `Invalid config file: ${parseResult.error}`
+    );
+  }
+  const configDir = dirname3(resolve3(configPath));
+  const expansionResult = tryExpandModuleRefs(parseResult.data, configDir);
+  if (!expansionResult.success) {
+    exitWithConfigValidation(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `Error expanding module references: ${expansionResult.error}`
+    );
+  }
+  if (!isValidExtractionConfig(expansionResult.data)) {
+    const validationResult = validateExtractionConfig(expansionResult.data);
+    exitWithConfigValidation(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `Invalid extraction config:
+${formatValidationErrors2(validationResult.errors)}`
+    );
+  }
+  return {
+    resolvedConfig: resolveConfig(expansionResult.data, createConfigLoader(configDir)),
+    configDir
+  };
+}
+function createExtractCommand() {
+  return new Command21("extract").description("Extract architectural components from source code").requiredOption("--config <path>", "Path to extraction config file").option("--dry-run", "Show component counts per domain without full output").option("-o, --output <file>", "Write output to file instead of stdout").option("--components-only", "Output only component identity (no metadata enrichment)").option("--enrich <file>", "Read draft components from file and enrich with extraction rules").option("--allow-incomplete", "Output components even when some extraction fields fail").action((options) => {
+    if (options.componentsOnly && options.enrich !== void 0) {
+      exitWithConfigValidation(
+        "VALIDATION_ERROR" /* ValidationError */,
+        "--components-only and --enrich cannot be used together"
       );
-      process.exit(1);
     }
-    const project = new Project();
-    project.addSourceFilesAtPaths(sourceFilePaths);
-    const components = extractComponents(
-      project,
-      sourceFilePaths,
+    const {
       resolvedConfig,
-      matchesGlob,
       configDir
-    );
+    } = loadAndValidateConfig(options.config);
+    const sourceFilePaths = resolveSourceFiles(resolvedConfig, configDir);
+    const project = new Project();
+    project.addSourceFilesAtPaths(sourceFilePaths);
+    const draftComponents = (() => {
+      if (options.enrich === void 0) {
+        return extractComponents(project, sourceFilePaths, resolvedConfig, matchesGlob, configDir);
+      }
+      try {
+        return loadDraftComponentsFromFile(options.enrich);
+      } catch (error48) {
+        if (error48 instanceof DraftComponentLoadError) {
+          exitWithRuntimeError(error48.message);
+        }
+        throw error48;
+      }
+    })();
     if (options.dryRun) {
-      const lines = formatDryRunOutput(components);
+      const lines = formatDryRunOutput(draftComponents);
       for (const line of lines) {
         console.log(line);
       }
       return;
     }
-    console.log(JSON.stringify(formatSuccess(components)));
+    if (options.componentsOnly) {
+      outputResult(formatSuccess(draftComponents), options);
+      return;
+    }
+    const enrichmentResult = enrichComponents(
+      draftComponents,
+      resolvedConfig,
+      project,
+      matchesGlob,
+      configDir
+    );
+    const hasFailures = enrichmentResult.failures.length > 0;
+    if (hasFailures && options.allowIncomplete === true) {
+      outputResult(formatSuccess(enrichmentResult.components), options);
+      return;
+    }
+    if (hasFailures) {
+      exitWithExtractionFailure(enrichmentResult.failures.map((f) => f.field));
+    }
+    outputResult(formatSuccess(enrichmentResult.components), options);
   });
 }
 
@@ -28005,7 +28432,7 @@ function parsePackageJson(pkg) {
 }
 function loadPackageJson() {
   if (true) {
-    return { version: "0.7.30" };
+    return { version: "0.8.0" };
   }
   const require2 = createRequire2(import.meta.url);
   return parsePackageJson(require2("../../package.json"));
@@ -28056,9 +28483,13 @@ program.parseAsync().catch((error48) => {
 /* istanbul ignore if -- @preserve: unreachable with typed ResolvedExtractionConfig; defensive guard */
 /* istanbul ignore else -- @preserve: false branch is unreachable; FindTarget is exhaustive */
 /* istanbul ignore next -- @preserve: unreachable with valid FindTarget type; defensive fallback */
+/* istanbul ignore next -- @preserve: only fromProperty reaches here; defensive guard */
+/* istanbul ignore next -- @preserve: catch always receives Error instances from ExtractionError */
 /* v8 ignore next -- @preserve defensive for non-Error throws */
 /* 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 next -- @preserve: yaml library always throws Error instances; defensive guard */
 /* v8 ignore next -- @preserve: error is always Error from yaml parser; defensive guard */
+/* v8 ignore start -- @preserve: called from DraftComponentLoadError catch; validation logic tested in draft-component-loader.spec.ts */
+/* v8 ignore start -- @preserve: DraftComponentLoadError handling; validation tested in draft-component-loader.spec.ts */
 /* v8 ignore start -- @preserve: dry-run path tested via CLI integration */

package/dist/index.js

@@ -23534,6 +23534,12 @@ async function fileExists(path2) {
 }
 
 // src/platform/infra/cli-presentation/error-codes.ts
+var ExitCode = /* @__PURE__ */ ((ExitCode2) => {
+  ExitCode2[ExitCode2["ExtractionFailure"] = 1] = "ExtractionFailure";
+  ExitCode2[ExitCode2["ConfigValidation"] = 2] = "ConfigValidation";
+  ExitCode2[ExitCode2["RuntimeError"] = 3] = "RuntimeError";
+  return ExitCode2;
+})(ExitCode || {});
 var CliErrorCode = /* @__PURE__ */ ((CliErrorCode3) => {
   CliErrorCode3["GraphNotFound"] = "GRAPH_NOT_FOUND";
   CliErrorCode3["ComponentNotFound"] = "COMPONENT_NOT_FOUND";
@@ -25092,8 +25098,9 @@ Examples:
 
 // src/features/extract/entrypoint/extract.ts
 import {
-  existsSync as existsSync3,
-  readFileSync as readFileSync3
+  existsSync as existsSync4,
+  readFileSync as readFileSync4,
+  writeFileSync
 } from "node:fs";
 import {
   dirname as dirname3,
@@ -26170,14 +26177,192 @@ function requireRule(rule, ruleName, moduleName) {
   return rule;
 }
 
+// ../riviere-extract-ts/dist/platform/domain/string-transforms/transforms.js
+function stripSuffix(value, suffix) {
+  if (value.endsWith(suffix)) {
+    return value.slice(0, -suffix.length);
+  }
+  return value;
+}
+function stripPrefix(value, prefix) {
+  if (value.startsWith(prefix)) {
+    return value.slice(prefix.length);
+  }
+  return value;
+}
+function toLowerCase(value) {
+  return value.toLowerCase();
+}
+function toUpperCase(value) {
+  return value.toUpperCase();
+}
+function kebabToPascal(value) {
+  return value.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function pascalToKebab(value) {
+  const transformed = value.replaceAll(/([A-Z])/g, "-$1").toLowerCase();
+  return transformed.startsWith("-") ? transformed.slice(1) : transformed;
+}
+function applyTransforms(value, transform2) {
+  const transformers = [];
+  if (transform2.stripSuffix !== void 0) {
+    const suffix = transform2.stripSuffix;
+    transformers.push((v) => stripSuffix(v, suffix));
+  }
+  if (transform2.stripPrefix !== void 0) {
+    const prefix = transform2.stripPrefix;
+    transformers.push((v) => stripPrefix(v, prefix));
+  }
+  if (transform2.toLowerCase === true) {
+    transformers.push(toLowerCase);
+  }
+  if (transform2.toUpperCase === true) {
+    transformers.push(toUpperCase);
+  }
+  if (transform2.kebabToPascal === true) {
+    transformers.push(kebabToPascal);
+  }
+  if (transform2.pascalToKebab === true) {
+    transformers.push(pascalToKebab);
+  }
+  return transformers.reduce((acc, fn) => fn(acc), value);
+}
+
 // ../riviere-extract-ts/dist/platform/domain/ast-literals/literal-detection.js
 import { SyntaxKind } from "ts-morph";
+var ExtractionError = class extends Error {
+  location;
+  constructor(message, file2, line) {
+    super(`${message} at ${file2}:${line}`);
+    this.name = "ExtractionError";
+    this.location = {
+      file: file2,
+      line
+    };
+  }
+};
+function extractString(expression) {
+  return expression.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralValue();
+}
+function extractNumber(expression) {
+  return Number(expression.getText());
+}
+function buildExtractionResult(expression) {
+  const syntaxKind = expression.getKind();
+  switch (syntaxKind) {
+    case SyntaxKind.StringLiteral:
+      return {
+        kind: "string",
+        value: extractString(expression)
+      };
+    case SyntaxKind.NumericLiteral:
+      return {
+        kind: "number",
+        value: extractNumber(expression)
+      };
+    case SyntaxKind.TrueKeyword:
+      return {
+        kind: "boolean",
+        value: true
+      };
+    case SyntaxKind.FalseKeyword:
+      return {
+        kind: "boolean",
+        value: false
+      };
+    default:
+      return void 0;
+  }
+}
+function throwMissingInitializer(file2, line) {
+  throw new ExtractionError("No initializer found", file2, line);
+}
+function throwNonLiteralValue(expression, file2, line) {
+  throw new ExtractionError(`Non-literal value detected (${expression.getKindName()}): ${expression.getText()}. Only inline literals (strings, numbers, booleans) are supported`, file2, line);
+}
+function extractLiteralValue(expression, file2, line) {
+  if (expression === void 0) {
+    throwMissingInitializer(file2, line);
+  }
+  const result = buildExtractionResult(expression);
+  if (result === void 0) {
+    throwNonLiteralValue(expression, file2, line);
+  }
+  return result;
+}
 
 // ../riviere-extract-ts/dist/domain/value-extraction/evaluate-extraction-rule-generic.js
 import { SyntaxKind as SyntaxKind2 } from "ts-morph";
 
 // ../riviere-extract-ts/dist/domain/value-extraction/evaluate-extraction-rule.js
 import { SyntaxKind as SyntaxKind3 } from "ts-morph";
+function literal2(value) {
+  return { value };
+}
+function evaluateLiteralRule(rule) {
+  return literal2(rule.literal);
+}
+function evaluateFromClassNameRule(rule, classDecl) {
+  const className = classDecl.getName() ?? "";
+  if (rule.fromClassName === true) {
+    return { value: className };
+  }
+  const transform2 = rule.fromClassName.transform;
+  if (transform2 === void 0) {
+    return { value: className };
+  }
+  return { value: applyTransforms(className, transform2) };
+}
+function evaluateFromFilePathRule(rule, filePath) {
+  const { pattern, capture, transform: transform2 } = rule.fromFilePath;
+  const regex = new RegExp(pattern);
+  const match2 = regex.exec(filePath);
+  if (match2 === null) {
+    throw new ExtractionError(`Pattern '${pattern}' did not match file path '${filePath}'`, filePath, 0);
+  }
+  const capturedValue = match2[capture];
+  if (capturedValue === void 0) {
+    throw new ExtractionError(`Capture group ${capture} out of bounds. Pattern has ${match2.length - 1} capture groups`, filePath, 0);
+  }
+  if (transform2 === void 0) {
+    return { value: capturedValue };
+  }
+  return { value: applyTransforms(capturedValue, transform2) };
+}
+function findPropertyInHierarchy(classDecl, propertyName, isStatic) {
+  const properties = isStatic ? classDecl.getStaticProperties() : classDecl.getInstanceProperties();
+  const property = properties.find((p) => p.getName() === propertyName);
+  if (property !== void 0 && "getInitializer" in property) {
+    const sourceFile = classDecl.getSourceFile();
+    return {
+      initializer: property.getInitializer(),
+      filePath: sourceFile.getFilePath(),
+      line: property.getStartLineNumber()
+    };
+  }
+  const baseClass = classDecl.getBaseClass();
+  if (baseClass === void 0) {
+    return void 0;
+  }
+  return findPropertyInHierarchy(baseClass, propertyName, isStatic);
+}
+function evaluateFromPropertyRule(rule, classDecl) {
+  const { name, kind, transform: transform2 } = rule.fromProperty;
+  const isStatic = kind === "static";
+  const propertyInfo = findPropertyInHierarchy(classDecl, name, isStatic);
+  if (propertyInfo === void 0) {
+    const sourceFile = classDecl.getSourceFile();
+    throw new ExtractionError(`Property '${name}' not found on class '${classDecl.getName() ?? "anonymous"}'`, sourceFile.getFilePath(), classDecl.getStartLineNumber());
+  }
+  const literalResult = extractLiteralValue(propertyInfo.initializer, propertyInfo.filePath, propertyInfo.line);
+  if (transform2 === void 0) {
+    return { value: literalResult.value };
+  }
+  if (typeof literalResult.value !== "string") {
+    return { value: literalResult.value };
+  }
+  return { value: applyTransforms(literalResult.value, transform2) };
+}
 
 // ../../node_modules/.pnpm/@isaacs+balanced-match@4.0.1/node_modules/@isaacs/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -27736,6 +27921,158 @@ function matchesGlob(path2, pattern) {
   return minimatch(path2, pattern);
 }
 
+// ../riviere-extract-ts/dist/domain/value-extraction/enrich-components.js
+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));
+}
+function isDetectionRule2(rule) {
+  if (typeof rule !== "object" || rule === null) {
+    return false;
+  }
+  return "find" in rule && "where" in rule;
+}
+function getBuiltInRule(module, componentType) {
+  const ruleMap = {
+    api: module.api,
+    useCase: module.useCase,
+    domainOp: module.domainOp,
+    event: module.event,
+    eventHandler: module.eventHandler,
+    ui: module.ui
+  };
+  const rule = ruleMap[componentType];
+  if (isDetectionRule2(rule)) {
+    return rule;
+  }
+  return void 0;
+}
+function findDetectionRule(module, componentType) {
+  const builtInTypes = [
+    "api",
+    "useCase",
+    "domainOp",
+    "event",
+    "eventHandler",
+    "ui"
+  ];
+  if (builtInTypes.includes(componentType)) {
+    return getBuiltInRule(module, componentType);
+  }
+  return module.customTypes?.[componentType];
+}
+function isLiteralRule(rule) {
+  return "literal" in rule;
+}
+function isFromClassNameRule(rule) {
+  return "fromClassName" in rule;
+}
+function isFromFilePathRule(rule) {
+  return "fromFilePath" in rule;
+}
+function isFromPropertyRule(rule) {
+  return "fromProperty" in rule;
+}
+function findClassAtLine(project, draft) {
+  const sourceFile = project.getSourceFile(draft.location.file);
+  if (sourceFile === void 0) {
+    throw new ExtractionError(`Source file '${draft.location.file}' not found in project`, draft.location.file, draft.location.line);
+  }
+  const classDecl = sourceFile.getClasses().find((c) => c.getStartLineNumber() === draft.location.line);
+  if (classDecl === void 0) {
+    throw new ExtractionError(`No class declaration found at line ${draft.location.line}`, draft.location.file, draft.location.line);
+  }
+  return classDecl;
+}
+function evaluateClassRule(rule, classDecl) {
+  if (isFromClassNameRule(rule)) {
+    return evaluateFromClassNameRule(rule, classDecl);
+  }
+  if (!isFromPropertyRule(rule)) {
+    throw new ExtractionError("Unsupported extraction rule type for class-based component", classDecl.getSourceFile().getFilePath(), classDecl.getStartLineNumber());
+  }
+  return evaluateFromPropertyRule(rule, classDecl);
+}
+function evaluateRule(rule, draft, project) {
+  if (isLiteralRule(rule)) {
+    return evaluateLiteralRule(rule);
+  }
+  if (isFromFilePathRule(rule)) {
+    return evaluateFromFilePathRule(rule, draft.location.file);
+  }
+  const classDecl = findClassAtLine(project, draft);
+  return evaluateClassRule(rule, classDecl);
+}
+function componentWithEmptyMetadata(draft) {
+  return {
+    enriched: {
+      ...draft,
+      metadata: {}
+    },
+    failures: []
+  };
+}
+function extractMetadataFields(extractBlock, draft, project) {
+  const metadata = {};
+  const missing = [];
+  const failures = [];
+  for (const [fieldName, extractionRule] of Object.entries(extractBlock)) {
+    try {
+      metadata[fieldName] = evaluateRule(extractionRule, draft, project).value;
+    } catch (error48) {
+      const errorMessage = error48 instanceof Error ? error48.message : String(error48);
+      failures.push({
+        component: draft,
+        field: fieldName,
+        error: errorMessage
+      });
+      missing.push(fieldName);
+    }
+  }
+  return {
+    metadata,
+    missing,
+    failures
+  };
+}
+function enrichSingleComponent(draft, config2, project, globMatcher, configDir) {
+  const module = findMatchingModule2(draft.location.file, config2.modules, globMatcher, configDir);
+  if (module === void 0) {
+    return componentWithEmptyMetadata(draft);
+  }
+  const detectionRule = findDetectionRule(module, draft.type);
+  if (detectionRule?.extract === void 0) {
+    return componentWithEmptyMetadata(draft);
+  }
+  const extracted = extractMetadataFields(detectionRule.extract, draft, project);
+  const enriched = {
+    ...draft,
+    metadata: extracted.metadata
+  };
+  if (extracted.missing.length > 0) {
+    enriched._missing = extracted.missing;
+  }
+  return {
+    enriched,
+    failures: extracted.failures
+  };
+}
+function enrichComponents(draftComponents, config2, project, globMatcher, configDir) {
+  const allComponents = [];
+  const allFailures = [];
+  for (const draft of draftComponents) {
+    const result = enrichSingleComponent(draft, config2, project, globMatcher, configDir);
+    allComponents.push(result.enriched);
+    allFailures.push(...result.failures);
+  }
+  return {
+    components: allComponents,
+    failures: allFailures
+  };
+}
+
 // src/features/extract/commands/config-loader.ts
 import {
   dirname as dirname2,
@@ -27867,6 +28204,44 @@ function expandModuleRefs(config2, configDir) {
   };
 }
 
+// src/features/extract/commands/draft-component-loader.ts
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync3
+} from "node:fs";
+var DraftComponentLoadError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DraftComponentLoadError";
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+};
+function isDraftComponentArray(value) {
+  if (!Array.isArray(value)) return false;
+  return value.every(
+    (item) => typeof item === "object" && item !== null && "type" in item && "name" in item && "domain" in item && "location" in item
+  );
+}
+function parseJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync3(filePath, "utf-8"));
+  } catch {
+    throw new DraftComponentLoadError(`Enrich file contains invalid JSON: ${filePath}`);
+  }
+}
+function loadDraftComponentsFromFile(filePath) {
+  if (!existsSync3(filePath)) {
+    throw new DraftComponentLoadError(`Enrich file not found: ${filePath}`);
+  }
+  const parsed = parseJsonFile(filePath);
+  if (!isDraftComponentArray(parsed)) {
+    throw new DraftComponentLoadError(
+      `Enrich file does not contain valid draft components: ${filePath}`
+    );
+  }
+  return parsed;
+}
+
 // src/features/extract/entrypoint/extract.ts
 function compareByCodePoint2(a, b) {
   if (a < b) return -1;
@@ -27926,87 +28301,145 @@ function tryExpandModuleRefs(data, configDir) {
     };
   }
 }
-function createExtractCommand() {
-  return new Command21("extract").description("Extract architectural components from source code").requiredOption("--config <path>", "Path to extraction config file").option("--dry-run", "Show component counts per domain without full output").action((options) => {
-    if (!existsSync3(options.config)) {
-      console.log(
-        JSON.stringify(
-          formatError2("CONFIG_NOT_FOUND" /* ConfigNotFound */, `Config file not found: ${options.config}`)
-        )
-      );
-      process.exit(1);
-    }
-    const content = readFileSync3(options.config, "utf-8");
-    const parseResult = parseConfigFile(content);
-    if (!parseResult.success) {
-      console.log(
-        JSON.stringify(
-          formatError2("VALIDATION_ERROR" /* ValidationError */, `Invalid config file: ${parseResult.error}`)
-        )
-      );
-      process.exit(1);
-    }
-    const configDir = dirname3(resolve3(options.config));
-    const expansionResult = tryExpandModuleRefs(parseResult.data, configDir);
-    if (!expansionResult.success) {
+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 */,
-            `Error expanding module references: ${expansionResult.error}`
+            "Failed to write output file: " + options.output
           )
         )
       );
-      process.exit(1);
+      process.exit(3 /* RuntimeError */);
     }
-    const expandedData = expansionResult.data;
-    if (!isValidExtractionConfig(expandedData)) {
-      const validationResult = validateExtractionConfig(expandedData);
-      console.log(
-        JSON.stringify(
-          formatError2(
-            "VALIDATION_ERROR" /* ValidationError */,
-            `Invalid extraction config:
-${formatValidationErrors2(validationResult.errors)}`
-          )
-        )
-      );
-      process.exit(1);
-    }
-    const unresolvedConfig = expandedData;
-    const configLoader = createConfigLoader(configDir);
-    const resolvedConfig = resolveConfig(unresolvedConfig, configLoader);
-    const sourceFilePaths = resolvedConfig.modules.flatMap((module) => globSync(module.path, { cwd: configDir })).map((filePath) => resolve3(configDir, filePath));
-    if (sourceFilePaths.length === 0) {
-      const patterns = resolvedConfig.modules.map((m) => m.path).join(", ");
-      console.log(
-        JSON.stringify(
-          formatError2(
-            "VALIDATION_ERROR" /* ValidationError */,
-            `No files matched extraction patterns: ${patterns}
+    return;
+  }
+  console.log(JSON.stringify(data));
+}
+function exitWithRuntimeError(message) {
+  console.log(JSON.stringify(formatError2("VALIDATION_ERROR" /* ValidationError */, message)));
+  process.exit(3 /* RuntimeError */);
+}
+function exitWithConfigValidation(code, message) {
+  console.log(JSON.stringify(formatError2(code, message)));
+  process.exit(2 /* ConfigValidation */);
+}
+function exitWithExtractionFailure(fieldNames) {
+  const uniqueFields = [...new Set(fieldNames)];
+  console.log(
+    JSON.stringify(
+      formatError2(
+        "VALIDATION_ERROR" /* ValidationError */,
+        `Extraction failed for fields: ${uniqueFields.join(", ")}`
+      )
+    )
+  );
+  process.exit(1 /* ExtractionFailure */);
+}
+function resolveSourceFiles(resolvedConfig, configDir) {
+  const sourceFilePaths = resolvedConfig.modules.flatMap((module) => globSync(module.path, { cwd: configDir })).map((filePath) => resolve3(configDir, filePath));
+  if (sourceFilePaths.length === 0) {
+    const patterns = resolvedConfig.modules.map((m) => m.path).join(", ");
+    exitWithConfigValidation(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `No files matched extraction patterns: ${patterns}
 Config directory: ${configDir}`
-          )
-        )
+    );
+  }
+  return sourceFilePaths;
+}
+function loadAndValidateConfig(configPath) {
+  if (!existsSync4(configPath)) {
+    exitWithConfigValidation("CONFIG_NOT_FOUND" /* ConfigNotFound */, `Config file not found: ${configPath}`);
+  }
+  const content = readFileSync4(configPath, "utf-8");
+  const parseResult = parseConfigFile(content);
+  if (!parseResult.success) {
+    exitWithConfigValidation(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `Invalid config file: ${parseResult.error}`
+    );
+  }
+  const configDir = dirname3(resolve3(configPath));
+  const expansionResult = tryExpandModuleRefs(parseResult.data, configDir);
+  if (!expansionResult.success) {
+    exitWithConfigValidation(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `Error expanding module references: ${expansionResult.error}`
+    );
+  }
+  if (!isValidExtractionConfig(expansionResult.data)) {
+    const validationResult = validateExtractionConfig(expansionResult.data);
+    exitWithConfigValidation(
+      "VALIDATION_ERROR" /* ValidationError */,
+      `Invalid extraction config:
+${formatValidationErrors2(validationResult.errors)}`
+    );
+  }
+  return {
+    resolvedConfig: resolveConfig(expansionResult.data, createConfigLoader(configDir)),
+    configDir
+  };
+}
+function createExtractCommand() {
+  return new Command21("extract").description("Extract architectural components from source code").requiredOption("--config <path>", "Path to extraction config file").option("--dry-run", "Show component counts per domain without full output").option("-o, --output <file>", "Write output to file instead of stdout").option("--components-only", "Output only component identity (no metadata enrichment)").option("--enrich <file>", "Read draft components from file and enrich with extraction rules").option("--allow-incomplete", "Output components even when some extraction fields fail").action((options) => {
+    if (options.componentsOnly && options.enrich !== void 0) {
+      exitWithConfigValidation(
+        "VALIDATION_ERROR" /* ValidationError */,
+        "--components-only and --enrich cannot be used together"
       );
-      process.exit(1);
     }
-    const project = new Project();
-    project.addSourceFilesAtPaths(sourceFilePaths);
-    const components = extractComponents(
-      project,
-      sourceFilePaths,
+    const {
       resolvedConfig,
-      matchesGlob,
       configDir
-    );
+    } = loadAndValidateConfig(options.config);
+    const sourceFilePaths = resolveSourceFiles(resolvedConfig, configDir);
+    const project = new Project();
+    project.addSourceFilesAtPaths(sourceFilePaths);
+    const draftComponents = (() => {
+      if (options.enrich === void 0) {
+        return extractComponents(project, sourceFilePaths, resolvedConfig, matchesGlob, configDir);
+      }
+      try {
+        return loadDraftComponentsFromFile(options.enrich);
+      } catch (error48) {
+        if (error48 instanceof DraftComponentLoadError) {
+          exitWithRuntimeError(error48.message);
+        }
+        throw error48;
+      }
+    })();
     if (options.dryRun) {
-      const lines = formatDryRunOutput(components);
+      const lines = formatDryRunOutput(draftComponents);
       for (const line of lines) {
         console.log(line);
       }
       return;
     }
-    console.log(JSON.stringify(formatSuccess(components)));
+    if (options.componentsOnly) {
+      outputResult(formatSuccess(draftComponents), options);
+      return;
+    }
+    const enrichmentResult = enrichComponents(
+      draftComponents,
+      resolvedConfig,
+      project,
+      matchesGlob,
+      configDir
+    );
+    const hasFailures = enrichmentResult.failures.length > 0;
+    if (hasFailures && options.allowIncomplete === true) {
+      outputResult(formatSuccess(enrichmentResult.components), options);
+      return;
+    }
+    if (hasFailures) {
+      exitWithExtractionFailure(enrichmentResult.failures.map((f) => f.field));
+    }
+    outputResult(formatSuccess(enrichmentResult.components), options);
   });
 }
 
@@ -28058,6 +28491,7 @@ function createProgram() {
 }
 export {
   CliErrorCode,
+  ExitCode,
   createProgram,
   formatError2 as formatError,
   formatSuccess,
@@ -28073,9 +28507,13 @@ export {
 /* istanbul ignore if -- @preserve: unreachable with typed ResolvedExtractionConfig; defensive guard */
 /* istanbul ignore else -- @preserve: false branch is unreachable; FindTarget is exhaustive */
 /* istanbul ignore next -- @preserve: unreachable with valid FindTarget type; defensive fallback */
+/* istanbul ignore next -- @preserve: only fromProperty reaches here; defensive guard */
+/* istanbul ignore next -- @preserve: catch always receives Error instances from ExtractionError */
 /* v8 ignore next -- @preserve defensive for non-Error throws */
 /* 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 next -- @preserve: yaml library always throws Error instances; defensive guard */
 /* v8 ignore next -- @preserve: error is always Error from yaml parser; defensive guard */
+/* v8 ignore start -- @preserve: called from DraftComponentLoadError catch; validation logic tested in draft-component-loader.spec.ts */
+/* v8 ignore start -- @preserve: DraftComponentLoadError handling; validation tested in draft-component-loader.spec.ts */
 /* v8 ignore start -- @preserve: dry-run path tested via CLI integration */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@living-architecture/riviere-cli",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "publishConfig": {
     "access": "public"
   },
@@ -32,10 +32,10 @@
     "glob": "^11.0.2",
     "ts-morph": "^24.0.0",
     "yaml": "^2.7.0",
-    "@living-architecture/riviere-builder": "0.6.0",
-    "@living-architecture/riviere-extract-config": "0.4.0",
-    "@living-architecture/riviere-extract-ts": "0.2.0",
-    "@living-architecture/riviere-schema": "0.5.0",
-    "@living-architecture/riviere-query": "0.5.0"
+    "@living-architecture/riviere-builder": "0.6.1",
+    "@living-architecture/riviere-extract-config": "0.4.1",
+    "@living-architecture/riviere-extract-ts": "0.2.1",
+    "@living-architecture/riviere-query": "0.5.1",
+    "@living-architecture/riviere-schema": "0.5.1"
   }
 }