@living-architecture/riviere-cli 0.2.1

package/dist/commands/builder/add-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-source.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/add-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,wBAAgB,sBAAsB,IAAI,OAAO,CA+BhD"}

package/dist/commands/builder/add-source.js

@@ -0,0 +1,28 @@
+import { Command } from 'commander';
+import { writeFile } from 'node:fs/promises';
+import { formatSuccess } from '../../output';
+import { getDefaultGraphPathDescription } from '../../graph-path';
+import { withGraphBuilder } from './link-infrastructure';
+export function createAddSourceCommand() {
+    return new Command('add-source')
+        .description('Add a source repository to the graph')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder add-source --repository https://github.com/org/orders-service
+  $ riviere builder add-source --repository https://github.com/org/payments-api --json
+`)
+        .requiredOption('--repository <url>', 'Source repository URL')
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--json', 'Output result as JSON')
+        .action(async (options) => {
+        await withGraphBuilder(options.graph, async (builder, graphPath) => {
+            builder.addSource({ repository: options.repository });
+            await writeFile(graphPath, builder.serialize(), 'utf-8');
+            if (options.json === true) {
+                console.log(JSON.stringify(formatSuccess({
+                    repository: options.repository,
+                })));
+            }
+        });
+    });
+}

package/dist/commands/builder/check-consistency.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createCheckConsistencyCommand(): Command;
+//# sourceMappingURL=check-consistency.d.ts.map

package/dist/commands/builder/check-consistency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-consistency.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/check-consistency.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC,wBAAgB,6BAA6B,IAAI,OAAO,CA8BvD"}

package/dist/commands/builder/check-consistency.js

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+import { getDefaultGraphPathDescription } from '../../graph-path';
+import { formatSuccess } from '../../output';
+import { withGraphBuilder } from './link-infrastructure';
+export function createCheckConsistencyCommand() {
+    return new Command('check-consistency')
+        .description('Check for structural issues in the graph')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder check-consistency
+  $ riviere builder check-consistency --json
+`)
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--json', 'Output result as JSON')
+        .action(async (options) => {
+        await withGraphBuilder(options.graph, async (builder) => {
+            const warnings = builder.warnings();
+            const consistent = warnings.length === 0;
+            if (options.json === true) {
+                console.log(JSON.stringify(formatSuccess({
+                    consistent,
+                    warnings,
+                })));
+            }
+        });
+    });
+}

package/dist/commands/builder/component-checklist.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createComponentChecklistCommand(): Command;
+//# sourceMappingURL=component-checklist.d.ts.map

package/dist/commands/builder/component-checklist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-checklist.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/component-checklist.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,+BAA+B,IAAI,OAAO,CAmDzD"}

package/dist/commands/builder/component-checklist.js

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { getDefaultGraphPathDescription } from '../../graph-path';
+import { formatError, formatSuccess } from '../../output';
+import { CliErrorCode } from '../../error-codes';
+import { isValidComponentType } from '../../component-types';
+import { withGraphBuilder } from './link-infrastructure';
+export function createComponentChecklistCommand() {
+    return new Command('component-checklist')
+        .description('List components as a checklist for linking/enrichment')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder component-checklist
+  $ riviere builder component-checklist --type DomainOp
+  $ riviere builder component-checklist --type API --json
+`)
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--json', 'Output result as JSON')
+        .option('--type <type>', 'Filter by component type')
+        .action(async (options) => {
+        if (options.type !== undefined && !isValidComponentType(options.type)) {
+            console.log(JSON.stringify(formatError(CliErrorCode.InvalidComponentType, `Invalid component type: ${options.type}`, [
+                'Valid types: UI, API, UseCase, DomainOp, Event, EventHandler, Custom',
+            ])));
+            return;
+        }
+        await withGraphBuilder(options.graph, async (builder) => {
+            const allComponents = builder.query().components();
+            const filteredComponents = options.type !== undefined ? allComponents.filter((c) => c.type === options.type) : allComponents;
+            const checklistItems = filteredComponents.map((c) => ({
+                id: c.id,
+                type: c.type,
+                name: c.name,
+                domain: c.domain,
+            }));
+            if (options.json === true) {
+                console.log(JSON.stringify(formatSuccess({
+                    total: checklistItems.length,
+                    components: checklistItems,
+                })));
+            }
+        });
+    });
+}

package/dist/commands/builder/component-summary.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createComponentSummaryCommand(): Command;
+//# sourceMappingURL=component-summary.d.ts.map

package/dist/commands/builder/component-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-summary.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/component-summary.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC,wBAAgB,6BAA6B,IAAI,OAAO,CAsBvD"}

package/dist/commands/builder/component-summary.js

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { getDefaultGraphPathDescription } from '../../graph-path';
+import { formatSuccess } from '../../output';
+import { withGraphBuilder } from './link-infrastructure';
+export function createComponentSummaryCommand() {
+    return new Command('component-summary')
+        .description('Show component counts by type and domain')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder component-summary
+  $ riviere builder component-summary --json
+`)
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--json', 'Output result as JSON')
+        .action(async (options) => {
+        await withGraphBuilder(options.graph, async (builder) => {
+            const stats = builder.stats();
+            if (options.json === true) {
+                console.log(JSON.stringify(formatSuccess(stats)));
+            }
+        });
+    });
+}

