@saptools/service-flow 0.1.43 → 0.1.45

package/src/indexer/repository-indexer.ts

@@ -42,42 +42,68 @@ interface ParsedFacts {
   symbolCalls: SymbolCallFact[];
   fileRecords: Array<{ relativePath: string; extension: string; sha256: string; sizeBytes: number }>;
 }
+export interface PreparedRepositoryIndex extends IndexRepoResult {
+  repo: RepoRow;
+  packageFacts?: Awaited<ReturnType<typeof parsePackageJson>>;
+  fingerprint?: string;
+  kind?: string;
+  parsed?: ParsedFacts;
+}
 export async function indexRepository(
   db: Db,
   repo: RepoRow,
   force: boolean,
 ): Promise<IndexRepoResult> {
   try {
-    const sourceFiles = await findSourceFiles(repo.absolute_path);
-    const packageFacts = await parsePackageJson(repo.absolute_path);
-    const fingerprint = await repositoryFingerprint(repo.absolute_path, sourceFiles, packageFacts);
-    if (!force && repo.fingerprint === fingerprint) return { fileCount: 0, diagnosticCount: 0, skipped: true };
-    const kind = await classifyRepository(repo.absolute_path, packageFacts);
-    const parsed = await parseAllSourceFacts(repo.absolute_path, sourceFiles);
-    db.transaction(() => {
-      db.prepare('UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?').run(packageFacts.packageName, packageFacts.packageVersion, JSON.stringify(packageFacts.dependencies), kind, 'indexing', repo.id);
-      clearRepoFacts(db, repo.id);
-      insertRequires(db, repo.id, packageFacts.cdsRequires);
-      const fileStmt = db.prepare('INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at');
-      for (const file of parsed.fileRecords) fileStmt.run(repo.id, file.relativePath, file.extension, file.sha256, file.sizeBytes, new Date().toISOString());
-      for (const s of parsed.services) insertService(db, repo.id, s);
-      for (const h of parsed.handlers) insertHandler(db, repo.id, h);
-      insertExecutableSymbols(db, repo.id, parsed.symbols);
-      insertSymbolCalls(db, repo.id, parsed.symbolCalls);
-      insertRegistrations(db, repo.id, parsed.registrations);
-      insertBindings(db, repo.id, parsed.bindings);
-      insertCalls(db, repo.id, parsed.calls);
-      db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(new Date().toISOString(), fingerprint, new Date().toISOString(), ANALYZER_VERSION, repo.id);
-    });
-    return { fileCount: sourceFiles.length, diagnosticCount: 0, skipped: false };
+    const prepared = await prepareRepositoryIndex(repo, force);
+    if (!prepared.skipped) db.transaction(() => publishPreparedRepositoryIndex(db, prepared));
+    return { fileCount: prepared.fileCount, diagnosticCount: prepared.diagnosticCount, skipped: prepared.skipped };
   } catch (error) {
-    const message = errorMessage(error);
-    db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repo.id);
-    db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repo.id);
-    db.prepare('INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)').run(repo.id, 'error', 'source_read_failed', `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
+    recordIndexFailure(db, repo.id, error);
     return { fileCount: 0, diagnosticCount: 1, skipped: false };
   }
 }
+export async function prepareRepositoryIndex(repo: RepoRow, force: boolean): Promise<PreparedRepositoryIndex> {
+  const sourceFiles = await findSourceFiles(repo.absolute_path);
+  const packageFacts = await parsePackageJson(repo.absolute_path);
+  const fingerprint = await repositoryFingerprint(repo.absolute_path, sourceFiles, packageFacts);
+  if (!force && repo.fingerprint === fingerprint) return { repo, fileCount: 0, diagnosticCount: 0, skipped: true };
+  return {
+    repo,
+    packageFacts,
+    fingerprint,
+    kind: await classifyRepository(repo.absolute_path, packageFacts),
+    parsed: await parseAllSourceFacts(repo.absolute_path, sourceFiles),
+    fileCount: sourceFiles.length,
+    diagnosticCount: 0,
+    skipped: false,
+  };
+}
+export function publishPreparedRepositoryIndex(db: Db, prepared: PreparedRepositoryIndex): void {
+  if (prepared.skipped) return;
+  if (!prepared.packageFacts || !prepared.parsed || !prepared.fingerprint || !prepared.kind) throw new Error('Prepared repository index is missing publication facts');
+  const now = new Date().toISOString();
+  const repoId = prepared.repo.id;
+  db.prepare('UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?').run(prepared.packageFacts.packageName, prepared.packageFacts.packageVersion, JSON.stringify(prepared.packageFacts.dependencies), prepared.kind, 'indexing', repoId);
+  clearRepoFacts(db, repoId);
+  insertRequires(db, repoId, prepared.packageFacts.cdsRequires);
+  const fileStmt = db.prepare('INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at');
+  for (const file of prepared.parsed.fileRecords) fileStmt.run(repoId, file.relativePath, file.extension, file.sha256, file.sizeBytes, now);
+  for (const service of prepared.parsed.services) insertService(db, repoId, service);
+  for (const handler of prepared.parsed.handlers) insertHandler(db, repoId, handler);
+  insertExecutableSymbols(db, repoId, prepared.parsed.symbols);
+  insertSymbolCalls(db, repoId, prepared.parsed.symbolCalls);
+  insertRegistrations(db, repoId, prepared.parsed.registrations);
+  insertBindings(db, repoId, prepared.parsed.bindings);
+  insertCalls(db, repoId, prepared.parsed.calls);
+  db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=?, fact_analyzer_version=? WHERE id=?").run(now, prepared.fingerprint, now, ANALYZER_VERSION, repoId);
+}
+export function recordIndexFailure(db: Db, repoId: number, error: unknown): void {
+  const message = errorMessage(error);
+  db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repoId);
+  db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repoId);
+  db.prepare('INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)').run(repoId, 'error', 'source_read_failed', `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
+}
 async function parseAllSourceFacts(root: string, files: string[]): Promise<ParsedFacts> {
   const facts: ParsedFacts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], symbols: [], symbolCalls: [], fileRecords: [] };
   for (const file of files) {

package/src/indexer/workspace-indexer.ts

@@ -1,12 +1,12 @@
 import type { Db } from '../db/connection.js';
 import { listRepositories, repoByName } from '../db/repositories.js';
 import { errorMessage } from '../utils/diagnostics.js';
-import { indexRepository } from './repository-indexer.js';
+import { prepareRepositoryIndex, publishPreparedRepositoryIndex, recordIndexFailure, type PreparedRepositoryIndex } from './repository-indexer.js';
 import { materializeCdsExtensionOperations } from './cds-extension-resolver.js';
 export async function indexWorkspace(
   db: Db,
   workspaceId: number,
-  options: { repo?: string; force: boolean },
+  options: { repo?: string; force: boolean; injectDerivedMaterializationFailure?: boolean },
 ): Promise<{ repoCount: number; indexedCount: number; skippedCount: number; fileCount: number; diagnosticCount: number }> {
   const started = new Date().toISOString();
   const repos = options.repo ? [repoByName(db, options.repo)].filter((r) => r !== undefined) : listRepositories(db);
@@ -14,17 +14,29 @@ export async function indexWorkspace(
   let fileCount = 0;
   let diagnosticCount = 0;
   let skippedCount = 0;
+  const preparedRows: PreparedRepositoryIndex[] = [];
+  let activeRepoId: number | undefined;
   try {
     for (const repo of repos) {
-      const result = await indexRepository(db, repo, options.force);
+      activeRepoId = repo.id;
+      const result = await prepareRepositoryIndex(repo, options.force);
+      preparedRows.push(result);
       fileCount += result.fileCount;
       diagnosticCount += result.diagnosticCount;
       skippedCount += result.skipped ? 1 : 0;
     }
-    materializeCdsExtensionOperations(db, workspaceId);
-    db.prepare('UPDATE index_runs SET finished_at=?, status=?, file_count=?, diagnostic_count=? WHERE id=?').run(new Date().toISOString(), diagnosticCount ? 'failed' : 'success', fileCount, diagnosticCount, runId);
+    db.transaction(() => {
+      for (const row of preparedRows) {
+        activeRepoId = row.repo.id;
+        publishPreparedRepositoryIndex(db, row);
+      }
+      if (options.injectDerivedMaterializationFailure) throw new Error('Injected derived materialization failure');
+      materializeCdsExtensionOperations(db, workspaceId);
+      db.prepare('UPDATE index_runs SET finished_at=?, status=?, file_count=?, diagnostic_count=? WHERE id=?').run(new Date().toISOString(), diagnosticCount ? 'failed' : 'success', fileCount, diagnosticCount, runId);
+    });
     return { repoCount: repos.length, indexedCount: repos.length - skippedCount, skippedCount, fileCount, diagnosticCount };
   } catch (error) {
+    if (activeRepoId && preparedRows.length < repos.length) recordIndexFailure(db, activeRepoId, error);
     db.prepare("UPDATE index_runs SET finished_at=?, status='failed', file_count=?, diagnostic_count=?, error_message=? WHERE id=?").run(new Date().toISOString(), fileCount, diagnosticCount + 1, errorMessage(error), runId);
     throw error;
   }

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 } {
@@ -162,7 +184,11 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
     const accepted = candidates.filter((candidate) => candidate.accepted);
     const topScore = accepted[0]?.score ?? 0;
     const winners = accepted.filter((candidate) => candidate.score === topScore);
-    const unique = winners.length === 1 ? winners[0] : undefined;
+    const duplicateFamilies = duplicatePackageFamilies(accepted);
+    const duplicatePackageAmbiguous = duplicateFamilies.length > 0 && !accepted.some(hasDirectOwnershipEvidence);
+    const selected = duplicatePackageAmbiguous ? accepted : winners;
+    const unique = !duplicatePackageAmbiguous && winners.length === 1 ? winners[0] : undefined;
+    const ambiguityReasons = duplicatePackageAmbiguous ? ['duplicate_package_name_candidates'] : winners.length > 1 ? ['multiple_equal_score_implementation_candidates'] : [];
     const evidence = {
       servicePath: operation.servicePath,
       operationPath: operation.operationPath,
@@ -171,6 +197,8 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
       implementationSource: implementationContext.operationId === operation.operationId ? 'direct_or_concrete_override' : 'inherited_from_base_operation',
       baseOperationId: operation.baseOperationId,
       implementationOperationId: implementationContext.operationId,
+      ambiguityReasons,
+      candidateFamilies: duplicateFamilies,
       candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1)),
     };
     if (accepted.length === 0) {
@@ -179,7 +207,7 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
       unresolvedCount += 1;
       continue;
     }
-    db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, 'OPERATION_IMPLEMENTED_BY_HANDLER', unique ? 'resolved' : 'ambiguous', 'operation', graphId(operation.operationId), unique ? 'handler_method' : 'handler_method_candidates', unique ? graphId(unique.methodId) : winners.map((row) => graphId(row.methodId)).join(','), unique ? 0.95 : 0.5, JSON.stringify(evidence), 0, unique ? null : 'Ambiguous registered handler implementation candidates', generation);
+    db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, 'OPERATION_IMPLEMENTED_BY_HANDLER', unique ? 'resolved' : 'ambiguous', 'operation', graphId(operation.operationId), unique ? 'handler_method' : 'handler_method_candidates', unique ? graphId(unique.methodId) : selected.map((row) => graphId(row.methodId)).join(','), unique ? 0.95 : 0.5, JSON.stringify(evidence), 0, unique ? null : 'Ambiguous registered handler implementation candidates', generation);
     edgeCount += 1;
     if (unique) resolvedCount += 1;
     else ambiguousCount += 1;
