@saptools/service-flow 0.1.44 → 0.1.45

package/dist/index.d.ts

@@ -121,6 +121,14 @@ interface TraceStart {
     operationPath?: string;
     handler?: string;
 }
+interface ImplementationHint {
+    servicePath?: string;
+    operationPath?: string;
+    packageName?: string;
+    repositoryName?: string;
+    candidateFamily?: string;
+    implementationRepo: string;
+}
 interface TraceEdge {
     step: number;
     type: string;
@@ -206,9 +214,12 @@ declare function trace(db: Db, start: TraceStart, options: {
     includeDb?: boolean;
     includeAsync?: boolean;
     implementationRepo?: string;
+    implementationHints?: ImplementationHint[];
 }): TraceResult;
 
+declare function parseImplementationHint(value: string): ImplementationHint;
+
 declare function redactText(text: string): string;
 declare function redactValue(value: unknown): unknown;
 
-export { type RuntimeSubstitution, applyVariables, discoverRepositories, extractPlaceholders, linkWorkspace, parseCdsFile, parseDecorators, parseGeneratedConstants, parseHandlerRegistrations, parseOutboundCalls, parsePackageJson, parseServiceBindings, redactText, redactValue, substituteVariables, trace };
+export { type ImplementationHint, type RuntimeSubstitution, applyVariables, discoverRepositories, extractPlaceholders, linkWorkspace, parseCdsFile, parseDecorators, parseGeneratedConstants, parseHandlerRegistrations, parseImplementationHint, parseOutboundCalls, parsePackageJson, parseServiceBindings, redactText, redactValue, substituteVariables, trace };

package/dist/index.js

@@ -8,6 +8,7 @@ import {
   parseCdsFile,
   parseDecorators,
   parseHandlerRegistrations,
+  parseImplementationHint,
   parseOutboundCalls,
   parsePackageJson,
   parseServiceBindings,
@@ -16,7 +17,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-UKNPHTUS.js";
+} from "./chunk-BXSCE5CR.js";
 
 // src/parsers/generated-constants-parser.ts
 import fs from "fs/promises";
@@ -46,6 +47,7 @@ export {
   parseDecorators,
   parseGeneratedConstants,
   parseHandlerRegistrations,
+  parseImplementationHint,
   parseOutboundCalls,
   parsePackageJson,
   parseServiceBindings,

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/parsers/generated-constants-parser.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\nimport type { GeneratedConstantFact } from '../types.js';\nimport { normalizePath, stripQuotes } from '../utils/path-utils.js';\nfunction lineOf(text: string, idx: number): number {\n  return text.slice(0, idx).split('\\n').length;\n}\nexport async function parseGeneratedConstants(\n  repoPath: string,\n  filePath: string\n): Promise<GeneratedConstantFact[]> {\n  const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');\n  return [\n    ...text.matchAll(\n      /(?:export\\s+)?(?:const|static\\s+readonly)\\s+(\\w+)\\s*=\\s*(['\"])([^'\"]+)\\2/g\n    )\n  ].map((m) => ({\n    name: m[1] ?? 'constant',\n    value: stripQuotes(m[3] ?? ''),\n    sourceFile: normalizePath(filePath),\n    sourceLine: lineOf(text, m.index ?? 0)\n  }));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ;AACf,OAAO,UAAU;AAGjB,SAAS,OAAO,MAAc,KAAqB;AACjD,SAAO,KAAK,MAAM,GAAG,GAAG,EAAE,MAAM,IAAI,EAAE;AACxC;AACA,eAAsB,wBACpB,UACA,UACkC;AAClC,QAAM,OAAO,MAAM,GAAG,SAAS,KAAK,KAAK,UAAU,QAAQ,GAAG,MAAM;AACpE,SAAO;AAAA,IACL,GAAG,KAAK;AAAA,MACN;AAAA,IACF;AAAA,EACF,EAAE,IAAI,CAAC,OAAO;AAAA,IACZ,MAAM,EAAE,CAAC,KAAK;AAAA,IACd,OAAO,YAAY,EAAE,CAAC,KAAK,EAAE;AAAA,IAC7B,YAAY,cAAc,QAAQ;AAAA,IAClC,YAAY,OAAO,MAAM,EAAE,SAAS,CAAC;AAAA,EACvC,EAAE;AACJ;","names":[]}
+{"version":3,"sources":["../src/parsers/generated-constants-parser.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\nimport type { GeneratedConstantFact } from '../types.js';\nimport { normalizePath, stripQuotes } from '../utils/path-utils.js';\nfunction lineOf(text: string, idx: number): number {\n  return text.slice(0, idx).split('\\n').length;\n}\nexport async function parseGeneratedConstants(\n  repoPath: string,\n  filePath: string\n): Promise<GeneratedConstantFact[]> {\n  const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');\n  return [\n    ...text.matchAll(\n      /(?:export\\s+)?(?:const|static\\s+readonly)\\s+(\\w+)\\s*=\\s*(['\"])([^'\"]+)\\2/g\n    )\n  ].map((m) => ({\n    name: m[1] ?? 'constant',\n    value: stripQuotes(m[3] ?? ''),\n    sourceFile: normalizePath(filePath),\n    sourceLine: lineOf(text, m.index ?? 0)\n  }));\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,QAAQ;AACf,OAAO,UAAU;AAGjB,SAAS,OAAO,MAAc,KAAqB;AACjD,SAAO,KAAK,MAAM,GAAG,GAAG,EAAE,MAAM,IAAI,EAAE;AACxC;AACA,eAAsB,wBACpB,UACA,UACkC;AAClC,QAAM,OAAO,MAAM,GAAG,SAAS,KAAK,KAAK,UAAU,QAAQ,GAAG,MAAM;AACpE,SAAO;AAAA,IACL,GAAG,KAAK;AAAA,MACN;AAAA,IACF;AAAA,EACF,EAAE,IAAI,CAAC,OAAO;AAAA,IACZ,MAAM,EAAE,CAAC,KAAK;AAAA,IACd,OAAO,YAAY,EAAE,CAAC,KAAK,EAAE;AAAA,IAC7B,YAAY,cAAc,QAAQ;AAAA,IAClC,YAAY,OAAO,MAAM,EAAE,SAAS,CAAC;AAAA,EACvC,EAAE;AACJ;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saptools/service-flow",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/cli/doctor.ts

@@ -3,13 +3,16 @@ import { classifyODataPathIntent, normalizeODataOperationInvocationPath } from '
 import { ANALYZER_VERSION } from '../version.js';
 
 type Diagnostic = Record<string, unknown>;
+interface DoctorOptions {
+  detail?: boolean;
+}
 
 export function linkUpgradeWarnings(db: Db): Diagnostic[] {
   return [...schemaDriftDiagnostics(db, true), ...analyzerVersionDiagnostics(db, true)]
     .filter((item) => ['schema_legacy_columns_present', 'external_target_columns_missing_data', 'reindex_required_after_upgrade', 'reindex_required_after_analyzer_upgrade'].includes(String(item.code)));
 }
 
-export function doctorDiagnostics(db: Db, strict: boolean): Diagnostic[] {
+export function doctorDiagnostics(db: Db, strict: boolean, options: DoctorOptions = {}): Diagnostic[] {
   const diagnostics = db.prepare('SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics ORDER BY id').all() as Diagnostic[];
   return [
     ...diagnostics,
@@ -17,7 +20,7 @@ export function doctorDiagnostics(db: Db, strict: boolean): Diagnostic[] {
     ...localServiceDiagnostics(db, strict),
     ...schemaDriftDiagnostics(db, strict),
     ...analyzerVersionDiagnostics(db, strict),
-    ...parserQualityDiagnostics(db, strict),
+    ...parserQualityDiagnostics(db, strict, options),
   ];
 }
 
@@ -99,7 +102,7 @@ function localServiceDiagnostics(db: Db, strict: boolean): Diagnostic[] {
   return out;
 }
 
-function parserQualityDiagnostics(db: Db, strict: boolean): Diagnostic[] {
+function parserQualityDiagnostics(db: Db, strict: boolean, options: DoctorOptions): Diagnostic[] {
   if (!strict) return [];
   const symbol = symbolCallQuality(db);
   const dbq = dbQueryQuality(db);
@@ -108,7 +111,7 @@ function parserQualityDiagnostics(db: Db, strict: boolean): Diagnostic[] {
     identityAliasBindingQuality(db),
     remoteActionNoBindingQuality(db),
     contextualImplementationQuality(db),
-    implementationCandidateQuality(db),
+    implementationCandidateQuality(db, Boolean(options.detail)),
     classInstanceNoiseQuality(db),
     contextualBindingPropagationQuality(db),
     nestedThisReceiverQuality(db),
@@ -178,20 +181,26 @@ function graphDynamicFlagQuality(db: Db): Diagnostic {
   return { severity: Number(row.count ?? 0) > 0 ? 'warning' : 'info', code: 'strict_graph_dynamic_flag_consistency', message: 'Graph dynamic flag consistency aggregate', dynamicTerminalEdges: Number(row.count ?? 0) };
 }
 
-function implementationCandidateQuality(db: Db): Diagnostic {
-  const categories = [...implementationEdgeCategories(db), missingParameterMetadataCategory(db)].filter((item) => item.count > 0);
+function implementationCandidateQuality(db: Db, detail: boolean): Diagnostic {
+  const categories = [...implementationEdgeCategories(db, detail), missingParameterMetadataCategory(db, detail), dynamicWrapperCategory(db, detail)].filter((item) => item.count > 0);
   const total = categories.reduce((sum, item) => sum + item.count, 0);
-  return { severity: total > 0 ? 'warning' : 'info', code: 'strict_implementation_candidate_quality', message: 'Implementation candidate ambiguity and rejection aggregate', total, categories };
+  return { severity: total > 0 ? 'warning' : 'info', code: 'strict_implementation_candidate_quality', message: 'Implementation candidate ambiguity and rejection aggregate', total, summary: implementationSummary(categories), categories };
 }
 
-function implementationEdgeCategories(db: Db): Array<Diagnostic & { count: number }> {
+function implementationEdgeCategories(db: Db, detail: boolean): Array<Diagnostic & { count: number }> {
   const rows = db.prepare(`SELECT e.status,e.unresolved_reason unresolvedReason,e.evidence_json evidenceJson,o.operation_name operationName,base.operation_name baseOperation,s.service_path servicePath
     FROM graph_edges e JOIN cds_operations o ON o.id=CAST(e.from_id AS INTEGER)
     JOIN cds_services s ON s.id=o.service_id LEFT JOIN cds_operations base ON base.id=o.base_operation_id
     WHERE e.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND e.status IN ('ambiguous','unresolved') ORDER BY s.service_path,o.operation_name,e.id`).all() as Diagnostic[];
   const grouped = new Map<string, Diagnostic & { count: number; servicePaths: string[]; examples: Diagnostic[] }>();
   for (const row of rows) addImplementationCategory(grouped, row);
-  return [...grouped.values()].map(({ servicePaths, ...item }) => ({ ...item, servicePathPattern: pathPattern(servicePaths), examples: item.examples.slice(0, 3) }));
+  return [...grouped.values()].map(({ servicePaths, ...item }) => ({
+    ...item,
+    servicePathPattern: pathPattern(servicePaths),
+    suggestedAction: categoryAction(String(item.category)),
+    examples: item.examples.slice(0, 3),
+    expandedExamples: detail ? item.examples : undefined,
+  }));
 }
 
 function addImplementationCategory(grouped: Map<string, Diagnostic & { count: number; servicePaths: string[]; examples: Diagnostic[] }>, row: Diagnostic): void {
@@ -208,16 +217,44 @@ function addImplementationCategory(grouped: Map<string, Diagnostic & { count: nu
   grouped.set(key, current);
 }
 
-function missingParameterMetadataCategory(db: Db): Diagnostic & { count: number } {
+function missingParameterMetadataCategory(db: Db, detail = false): Diagnostic & { count: number } {
   const examples = db.prepare(`SELECT sc.source_file sourceFile,sc.source_line sourceLine,sc.callee_expression calleeExpression
     FROM symbol_calls sc JOIN symbols s ON s.id=sc.callee_symbol_id
     WHERE sc.status='resolved' AND json_extract(sc.evidence_json,'$.callArguments[0].kind') IN ('identifier','object_literal')
       AND (s.evidence_json IS NULL OR json_extract(s.evidence_json,'$.parameterBindings') IS NULL)
-    ORDER BY sc.source_file,sc.source_line LIMIT 3`).all() as Diagnostic[];
+    ORDER BY sc.source_file,sc.source_line`).all() as Diagnostic[];
   const row = db.prepare(`SELECT COUNT(*) count FROM symbol_calls sc JOIN symbols s ON s.id=sc.callee_symbol_id
     WHERE sc.status='resolved' AND json_extract(sc.evidence_json,'$.callArguments[0].kind') IN ('identifier','object_literal')
       AND (s.evidence_json IS NULL OR json_extract(s.evidence_json,'$.parameterBindings') IS NULL)`).get() as { count?: number };
-  return { category: 'missing_parameter_metadata', reason: 'callee symbol is missing parameter binding metadata', candidateFamily: 'symbol_parameter_metadata', count: Number(row.count ?? 0), examples };
+  return { category: 'missing_parameter_metadata', reason: 'callee symbol is missing parameter binding metadata', candidateFamily: 'symbol_parameter_metadata', count: Number(row.count ?? 0), suggestedAction: categoryAction('missing_parameter_metadata'), examples: examples.slice(0, 3), expandedExamples: detail ? examples : undefined };
+}
+
+function dynamicWrapperCategory(db: Db, detail: boolean): Diagnostic & { count: number } {
+  const rows = db.prepare(`SELECT source_file sourceFile,source_line sourceLine,
+      json_extract(evidence_json,'$.receiver') receiverName,
+      COALESCE(json_extract(evidence_json,'$.missingPathIdentifier'),json_extract(evidence_json,'$.operationPathExpression')) pathIdentifier
+    FROM outbound_calls WHERE call_type='remote_action' AND unresolved_reason='dynamic_operation_path_identifier'
+    ORDER BY source_file,source_line`).all() as Diagnostic[];
+  return { category: 'dynamic_wrapper_paths', reason: 'wrapper path cannot be proven statically', candidateFamily: 'wrapper_path', count: rows.length, suggestedAction: categoryAction('dynamic_wrapper_paths'), examples: rows.slice(0, 3), expandedExamples: detail ? rows : undefined };
+}
+
+function implementationSummary(categories: Array<Diagnostic & { count: number }>): Diagnostic[] {
+  const grouped = new Map<string, Diagnostic & { count: number }>();
+  for (const category of categories) {
+    const key = [category.category, category.candidateFamily, category.reason].join('\0');
+    const current = grouped.get(key) ?? { category: category.category, candidateFamily: category.candidateFamily, reason: category.reason, severity: 'warning', suggestedAction: category.suggestedAction, count: 0 };
+    current.count += category.count;
+    grouped.set(key, current);
+  }
+  return [...grouped.values()].sort((left, right) => String(left.category).localeCompare(String(right.category)) || String(left.candidateFamily).localeCompare(String(right.candidateFamily)));
+}
+
+function categoryAction(category: string): string {
+  if (category === 'duplicate_package_name_candidates') return 'Use scoped --implementation-hint fields to select one repository for each ambiguous hop.';
+  if (category === 'missing_strong_ownership_evidence') return 'Add an explicit package dependency, local service-path ownership, or registration ownership evidence.';
+  if (category === 'missing_parameter_metadata') return 'Export a statically analyzable helper with named or destructured parameters.';
+  if (category === 'dynamic_wrapper_paths') return 'Pass a literal path or provide the reported runtime identifier with --var key=value.';
+  return 'Inspect the capped examples and add stronger implementation ownership evidence.';
 }
 
 function implementationCategory(row: Diagnostic, evidence: Diagnostic): string {

package/src/cli.ts

@@ -24,6 +24,7 @@ import { linkWorkspace } from './linker/cross-repo-linker.js';
 import { doctorDiagnostics, linkUpgradeWarnings } from './cli/doctor.js';
 import { trace } from './trace/trace-engine.js';
 import { parseVars } from './trace/selectors.js';
+import { parseImplementationHint } from './trace/implementation-hints.js';
 import { renderTraceTable } from './output/table-output.js';
 import { renderTraceJson, renderJson } from './output/json-output.js';
 import { renderMermaid } from './output/mermaid-output.js';
@@ -152,6 +153,7 @@ export function createProgram(): Command {
     .option('--include-db')
     .option('--include-async')
     .option('--implementation-repo <name>')
+    .option('--implementation-hint <scope>', 'scoped implementation hint', collect, [])
     .option('--var <key=value>', 'dynamic variable', collect, [])
     .action(
       (opts: {
@@ -167,6 +169,7 @@ export function createProgram(): Command {
         includeDb?: boolean;
         includeAsync?: boolean;
         implementationRepo?: string;
+        implementationHint: string[];
         var: string[];
       }) =>
         void withReadOnlyWorkspace(opts.workspace, (db) => {
@@ -186,6 +189,7 @@ export function createProgram(): Command {
               includeDb: Boolean(opts.includeDb),
               includeAsync: Boolean(opts.includeAsync),
               implementationRepo: opts.implementationRepo,
+              implementationHints: opts.implementationHint.map(parseImplementationHint),
             },
           );
           process.stdout.write(
@@ -293,6 +297,7 @@ export function createProgram(): Command {
     .option('--path <operationPath>')
     .option('--format <format>', 'mermaid|json', 'mermaid')
     .option('--implementation-repo <name>')
+    .option('--implementation-hint <scope>', 'scoped implementation hint', collect, [])
     .option('--var <key=value>', 'dynamic variable', collect, [])
     .action(
       (opts: {
@@ -303,6 +308,7 @@ export function createProgram(): Command {
         path?: string;
         format: string;
         implementationRepo?: string;
+        implementationHint: string[];
         var: string[];
       }) =>
         void withReadOnlyWorkspace(opts.workspace, (db) => {
@@ -321,6 +327,7 @@ export function createProgram(): Command {
               includeExternal: true,
               vars: parseVars(opts.var),
               implementationRepo: opts.implementationRepo,
+              implementationHints: opts.implementationHint.map(parseImplementationHint),
             },
           );
           process.stdout.write(
@@ -362,10 +369,11 @@ export function createProgram(): Command {
     .command('doctor')
     .option('--workspace <path>')
     .option('--strict')
+    .option('--detail')
     .action(
-      (opts: { workspace?: string; strict?: boolean }) =>
+      (opts: { workspace?: string; strict?: boolean; detail?: boolean }) =>
         void withReadOnlyWorkspace(opts.workspace, (db) => {
-          const allDiagnostics = doctorDiagnostics(db, Boolean(opts.strict));
+          const allDiagnostics = doctorDiagnostics(db, Boolean(opts.strict), { detail: Boolean(opts.detail) });
           process.stdout.write(
             allDiagnostics.length
               ? renderJson(allDiagnostics)

package/src/index.ts

@@ -10,4 +10,6 @@ export { linkWorkspace } from './linker/cross-repo-linker.js';
 export { applyVariables, extractPlaceholders, substituteVariables } from './linker/dynamic-edge-resolver.js';
 export type { RuntimeSubstitution } from './linker/dynamic-edge-resolver.js';
 export { trace } from './trace/trace-engine.js';
+export { parseImplementationHint } from './trace/implementation-hints.js';
+export type { ImplementationHint } from './types.js';
 export { redactValue, redactText } from './utils/redaction.js';

package/src/linker/cross-repo-linker.ts

@@ -146,7 +146,29 @@ function objectJson(value: unknown): Record<string, unknown> | undefined {
 }
 function callEvidence(call: Record<string, unknown>, resolution: { target?: { repoName?: string; servicePath?: string; operationPath?: string; operationName?: string }; candidates: unknown[]; status: string; reasons: string[] }, servicePath: string | undefined, op: string | undefined, destination: string | undefined, normalized?: NormalizedODataOperationPath, odataPathIntent?: ReturnType<typeof classifyODataPathIntent>): Record<string, unknown> {
   const bindingHasDynamicExpression = Boolean(Number(call.isDynamic ?? 0));
-  return { sourceFile: call.source_file, sourceLine: call.source_line, file: call.source_file, line: call.source_line, callId: call.id, repo: call.repoName, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination, servicePath, operationPath: op, rawOperationPath: normalized?.wasInvocation ? normalized.rawOperationPath : odataPathIntent?.rawPath, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : undefined, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : undefined, odataOperationNormalizationReason: normalized?.normalizationReason, odataOperationNormalizationRejectedReason: normalized?.normalizationRejectedReason, localServiceName: call.local_service_name, localServiceLookup: call.local_service_lookup, aliasChain: parseJson(call.alias_chain_json), transport: call.call_type === 'local_service_call' ? 'local' : undefined, targetRepo: resolution.target?.repoName, targetServicePath: resolution.target?.servicePath, targetOperationPath: resolution.target?.operationPath, targetOperation: resolution.target?.operationName, helperChain: parseJson(call.helperChainJson), candidates: resolution.candidates, candidateCount: resolution.candidates.length, resolutionStatus: resolution.status, resolutionReasons: resolution.reasons, odataPathIntent, queryStringPresent: odataPathIntent?.hasQueryString || undefined, queryPlaceholderKeys: odataPathIntent?.placeholderKeys.length ? odataPathIntent.placeholderKeys : undefined, bindingHasDynamicExpression: bindingHasDynamicExpression || undefined, outboundEvidence: objectJson(call.evidence_json), analysisCompleteness: call.unresolved_reason ? 'partial' : 'complete', parserWarning: call.unresolved_reason ? { code: 'parser_warning', message: call.unresolved_reason } : undefined };
+  const routingPlaceholderKeys = placeholderKeys([servicePath, destination, stringValue(call.aliasExpr), stringValue(call.alias)]);
+  return { sourceFile: call.source_file, sourceLine: call.source_line, file: call.source_file, line: call.source_line, callId: call.id, repo: call.repoName, serviceAlias: call.alias, serviceAliasExpr: call.aliasExpr, destination, servicePath, operationPath: op, rawOperationPath: normalized?.wasInvocation ? normalized.rawOperationPath : odataPathIntent?.rawPath, normalizedOperationPath: normalized?.wasInvocation ? normalized.normalizedOperationPath : undefined, invocationArguments: normalized?.wasInvocation ? normalized.invocationArguments : undefined, invocationArgumentPlaceholderKeys: normalized?.invocationArgumentPlaceholderKeys.length ? normalized.invocationArgumentPlaceholderKeys : undefined, routingPlaceholderKeys: routingPlaceholderKeys.length ? routingPlaceholderKeys : undefined, odataOperationNormalizationReason: normalized?.normalizationReason, odataOperationNormalizationRejectedReason: normalized?.normalizationRejectedReason, localServiceName: call.local_service_name, localServiceLookup: call.local_service_lookup, aliasChain: parseJson(call.alias_chain_json), transport: call.call_type === 'local_service_call' ? 'local' : undefined, targetRepo: resolution.target?.repoName, targetServicePath: resolution.target?.servicePath, targetOperationPath: resolution.target?.operationPath, targetOperation: resolution.target?.operationName, helperChain: parseJson(call.helperChainJson), candidates: resolution.candidates, candidateScores: compactCandidateScores(resolution.candidates), candidateCount: resolution.candidates.length, resolutionStatus: resolution.status, resolutionReasons: resolution.reasons, odataPathIntent, queryStringPresent: odataPathIntent?.hasQueryString || undefined, queryPlaceholderKeys: odataPathIntent?.placeholderKeys.length ? odataPathIntent.placeholderKeys : undefined, bindingHasDynamicExpression: bindingHasDynamicExpression || undefined, outboundEvidence: objectJson(call.evidence_json), analysisCompleteness: call.unresolved_reason ? 'partial' : 'complete', parserWarning: call.unresolved_reason ? { code: 'parser_warning', message: call.unresolved_reason } : undefined };
+}
+
+function compactCandidateScores(candidates: unknown[]): Array<Record<string, unknown>> {
+  return candidates.flatMap((candidate): Array<Record<string, unknown>> => {
+    const row = objectValue(candidate);
+    if (!row) return [];
+    return [{ repo: row.repoName, servicePath: row.servicePath, operationPath: row.operationPath, score: row.score, reasons: row.reasons }];
+  });
+}
+
+function placeholderKeys(values: Array<string | undefined>): string[] {
+  const keys = values.flatMap((value) => [...(value ?? '').matchAll(/\$\{([^}]*)\}/g)].map((match) => (match[1] ?? '').trim()).filter(Boolean));
+  return [...new Set(keys)].sort();
+}
+
+function objectValue(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
 }
 
 function linkImplementations(db: Db, workspaceId: number, generation: number): { edgeCount: number; resolvedCount: number; ambiguousCount: number; unresolvedCount: number } {

package/src/linker/odata-path-normalizer.ts

@@ -2,6 +2,7 @@ export interface NormalizedODataOperationPath {
   rawOperationPath: string;
   normalizedOperationPath: string;
   wasInvocation: boolean;
+  invocationArguments?: string;
   invocationArgumentPlaceholderKeys: string[];
   normalizationReason?: string;
   normalizationRejectedReason?: string;
@@ -20,6 +21,7 @@ export interface ODataPathIntent {
   placeholderKeys: string[];
   keyPredicatePlaceholderKeys: string[];
   invocationArgumentPlaceholderKeys: string[];
+  invocationArguments?: string;
   navigationSuffix?: string;
   mediaOrPropertySuffix?: string;
   hasEntityKeyPredicate: boolean;
@@ -51,6 +53,7 @@ export function normalizeODataOperationInvocationPath(path: string | undefined):
     rawOperationPath: raw,
     normalizedOperationPath: operationSegment,
     wasInvocation: true,
+    invocationArguments: raw.slice(open + 1, close),
     invocationArgumentPlaceholderKeys: [...new Set(extractTemplatePlaceholders(raw.slice(open + 1, close)))],
     normalizationReason: 'balanced_top_level_operation_invocation',
   };
@@ -81,7 +84,7 @@ export function classifyODataPathIntent(path: string | undefined, method: string
   const topLevelOperationInvocation = Boolean(invocation?.wasInvocation && looksLikeLowerCamelInvocation(firstSegment));
   const keyPredicatePlaceholderKeys = topLevelOperationInvocation ? [] : rawKeyPredicatePlaceholderKeys;
   const topLevelOperationNameCandidate = Boolean(topLevelOperationName && !hasNavigationSegments && !firstSegment.includes('('));
-  const base = { rawPath, method: normalizedMethod, pathWithoutQuery, queryString, hasQueryString: queryIndex >= 0, entitySegment, placeholderKeys, keyPredicatePlaceholderKeys, invocationArgumentPlaceholderKeys: invocation?.invocationArgumentPlaceholderKeys ?? [], navigationSuffix, mediaOrPropertySuffix, hasEntityKeyPredicate: firstOpen >= 0 && firstClose !== undefined, hasNavigationSuffix: hasNavigationSegments, hasMediaOrPropertySuffix: Boolean(mediaOrPropertySuffix && isMediaOrPropertySuffix(mediaOrPropertySuffix)), topLevelOperationName, topLevelOperationNameCandidate, topLevelOperationInvocation };
+  const base = { rawPath, method: normalizedMethod, pathWithoutQuery, queryString, hasQueryString: queryIndex >= 0, entitySegment, placeholderKeys, keyPredicatePlaceholderKeys, invocationArguments: invocation?.invocationArguments, invocationArgumentPlaceholderKeys: invocation?.invocationArgumentPlaceholderKeys ?? [], navigationSuffix, mediaOrPropertySuffix, hasEntityKeyPredicate: firstOpen >= 0 && firstClose !== undefined, hasNavigationSuffix: hasNavigationSegments, hasMediaOrPropertySuffix: Boolean(mediaOrPropertySuffix && isMediaOrPropertySuffix(mediaOrPropertySuffix)), topLevelOperationName, topLevelOperationNameCandidate, topLevelOperationInvocation };
   if (!rawPath || !rawPath.startsWith('/')) return { ...base, kind: 'unknown', reason: 'path_missing_or_not_absolute' };
   const upperEntityLike = /^[A-Z][A-Za-z0-9_]*$/.test(entitySegment ?? firstSegment);
   const mediaLike = isMediaOrPropertySuffix(segments.at(-1) ?? '');

package/src/parsers/imported-wrapper-parser.ts

@@ -0,0 +1,262 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { classifyODataPathIntent } from '../linker/odata-path-normalizer.js';
+import type { OutboundCallFact } from '../types.js';
+import { normalizePath } from '../utils/path-utils.js';
+import { importsFor, lineOf, readSource, type ImportBinding } from './service-binding-parser-helpers.js';
+
+interface WrapperSpec {
+  clientIndex: number;
+  pathIndex: number;
+  methodIndex?: number;
+  methodLiteral?: string;
+  sourceFile: string;
+  sourceLine: number;
+  chain: string[];
+}
+
+interface PathValue {
+  value?: string;
+  sourceKind: string;
+  rawExpression: string;
+}
+
+export async function parseImportedWrapperCalls(
+  repoPath: string,
+  filePath: string,
+  source: ts.SourceFile,
+  serviceBindings: Set<string>,
+): Promise<OutboundCallFact[]> {
+  const imports = await importsFor(repoPath, filePath, source);
+  const importedByLocal = new Map(imports.filter((item) => item.sourceFile).map((item) => [item.localName, item]));
+  const calls = collectImportedCalls(source, importedByLocal);
+  const out: OutboundCallFact[] = [];
+  const cache = new Map<string, Promise<WrapperSpec | undefined>>();
+  for (const call of calls) {
+    if (!ts.isIdentifier(call.expression)) continue;
+    const imported = importedByLocal.get(call.expression.text);
+    if (!imported?.sourceFile) continue;
+    const spec = await loadWrapperSpec(repoPath, imported, cache, 0);
+    const fact = spec ? wrapperCallFact(source, filePath, call, spec, serviceBindings) : undefined;
+    if (fact) out.push(fact);
+  }
+  return out;
+}
+
+function collectImportedCalls(source: ts.SourceFile, imports: Map<string, ImportBinding>): ts.CallExpression[] {
+  const calls: ts.CallExpression[] = [];
+  const visit = (node: ts.Node): void => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && imports.has(node.expression.text)) calls.push(node);
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return calls;
+}
+
+async function loadWrapperSpec(
+  repoPath: string,
+  imported: ImportBinding,
+  cache: Map<string, Promise<WrapperSpec | undefined>>,
+  depth: number,
+): Promise<WrapperSpec | undefined> {
+  if (!imported.sourceFile || depth > 5) return undefined;
+  const key = `${imported.sourceFile}#${imported.exportedName}`;
+  const existing = cache.get(key);
+  if (existing) return existing;
+  const pending = inspectWrapper(repoPath, imported.sourceFile, imported.exportedName, cache, depth);
+  cache.set(key, pending);
+  return pending;
+}
+
+async function inspectWrapper(
+  repoPath: string,
+  sourceFile: string,
+  exportedName: string,
+  cache: Map<string, Promise<WrapperSpec | undefined>>,
+  depth: number,
+): Promise<WrapperSpec | undefined> {
+  const source = await readSource(path.join(repoPath, sourceFile));
+  if (!source) return undefined;
+  const named = findFunction(source, exportedName);
+  if (!named) return undefined;
+  const direct = directSendSpec(source, sourceFile, named.name, named.fn);
+  if (direct) return direct;
+  return nestedSendSpec(repoPath, sourceFile, source, named.name, named.fn, cache, depth);
+}
+
+function directSendSpec(source: ts.SourceFile, sourceFile: string, name: string, fn: ts.FunctionLikeDeclaration): WrapperSpec | undefined {
+  const params = parameterNames(fn);
+  const sends: ts.CallExpression[] = [];
+  visitFunctionBody(fn, (node) => {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'send') sends.push(node);
+  });
+  if (sends.length !== 1) return undefined;
+  const send = sends[0];
+  const receiver = send && ts.isPropertyAccessExpression(send.expression) && ts.isIdentifier(send.expression.expression) ? send.expression.expression.text : undefined;
+  const object = send?.arguments[0];
+  if (!receiver || !object || !ts.isObjectLiteralExpression(object)) return undefined;
+  const pathExpr = propertyExpression(object, 'path');
+  const methodExpr = propertyExpression(object, 'method');
+  const pathName = pathExpr && ts.isIdentifier(pathExpr) ? pathExpr.text : undefined;
+  const clientIndex = params.indexOf(receiver);
+  const pathIndex = pathName ? params.indexOf(pathName) : -1;
+  if (clientIndex < 0 || pathIndex < 0) return undefined;
+  const methodName = methodExpr && ts.isIdentifier(methodExpr) ? methodExpr.text : undefined;
+  const methodIndex = methodName ? params.indexOf(methodName) : -1;
+  return { clientIndex, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : undefined, methodLiteral: literal(methodExpr), sourceFile, sourceLine: lineOf(source, fn), chain: [name] };
+}
+
+async function nestedSendSpec(
+  repoPath: string,
+  sourceFile: string,
+  source: ts.SourceFile,
+  name: string,
+  fn: ts.FunctionLikeDeclaration,
+  cache: Map<string, Promise<WrapperSpec | undefined>>,
+  depth: number,
+): Promise<WrapperSpec | undefined> {
+  const imports = await importsFor(repoPath, sourceFile, source);
+  const byLocal = new Map(imports.filter((item) => item.sourceFile).map((item) => [item.localName, item]));
+  const calls: ts.CallExpression[] = [];
+  visitFunctionBody(fn, (node) => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && byLocal.has(node.expression.text)) calls.push(node);
+  });
+  if (calls.length !== 1) return undefined;
+  const call = calls[0];
+  const imported = call && ts.isIdentifier(call.expression) ? byLocal.get(call.expression.text) : undefined;
+  const nested = imported ? await loadWrapperSpec(repoPath, imported, cache, depth + 1) : undefined;
+  if (!call || !nested) return undefined;
+  const params = parameterNames(fn);
+  const clientIndex = mappedParameterIndex(call.arguments[nested.clientIndex], params);
+  const pathIndex = mappedParameterIndex(call.arguments[nested.pathIndex], params);
+  if (clientIndex < 0 || pathIndex < 0) return undefined;
+  const methodIndex = nested.methodIndex === undefined ? undefined : mappedParameterIndex(call.arguments[nested.methodIndex], params);
+  return { clientIndex, pathIndex, methodIndex: methodIndex !== undefined && methodIndex >= 0 ? methodIndex : undefined, methodLiteral: nested.methodLiteral, sourceFile, sourceLine: lineOf(source, fn), chain: [name, ...nested.chain] };
+}
+
+function wrapperCallFact(
+  source: ts.SourceFile,
+  filePath: string,
+  call: ts.CallExpression,
+  spec: WrapperSpec,
+  serviceBindings: Set<string>,
+): OutboundCallFact | undefined {
+  const client = call.arguments[spec.clientIndex];
+  if (!client || !ts.isIdentifier(client) || !serviceBindings.has(client.text)) return undefined;
+  const pathValue = resolveCallerPath(call.arguments[spec.pathIndex], call);
+  const methodValue = spec.methodIndex === undefined ? spec.methodLiteral : literal(call.arguments[spec.methodIndex]);
+  const method = (methodValue ?? 'POST').toUpperCase();
+  const rawPath = pathValue.rawExpression;
+  const operationPathExpr = pathValue.value ? normalizeOperationPath(pathValue.value) : runtimePathExpression(rawPath);
+  return {
+    callType: 'remote_action',
+    serviceVariableName: client.text,
+    method,
+    operationPathExpr,
+    payloadSummary: call.getText(source),
+    sourceFile: normalizePath(filePath),
+    sourceLine: lineOf(source, call),
+    confidence: operationPathExpr ? 0.85 : 0.5,
+    unresolvedReason: pathValue.value ? undefined : 'dynamic_operation_path_identifier',
+    evidence: {
+      parser: 'typescript_ast',
+      classifier: pathValue.value ? 'imported_wrapper_literal_path' : 'imported_wrapper_dynamic_path',
+      receiver: client.text,
+      wrapperFunction: spec.chain[0],
+      wrapperChain: spec.chain,
+      callerSite: { sourceFile: normalizePath(filePath), sourceLine: lineOf(source, call) },
+      calleeSite: { sourceFile: spec.sourceFile, sourceLine: spec.sourceLine },
+      rawPathExpression: rawPath,
+      missingPathIdentifier: pathValue.value ? undefined : rawPath,
+      odataPathIntent: pathValue.value ? classifyODataPathIntent(operationPathExpr, method) : undefined,
+    },
+  };
+}
+
+function resolveCallerPath(expr: ts.Expression | undefined, use: ts.Node): PathValue {
+  if (!expr) return { sourceKind: 'missing', rawExpression: '' };
+  if (ts.isStringLiteralLike(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) return { value: expr.text, sourceKind: 'literal', rawExpression: expr.getText() };
+  if (ts.isTemplateExpression(expr)) return { value: expr.getText().slice(1, -1), sourceKind: 'template', rawExpression: expr.getText() };
+  if (ts.isIdentifier(expr)) {
+    const initializer = constInitializer(expr.text, use);
+    if (initializer) {
+      const resolved = resolveCallerPath(initializer, initializer);
+      return { ...resolved, sourceKind: 'const', rawExpression: expr.text };
+    }
+  }
+  return { sourceKind: 'dynamic', rawExpression: expr.getText() };
+}
+
+function constInitializer(name: string, use: ts.Node): ts.Expression | undefined {
+  let found: ts.Expression | undefined;
+  const source = use.getSourceFile();
+  const visit = (node: ts.Node): void => {
+    if (node.getStart(source) >= use.getStart(source)) return;
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === name && node.initializer && (node.parent.flags & ts.NodeFlags.Const) !== 0) found = node.initializer;
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return found;
+}
+
+function findFunction(source: ts.SourceFile, exportedName: string): { name: string; fn: ts.FunctionLikeDeclaration } | undefined {
+  const localName = exportedLocalName(source, exportedName);
+  for (const statement of source.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name?.text === localName) return { name: exportedName, fn: statement };
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.name.text === localName && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) return { name: exportedName, fn: declaration.initializer };
+    }
+  }
+  return undefined;
+}
+
+function exportedLocalName(source: ts.SourceFile, exportedName: string): string {
+  for (const statement of source.statements) {
+    if (!ts.isExportDeclaration(statement) || !statement.exportClause || !ts.isNamedExports(statement.exportClause)) continue;
+    const match = statement.exportClause.elements.find((item) => item.name.text === exportedName);
+    if (match) return match.propertyName?.text ?? match.name.text;
+  }
+  return exportedName;
+}
+
+function visitFunctionBody(fn: ts.FunctionLikeDeclaration, visitor: (node: ts.Node) => void): void {
+  const visit = (node: ts.Node): void => {
+    if (node !== fn && ts.isFunctionLike(node)) return;
+    visitor(node);
+    ts.forEachChild(node, visit);
+  };
+  if (fn.body) visit(fn.body);
+}
+
+function parameterNames(fn: ts.FunctionLikeDeclaration): string[] {
+  return fn.parameters.map((parameter) => ts.isIdentifier(parameter.name) ? parameter.name.text : '');
+}
+
+function mappedParameterIndex(expr: ts.Expression | undefined, parameters: string[]): number {
+  return expr && ts.isIdentifier(expr) ? parameters.indexOf(expr.text) : -1;
+}
+
+function propertyExpression(object: ts.ObjectLiteralExpression, key: string): ts.Expression | undefined {
+  for (const property of object.properties) {
+    if (ts.isPropertyAssignment(property) && propertyName(property.name) === key) return property.initializer;
+    if (ts.isShorthandPropertyAssignment(property) && property.name.text === key) return property.name;
+  }
+  return undefined;
+}
+
+function propertyName(name: ts.PropertyName): string | undefined {
+  return ts.isIdentifier(name) || ts.isStringLiteralLike(name) ? name.text : undefined;
+}
+
+function literal(expr: ts.Expression | undefined): string | undefined {
+  return expr && (ts.isStringLiteralLike(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) ? expr.text : undefined;
+}
+
+function normalizeOperationPath(value: string): string {
+  return value.startsWith('/') ? value : `/${value}`;
+}
+
+function runtimePathExpression(value: string): string | undefined {
+  return value ? `\${${value}}` : undefined;
+}

package/src/parsers/outbound-call-parser.ts

@@ -6,6 +6,8 @@ import type { OutboundCallFact } from '../types.js';
 import { normalizePath, stripQuotes } from '../utils/path-utils.js';
 import { summarizeExpression } from '../utils/redaction.js';
 import { classifyODataPathIntent } from '../linker/odata-path-normalizer.js';
+import { parseServiceBindings } from './service-binding-parser.js';
+import { parseImportedWrapperCalls } from './imported-wrapper-parser.js';
 function lineOf(text: string, idx: number): number {
   return text.slice(0, idx).split('\n').length;
 }
@@ -501,7 +503,9 @@ export async function parseOutboundCalls(
 ): Promise<OutboundCallFact[]> {
   const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');
   const source = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, filePath.endsWith('.ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS);
-  return [...classifyOutboundCallsInSource(source, filePath).map((call) => call.fact), ...parseLocalServiceCalls(text, filePath)];
+  const bindingNames = new Set((await parseServiceBindings(repoPath, filePath)).map((binding) => binding.variableName));
+  const importedWrappers = await parseImportedWrapperCalls(repoPath, filePath, source, bindingNames);
+  return [...classifyOutboundCallsInSource(source, filePath).map((call) => call.fact), ...importedWrappers, ...parseLocalServiceCalls(text, filePath)];
 }
 function parseLocalServiceCalls(text: string, filePath: string): OutboundCallFact[] {
   const source = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, filePath.endsWith('.ts') ? ts.ScriptKind.TS : ts.ScriptKind.JS);