package/dist/commands/builder/enrich.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createEnrichCommand(): Command;
+//# sourceMappingURL=enrich.d.ts.map

package/dist/commands/builder/enrich.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enrich.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/enrich.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoDpC,wBAAgB,mBAAmB,IAAI,OAAO,CAsD7C"}

package/dist/commands/builder/enrich.js

@@ -0,0 +1,85 @@
+import { Command } from 'commander';
+import { writeFile } from 'node:fs/promises';
+import { InvalidEnrichmentTargetError } from '@living-architecture/riviere-builder';
+import { withGraphBuilder, handleComponentNotFoundError } from './link-infrastructure';
+import { formatError, formatSuccess } from '../../output';
+import { CliErrorCode } from '../../error-codes';
+import { getDefaultGraphPathDescription } from '../../graph-path';
+function collectOption(value, previous) {
+    return [...previous, value];
+}
+function parseStateChange(input) {
+    const [from, to, ...rest] = input.split(':');
+    if (from === undefined || to === undefined || rest.length > 0) {
+        return undefined;
+    }
+    return { from, to };
+}
+function parseStateChanges(inputs) {
+    const stateChanges = [];
+    for (const sc of inputs) {
+        const parsed = parseStateChange(sc);
+        if (parsed === undefined) {
+            return { success: false, invalidInput: sc };
+        }
+        stateChanges.push(parsed);
+    }
+    return { success: true, stateChanges };
+}
+function handleEnrichmentError(error) {
+    if (error instanceof InvalidEnrichmentTargetError) {
+        console.log(JSON.stringify(formatError(CliErrorCode.InvalidComponentType, error.message, [])));
+        return;
+    }
+    handleComponentNotFoundError(error);
+}
+export function createEnrichCommand() {
+    return new Command('enrich')
+        .description('Enrich a DomainOp component with entity, state changes, and business rules')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder enrich \\
+      --id "orders:checkout:domainop:orderbegin" \\
+      --entity Order \\
+      --state-change "Draft:Placed" \\
+      --business-rule "Order must have at least one item"
+
+  $ riviere builder enrich \\
+      --id "payments:gateway:domainop:paymentprocess" \\
+      --state-change "Pending:Processing" \\
+      --state-change "Processing:Completed" \\
+      --business-rule "Amount must be positive" \\
+      --business-rule "Currency must be valid"
+`)
+        .requiredOption('--id <component-id>', 'Component ID to enrich')
+        .option('--entity <name>', 'Entity name')
+        .option('--state-change <from:to>', 'State transition (repeatable)', collectOption, [])
+        .option('--business-rule <rule>', 'Business rule (repeatable)', collectOption, [])
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--json', 'Output result as JSON')
+        .action(async (options) => {
+        const parseResult = parseStateChanges(options.stateChange);
+        if (!parseResult.success) {
+            const msg = `Invalid state-change format: '${parseResult.invalidInput}'. Expected 'from:to'.`;
+            console.log(JSON.stringify(formatError(CliErrorCode.ValidationError, msg, [])));
+            return;
+        }
+        await withGraphBuilder(options.graph, async (builder, graphPath) => {
+            try {
+                builder.enrichComponent(options.id, {
+                    ...(options.entity !== undefined && { entity: options.entity }),
+                    ...(parseResult.stateChanges.length > 0 && { stateChanges: parseResult.stateChanges }),
+                    ...(options.businessRule.length > 0 && { businessRules: options.businessRule }),
+                });
+            }
+            catch (error) {
+                handleEnrichmentError(error);
+                return;
+            }
+            await writeFile(graphPath, builder.serialize(), 'utf-8');
+            if (options.json === true) {
+                console.log(JSON.stringify(formatSuccess({ componentId: options.id })));
+            }
+        });
+    });
+}

package/dist/commands/builder/finalize.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createFinalizeCommand(): Command;
+//# sourceMappingURL=finalize.d.ts.map

package/dist/commands/builder/finalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/finalize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,qBAAqB,IAAI,OAAO,CAwC/C"}

package/dist/commands/builder/finalize.js

@@ -0,0 +1,37 @@
+import { Command } from 'commander';
+import { writeFile } from 'node:fs/promises';
+import { formatError, formatSuccess } from '../../output';
+import { CliErrorCode } from '../../error-codes';
+import { getDefaultGraphPathDescription } from '../../graph-path';
+import { withGraphBuilder } from './link-infrastructure';
+export function createFinalizeCommand() {
+    return new Command('finalize')
+        .description('Validate and export the final graph')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder finalize
+  $ riviere builder finalize --output ./dist/architecture.json
+  $ riviere builder finalize --json
+`)
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--output <path>', 'Output path for finalized graph (defaults to input path)')
+        .option('--json', 'Output result as JSON')
+        .action(async (options) => {
+        await withGraphBuilder(options.graph, async (builder, graphPath) => {
+            const validationResult = builder.validate();
+            if (!validationResult.valid) {
+                const messages = validationResult.errors.map((e) => e.message).join('; ');
+                console.log(JSON.stringify(formatError(CliErrorCode.ValidationError, `Validation failed: ${messages}`, [
+                    'Fix the validation errors and try again',
+                ])));
+                return;
+            }
+            const outputPath = options.output ?? graphPath;
+            const finalGraph = builder.build();
+            await writeFile(outputPath, JSON.stringify(finalGraph, null, 2), 'utf-8');
+            if (options.json === true) {
+                console.log(JSON.stringify(formatSuccess({ path: outputPath })));
+            }
+        });
+    });
+}