@@ -232,6 +260,20 @@ function uniqueRegistrations(rows: Array<Record<string, unknown>>): Array<Record
     return true;
   });
 }
+function duplicatePackageFamilies(candidates: ImplementationCandidate[]): Array<Record<string, unknown>> {
+  const byPackage = new Map<string, ImplementationCandidate[]>();
+  for (const candidate of candidates) {
+    const packageName = typeof candidate.handlerPackage === 'string' ? candidate.handlerPackage : undefined;
+    if (!packageName) continue;
+    byPackage.set(packageName, [...(byPackage.get(packageName) ?? []), candidate]);
+  }
+  return [...byPackage.entries()]
+    .filter(([, rows]) => new Set(rows.map((row) => Number(row.handlerRepoId))).size > 1)
+    .map(([packageName, rows]) => ({ reason: 'duplicate_package_name_candidates', packageName, count: rows.length, repositories: rows.map((row) => row.handlerRepo).sort() }));
+}
+function hasDirectOwnershipEvidence(candidate: ImplementationCandidate): boolean {
+  return candidate.acceptedReasons.some((reason) => reason === 'model package equals registration package' || reason === 'model package equals handler package' || reason === 'registration package contains exact local service path');
+}
 function implementationCandidates(db: Db, workspaceId: number, operation: Record<string, unknown>): Array<Record<string, unknown>> {
   const modelRepoGraphId = graphId(operation.modelRepoId);
   return db.prepare(`SELECT DISTINCT

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;
 }
@@ -338,7 +340,7 @@ function isSupportedEventReceiver(receiver: string | undefined, rootReceiver: st
   if (/^(srv|service|serviceClient|messaging|messageClient|eventClient)$/.test(candidate)) return true;
   return false;
 }
-interface WrapperSpec { clientIndex?: number; clientName?: string; pathIndex: number; methodIndex?: number; methodName?: string; methodLiteral?: string; definitionLine: number; internalStart: number; internalEnd: number }
+interface WrapperSpec { clientIndex?: number; clientName?: string; pathIndex: number; methodIndex?: number; methodName?: string; methodLiteral?: string; nestedWrapperFunction?: string; definitionLine: number; internalStart: number; internalEnd: number }
 function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
   const specs = new Map<string, WrapperSpec>();
   const serviceVariables = collectServiceVariables(source);
@@ -354,7 +356,7 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
   const scanFunction = (name: string, fn: ts.FunctionLikeDeclaration): void => {
     if (!calledNames.has(name)) return;
     const params = fn.parameters.map((param) => ts.isIdentifier(param.name) ? param.name.text : undefined);
-    const sends: Array<{ client: string; path: string; method?: string; methodLiteral?: string; start: number; end: number }> = [];
+    const sends: Array<{ client: string; path: string; method?: string; methodLiteral?: string; nestedWrapperFunction?: string; start: number; end: number }> = [];
     const visit = (node: ts.Node): void => {
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'send' && ts.isIdentifier(node.expression.expression)) {
         const objectArg = node.arguments[0];
@@ -367,6 +369,14 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
           if (pathName) sends.push({ client: node.expression.expression.text, path: pathName, method: methodName, methodLiteral, start: node.getStart(source), end: node.getEnd() });
         }
       }
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && specs.has(node.expression.text)) {
+        const nested = specs.get(node.expression.text);
+        const pathArg = nested ? node.arguments[nested.pathIndex] : undefined;
+        const clientArg = nested?.clientIndex === undefined ? undefined : node.arguments[nested.clientIndex];
+        const pathName = pathArg && ts.isIdentifier(pathArg) ? pathArg.text : undefined;
+        const clientName = clientArg && ts.isIdentifier(clientArg) ? clientArg.text : nested?.clientName;
+        if (nested && pathName && clientName) sends.push({ client: clientName, path: pathName, method: nested.methodName, methodLiteral: nested.methodLiteral, nestedWrapperFunction: node.expression.text, start: node.getStart(source), end: node.getEnd() });
+      }
       ts.forEachChild(node, visit);
     };
     visit(fn);
@@ -376,7 +386,7 @@ function collectWrapperSpecs(source: ts.SourceFile): Map<string, WrapperSpec> {
     const pathIndex = params.indexOf(found.path);
     const methodIndex = found.method ? params.indexOf(found.method) : -1;
     const capturesKnownClient = serviceVariables.has(found.client) || /^(srv|service|serviceClient|client|.*Client)$/.test(found.client);
-    if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : undefined, clientName: clientIndex >= 0 ? undefined : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : undefined, methodName: found.method, methodLiteral: found.methodLiteral, definitionLine: lineOf(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
+    if (pathIndex >= 0 && (clientIndex >= 0 || capturesKnownClient)) specs.set(name, { clientIndex: clientIndex >= 0 ? clientIndex : undefined, clientName: clientIndex >= 0 ? undefined : found.client, pathIndex, methodIndex: methodIndex >= 0 ? methodIndex : undefined, methodName: found.method, methodLiteral: found.methodLiteral, nestedWrapperFunction: found.nestedWrapperFunction, definitionLine: lineOf(source.text, fn.getStart(source)), internalStart: found.start, internalEnd: found.end });
   };
   const visitTop = (node: ts.Node): void => {
     if (ts.isFunctionDeclaration(node) && node.name) scanFunction(node.name.text, node);
@@ -456,7 +466,7 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
         const operationPathExpr = operationPathFromStatic(resolvedPath.text);
         const normalizedOperationPath = operationPathExpr ? classifyODataPathIntent(operationPathExpr, method).topLevelOperationName : undefined;
         if (spec && receiver && operationPathExpr) {
-          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === 'literal' ? 'higher_order_wrapper_literal_path' : 'higher_order_wrapper_static_path', wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
+          add(node, { callType: 'remote_action', serviceVariableName: receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.75 }, { receiver, classifier: resolvedPath.sourceKind === 'literal' ? 'higher_order_wrapper_literal_path' : 'higher_order_wrapper_static_path', wrapperFunction: wrapperName, nestedWrapperFunction: spec.nestedWrapperFunction, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, normalizedOperationPath, literalPathSource: resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : `wrapper_call_${resolvedPath.sourceKind}`, literalCallerArgumentDetected: true });
         } else if (spec && receiver) {
           add(node, { callType: 'remote_action', serviceVariableName: receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.45, unresolvedReason: 'dynamic_operation_path_identifier' }, { receiver, classifier: 'higher_order_wrapper_dynamic_path', wrapperFunction: wrapperName, wrapperDefinitionLine: spec.definitionLine, callerLine: lineOf(source.text, node.getStart(source)), wrapperPathSourceKind: resolvedPath.sourceKind, rawPathExpression: resolvedPath.rawExpression, parserWarning: 'dynamic_operation_path_identifier' });
         }
@@ -493,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);