package/dist/commands/builder/init.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createInitCommand(): Command;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/builder/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqDpC,wBAAgB,iBAAiB,IAAI,OAAO,CAiG3C"}

package/dist/commands/builder/init.js

@@ -0,0 +1,100 @@
+import { Command } from 'commander';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { RiviereBuilder } from '@living-architecture/riviere-builder';
+import { formatError, formatSuccess } from '../../output';
+import { CliErrorCode } from '../../error-codes';
+import { fileExists } from '../../file-existence';
+import { resolveGraphPath, getDefaultGraphPathDescription } from '../../graph-path';
+import { isValidSystemType } from '../../component-types';
+function isDomainInputParsed(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    return ('name' in value &&
+        typeof value.name === 'string' &&
+        'description' in value &&
+        typeof value.description === 'string' &&
+        'systemType' in value &&
+        typeof value.systemType === 'string' &&
+        isValidSystemType(value.systemType));
+}
+function parseDomainJson(value, previous) {
+    const parsed = JSON.parse(value);
+    if (!isDomainInputParsed(parsed)) {
+        throw new Error(`Invalid domain JSON: ${value}`);
+    }
+    return [...previous, parsed];
+}
+function collectSource(value, previous) {
+    return [...previous, value];
+}
+export function createInitCommand() {
+    return new Command('init')
+        .description('Initialize a new graph')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder init --source https://github.com/org/repo \\
+      --domain '{"name":"orders","description":"Order management","systemType":"domain"}'
+
+  $ riviere builder init --name "ecommerce" \\
+      --source https://github.com/org/orders \\
+      --source https://github.com/org/payments \\
+      --domain '{"name":"orders","description":"Order management","systemType":"domain"}' \\
+      --domain '{"name":"payments","description":"Payment processing","systemType":"domain"}'
+`)
+        .option('--name <name>', 'System name')
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--json', 'Output result as JSON')
+        .option('--source <url>', 'Source repository URL (repeatable)', collectSource, [])
+        .option('--domain <json>', 'Domain as JSON (repeatable)', parseDomainJson, [])
+        .action(async (options) => {
+        // Validate required flags
+        if (options.source.length === 0) {
+            console.log(JSON.stringify(formatError(CliErrorCode.ValidationError, 'At least one source required', [
+                'Add --source <url> flag',
+            ])));
+            return;
+        }
+        if (options.domain.length === 0) {
+            console.log(JSON.stringify(formatError(CliErrorCode.ValidationError, 'At least one domain required', [
+                'Add --domain <json> flag',
+            ])));
+            return;
+        }
+        const graphPath = resolveGraphPath(options.graph);
+        const graphDir = dirname(graphPath);
+        const graphExists = await fileExists(graphPath);
+        if (graphExists) {
+            console.log(JSON.stringify(formatError(CliErrorCode.GraphExists, `Graph already exists at ${graphPath}`, [
+                'Delete the file to reinitialize',
+            ])));
+            return;
+        }
+        const domains = {};
+        for (const d of options.domain) {
+            domains[d.name] = {
+                description: d.description,
+                systemType: d.systemType,
+            };
+        }
+        const builderOptions = {
+            sources: options.source.map((url) => ({ repository: url })),
+            domains,
+        };
+        if (options.name !== undefined) {
+            builderOptions.name = options.name;
+        }
+        const builder = RiviereBuilder.new(builderOptions);
+        await mkdir(graphDir, { recursive: true });
+        await writeFile(graphPath, builder.serialize(), 'utf-8');
+        if (options.json === true) {
+            const domainNames = options.domain.map((d) => d.name);
+            console.log(JSON.stringify(formatSuccess({
+                path: graphPath,
+                sources: options.source.length,
+                domains: domainNames,
+            })));
+        }
+    });
+}

package/dist/commands/builder/link-external.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createLinkExternalCommand(): Command;
+//# sourceMappingURL=link-external.d.ts.map

package/dist/commands/builder/link-external.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-external.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/link-external.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkCpC,wBAAgB,yBAAyB,IAAI,OAAO,CAiEnD"}

package/dist/commands/builder/link-external.js

@@ -0,0 +1,70 @@
+import { Command } from 'commander';
+import { writeFile } from 'node:fs/promises';
+import { getDefaultGraphPathDescription, resolveGraphPath } from '../../graph-path';
+import { fileExists } from '../../file-existence';
+import { formatSuccess } from '../../output';
+import { isValidLinkType } from '../../component-types';
+import { validateLinkType } from '../../validation';
+import { loadGraphBuilder, reportGraphNotFound, tryBuilderOperation } from './link-infrastructure';
+function buildExternalTarget(options) {
+    return {
+        name: options.targetName,
+        ...(options.targetDomain && { domain: options.targetDomain }),
+        ...(options.targetUrl && { url: options.targetUrl }),
+    };
+}
+export function createLinkExternalCommand() {
+    return new Command('link-external')
+        .description('Link a component to an external system')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder link-external \\
+      --from "payments:gateway:usecase:processpayment" \\
+      --target-name "Stripe" \\
+      --target-url "https://api.stripe.com" \\
+      --link-type sync
+
+  $ riviere builder link-external \\
+      --from "shipping:tracking:usecase:updatetracking" \\
+      --target-name "FedEx API" \\
+      --target-domain "shipping" \\
+      --link-type async
+`)
+        .requiredOption('--from <component-id>', 'Source component ID')
+        .requiredOption('--target-name <name>', 'External target name')
+        .option('--target-domain <domain>', 'External target domain')
+        .option('--target-url <url>', 'External target URL')
+        .option('--link-type <type>', 'Link type (sync, async)')
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--json', 'Output result as JSON')
+        .action(async (options) => {
+        const linkTypeValidation = validateLinkType(options.linkType);
+        if (!linkTypeValidation.valid) {
+            console.log(linkTypeValidation.errorJson);
+            return;
+        }
+        const graphPath = resolveGraphPath(options.graph);
+        const graphExists = await fileExists(graphPath);
+        if (!graphExists) {
+            reportGraphNotFound(graphPath);
+            return;
+        }
+        const builder = await loadGraphBuilder(graphPath);
+        const target = buildExternalTarget(options);
+        const externalLinkInput = {
+            from: options.from,
+            target,
+        };
+        if (options.linkType !== undefined && isValidLinkType(options.linkType)) {
+            externalLinkInput.type = options.linkType;
+        }
+        const externalLink = tryBuilderOperation(() => builder.linkExternal(externalLinkInput));
+        if (externalLink === undefined) {
+            return;
+        }
+        await writeFile(graphPath, builder.serialize(), 'utf-8');
+        if (options.json) {
+            console.log(JSON.stringify(formatSuccess({ externalLink })));
+        }
+    });
+}

package/dist/commands/builder/link-http.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createLinkHttpCommand(): Command;
+//# sourceMappingURL=link-http.d.ts.map

package/dist/commands/builder/link-http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-http.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/link-http.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoGpC,wBAAgB,qBAAqB,IAAI,OAAO,CA+F/C"}

package/dist/commands/builder/link-http.js

@@ -0,0 +1,130 @@
+import { Command } from 'commander';
+import { writeFile } from 'node:fs/promises';
+import { ComponentId } from '@living-architecture/riviere-builder';
+import { RiviereQuery } from '@living-architecture/riviere-query';
+import { getDefaultGraphPathDescription, resolveGraphPath } from '../../graph-path';
+import { fileExists } from '../../file-existence';
+import { formatError, formatSuccess } from '../../output';
+import { CliErrorCode } from '../../error-codes';
+import { isValidLinkType, normalizeComponentType } from '../../component-types';
+import { isValidHttpMethod, validateComponentType, validateHttpMethod, validateLinkType } from '../../validation';
+import { loadGraphBuilder, reportGraphNotFound } from './link-infrastructure';
+function isRestApiWithPath(component) {
+    return component.type === 'API' && 'path' in component && 'httpMethod' in component;
+}
+function findApisByPath(graph, path, method) {
+    const query = new RiviereQuery(graph);
+    const allComponents = query.componentsByType('API');
+    const apis = allComponents.filter(isRestApiWithPath);
+    const matchingPath = apis.filter((api) => api.path === path);
+    if (method) {
+        return matchingPath.filter((api) => api.httpMethod === method);
+    }
+    return matchingPath;
+}
+function getAllApiPaths(graph) {
+    const query = new RiviereQuery(graph);
+    const allComponents = query.componentsByType('API');
+    const apis = allComponents.filter(isRestApiWithPath);
+    return [...new Set(apis.map((api) => api.path))];
+}
+function reportNoApiFoundForPath(path, availablePaths) {
+    console.log(JSON.stringify(formatError(CliErrorCode.ComponentNotFound, `No API found with path '${path}'`, availablePaths.length > 0 ? [`Available paths: ${availablePaths.join(', ')}`] : [])));
+}
+function reportAmbiguousApiMatch(path, matchingApis) {
+    const apiList = matchingApis.map((api) => `${api.id} (${api.httpMethod})`).join(', ');
+    console.log(JSON.stringify(formatError(CliErrorCode.AmbiguousApiMatch, `Multiple APIs match path '${path}': ${apiList}`, [
+        'Add --method flag to disambiguate',
+    ])));
+}
+function validateOptions(options) {
+    const componentTypeValidation = validateComponentType(options.toType);
+    if (!componentTypeValidation.valid) {
+        return componentTypeValidation.errorJson;
+    }
+    const httpMethodValidation = validateHttpMethod(options.method);
+    if (!httpMethodValidation.valid) {
+        return httpMethodValidation.errorJson;
+    }
+    const linkTypeValidation = validateLinkType(options.linkType);
+    if (!linkTypeValidation.valid) {
+        return linkTypeValidation.errorJson;
+    }
+    return undefined;
+}
+export function createLinkHttpCommand() {
+    return new Command('link-http')
+        .description('Find an API by HTTP path and link to a target component')
+        .addHelpText('after', `
+Examples:
+  $ riviere builder link-http \\
+      --path "/orders" --method POST \\
+      --to-domain orders --to-module checkout --to-type UseCase --to-name "place-order"
+
+  $ riviere builder link-http \\
+      --path "/users/{id}" --method GET \\
+      --to-domain users --to-module queries --to-type UseCase --to-name "get-user" \\
+      --link-type sync
+`)
+        .requiredOption('--path <http-path>', 'HTTP path to match')
+        .requiredOption('--to-domain <domain>', 'Target domain')
+        .requiredOption('--to-module <module>', 'Target module')
+        .requiredOption('--to-type <type>', 'Target component type')
+        .requiredOption('--to-name <name>', 'Target component name')
+        .option('--method <method>', 'Filter by HTTP method (GET, POST, PUT, PATCH, DELETE)')
+        .option('--link-type <type>', 'Link type (sync, async)')
+        .option('--graph <path>', getDefaultGraphPathDescription())
+        .option('--json', 'Output result as JSON')
+        .action(async (options) => {
+        const validationError = validateOptions(options);
+        if (validationError) {
+            console.log(validationError);
+            return;
+        }
+        const graphPath = resolveGraphPath(options.graph);
+        const graphExists = await fileExists(graphPath);
+        if (!graphExists) {
+            reportGraphNotFound(graphPath);
+            return;
+        }
+        const builder = await loadGraphBuilder(graphPath);
+        const graph = builder.build();
+        const normalizedMethod = options.method?.toUpperCase();
+        const httpMethod = normalizedMethod && isValidHttpMethod(normalizedMethod) ? normalizedMethod : undefined;
+        const matchingApis = findApisByPath(graph, options.path, httpMethod);
+        const [matchedApi, ...otherApis] = matchingApis;
+        if (!matchedApi) {
+            reportNoApiFoundForPath(options.path, getAllApiPaths(graph));
+            return;
+        }
+        if (otherApis.length > 0) {
+            reportAmbiguousApiMatch(options.path, matchingApis);
+            return;
+        }
+        const targetId = ComponentId.create({
+            domain: options.toDomain,
+            module: options.toModule,
+            type: normalizeComponentType(options.toType),
+            name: options.toName,
+        }).toString();
+        const linkInput = {
+            from: matchedApi.id,
+            to: targetId,
+        };
+        if (options.linkType !== undefined && isValidLinkType(options.linkType)) {
+            linkInput.type = options.linkType;
+        }
+        const link = builder.link(linkInput);
+        await writeFile(graphPath, builder.serialize(), 'utf-8');
+        if (options.json) {
+            console.log(JSON.stringify(formatSuccess({
+                link,
+                matchedApi: {
+                    id: matchedApi.id,
+                    path: matchedApi.path,
+                    method: matchedApi.httpMethod,
+                },
+            })));
+        }
+    });
+}

package/dist/commands/builder/link-infrastructure.d.ts

@@ -0,0 +1,7 @@
+import { RiviereBuilder } from '@living-architecture/riviere-builder';
+export declare function reportGraphNotFound(graphPath: string): void;
+export declare function loadGraphBuilder(graphPath: string): Promise<RiviereBuilder>;
+export declare function withGraphBuilder(graphPathOption: string | undefined, handler: (builder: RiviereBuilder, graphPath: string) => Promise<void>): Promise<void>;
+export declare function handleComponentNotFoundError(error: unknown): void;
+export declare function tryBuilderOperation<T>(operation: () => T): T | undefined;
+//# sourceMappingURL=link-infrastructure.d.ts.map

package/dist/commands/builder/link-infrastructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-infrastructure.d.ts","sourceRoot":"","sources":["../../../src/commands/builder/link-infrastructure.ts"],"names":[],"mappings":"AACA,OAAO,EAA0B,cAAc,EAAE,MAAM,sCAAsC,CAAC;AAO9F,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAM3D;AAED,wBAAsB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAKjF;AAED,wBAAsB,gBAAgB,CACpC,eAAe,EAAE,MAAM,GAAG,SAAS,EACnC,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GACrE,OAAO,CAAC,IAAI,CAAC,CAWf;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAKjE;AAED,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAOxE"}