@saptools/service-flow 0.1.48 → 0.1.50

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

@@ -78,7 +78,38 @@ function insertCallEdge(db: Db, workspaceId: number, call: Record<string, unknow
   const operationLikeRemoteEntity = isRemoteEntityCall && Boolean(op) && credibleOperationSignal && (!strongEntitySignal || indexedOperationCandidateCount > 0);
   const isOperationCall = operationLikeRemoteEntity || ((callType === 'remote_action' || callType === 'local_service_call') || (callType === 'remote_query' && Boolean(op)));
   const resolution = isOperationCall ? resolveOperation(db, { servicePath, operationPath: op, serviceName: call.local_service_name as string | undefined, repoId: callType === 'local_service_call' ? Number(call.repo_id) : undefined, alias: applyVariables((call.aliasExpr as string | undefined) ?? (call.alias as string | undefined), vars), destination: destination ? applyVariables(destination, vars) : undefined, isDynamic, hasExplicitOverride: Object.keys(vars).length > 0 || callType === 'local_service_call' }, workspaceId) : { status: 'unresolved' as const, candidates: [], reasons: [] };
-  const evidence: Record<string, unknown> = { ...callEvidence(call, resolution, servicePath, op, destination ? applyVariables(destination, vars) : undefined, normalized, intent), indexedOperationCandidateCount, parserCallType: callType };
+  const evidence: Record<string, unknown> = {
+    ...callEvidence(call, resolution, servicePath, op, destination ? applyVariables(destination, vars) : undefined, normalized, intent),
+    indexedOperationCandidateCount,
+    parserCallType: callType,
+    entityOperationPrecedence: operationPrecedence(
+      callType,
+      intent,
+      indexedOperationCandidateCount,
+      Boolean(resolution.target),
+    ),
+  };
+  const pathAnalysis = objectValue(objectJson(call.evidence_json)?.pathAnalysis);
+  if (callType === 'remote_action' && pathAnalysis?.status === 'ambiguous') {
+    const candidatePaths = Array.isArray(pathAnalysis.candidateRawPaths)
+      ? pathAnalysis.candidateRawPaths
+      : [];
+    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,
+      'UNRESOLVED_EDGE',
+      'ambiguous',
+      'call',
+      String(call.id),
+      'operation_candidates',
+      candidatePaths.join(','),
+      Number(call.confidence ?? 0.5),
+      JSON.stringify(evidence),
+      0,
+      'Ambiguous operation path candidates require explicit disambiguation',
+      generation,
+    );
+    return { status: 'ambiguous', callType };
+  }
   if (isRemoteEntityCall && (resolution.target || resolution.candidates.length > 0 || resolution.status === 'dynamic')) {
     if (resolution.target) {
       db.prepare('INSERT INTO graph_edges(workspace_id,edge_type,status,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,generation) VALUES(?,?,?,?,?,?,?,?,?,?,?)').run(workspaceId, 'REMOTE_CALL_RESOLVES_TO_OPERATION', 'resolved', 'call', String(call.id), 'operation', String(resolution.target.operationId), resolution.target.score, JSON.stringify({ ...evidence, operationEntityPrecedence: 'indexed_operation_over_parser_entity' }), 0, generation);
@@ -125,6 +156,44 @@ function operationCandidateCount(db: Db, workspaceId: number, operationPath: str
   return Number(row?.count ?? 0);
 }
 
+function operationPrecedence(
+  callType: string,
+  intent: ReturnType<typeof classifyODataPathIntent>,
+  indexedOperationCandidateCount: number,
+  resolvedOperation: boolean,
+): Record<string, unknown> {
+  if (resolvedOperation) {
+    return {
+      decision: 'operation',
+      reason: 'indexed_operation_with_strong_service_context',
+      indexedOperationCandidateCount,
+    };
+  }
+  if (callType === 'remote_action' && intent.kind === 'operation_invocation') {
+    return {
+      decision: 'operation_candidate',
+      rejectionReason: indexedOperationCandidateCount > 0
+        ? 'indexed_candidates_lack_unique_strong_service_context'
+        : 'no_indexed_operation_candidate',
+      indexedOperationCandidateCount,
+    };
+  }
+  if (intent.kind.startsWith('entity_')) {
+    return {
+      decision: 'entity',
+      rejectionReason: indexedOperationCandidateCount > 0
+        ? 'entity_shape_has_precedence_without_resolved_operation_context'
+        : 'entity_shape_has_no_indexed_operation_evidence',
+      indexedOperationCandidateCount,
+    };
+  }
+  return {
+    decision: 'unresolved',
+    rejectionReason: 'path_has_no_safe_entity_or_operation_precedence',
+    indexedOperationCandidateCount,
+  };
+}
+
 function unresolvedOperationReason(resolution: { candidates: unknown[]; status: string; reasons: string[] }): string {
   if (resolution.status === 'dynamic') return `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ['missing runtime variables']).join(', ')}`;
   if (resolution.candidates.length === 0) return 'No indexed target operation matched';
@@ -232,14 +301,64 @@ function implementationContextForOperation(db: Db, operation: Record<string, unk
 }
 function rankedImplementationCandidates(db: Db, workspaceId: number, operation: Record<string, unknown>): ImplementationCandidate[] {
   const rows = implementationCandidates(db, workspaceId, operation);
-  return deduplicateCandidates(rows.map((row) => scoreImplementationCandidate(row, operation))).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
+  const invalid = rows.filter((row) => !validRegistrationPair(row));
+  recordRegistrationInvariantDiagnostics(db, invalid);
+  return deduplicateCandidates(
+    rows.filter(validRegistrationPair)
+      .map((row) => scoreImplementationCandidate(row, operation)),
+  ).sort((a, b) => b.score - a.score || String(a.className).localeCompare(String(b.className)) || a.methodId - b.methodId);
+}
+function validRegistrationPair(row: Record<string, unknown>): boolean {
+  if (row.registrationHandlerClassId === null
+    || row.registrationHandlerClassId === undefined)
+    return registrationPairingStrategy(row) !== 'unproven';
+  return Number(row.registrationHandlerClassId) === Number(row.classId);
+}
+function registrationPairingStrategy(row: Record<string, unknown>): string {
+  if (row.registrationHandlerClassId !== null
+    && row.registrationHandlerClassId !== undefined)
+    return 'exact_handler_class_id';
+  if (Number(row.applicationRepoId) === Number(row.handlerRepoId))
+    return 'same_repository_class_name_fallback';
+  const source = stringValue(row.importSource);
+  const separator = source?.lastIndexOf('#') ?? -1;
+  if (!source || separator <= 0) return 'unproven';
+  const moduleName = source.slice(0, separator);
+  const importedName = source.slice(separator + 1);
+  const matchesClass = importedName === row.className
+    || (importedName === 'default' && row.registrationClassName === row.className);
+  return moduleName === row.handlerPackage && matchesClass
+    ? 'explicit_package_import'
+    : 'unproven';
+}
+function recordRegistrationInvariantDiagnostics(
+  db: Db,
+  rows: Array<Record<string, unknown>>,
+): void {
+  const insert = db.prepare(`INSERT INTO diagnostics(repo_id,severity,code,message,source_file,source_line)
+    SELECT ?,'error','handler_registration_class_mismatch',
+      'Implementation candidate registration did not match its persisted handler class id',?,?
+    WHERE NOT EXISTS (
+      SELECT 1 FROM diagnostics
+      WHERE repo_id=? AND code='handler_registration_class_mismatch'
+        AND source_file=? AND source_line=?
+    )`);
+  for (const row of rows)
+    insert.run(
+      row.applicationRepoId,
+      row.registrationFile,
+      row.registrationLine,
+      row.applicationRepoId,
+      row.registrationFile,
+      row.registrationLine,
+    );
 }
 
 function deduplicateCandidates(rows: ImplementationCandidate[]): ImplementationCandidate[] {
   const merged = new Map<string, ImplementationCandidate>();
   for (const row of rows) {
     const key = [row.methodId, row.classId, row.handlerRepoId].join(':');
-    const registration = { file: row.registrationFile, line: row.registrationLine, kind: row.registrationKind, importSource: row.importSource };
+    const registration = registrationEvidence(row);
     const existing = merged.get(key);
     if (!existing) {
       merged.set(key, { ...row, registrations: [registration] });
@@ -253,6 +372,19 @@ function deduplicateCandidates(rows: ImplementationCandidate[]): ImplementationC
   }
   return [...merged.values()];
 }
+function registrationEvidence(
+  row: Record<string, unknown>,
+): Record<string, unknown> {
+  return {
+    id: row.registrationId,
+    handlerClassId: row.registrationHandlerClassId,
+    file: row.registrationFile,
+    line: row.registrationLine,
+    kind: row.registrationKind,
+    importSource: row.importSource,
+    pairingStrategy: registrationPairingStrategy(row),
+  };
+}
 function uniqueRegistrations(rows: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
   const seen = new Set<string>();
   return rows.filter((row) => {
@@ -283,10 +415,14 @@ function implementationCandidates(db: Db, workspaceId: number, operation: Record
       hm.method_name methodName,
       hm.decorator_value decoratorValue,
       hm.decorator_raw_expression decoratorRawExpression,
+      hm.decorator_resolution_json decoratorResolutionJson,
       hc.id classId,
       hc.class_name className,
       hc.source_file sourceFile,
       hc.source_line sourceLine,
+      hr.id registrationId,
+      hr.handler_class_id registrationHandlerClassId,
+      hr.class_name registrationClassName,
       hr.repo_id applicationRepoId,
       hr.registration_file registrationFile,
       hr.registration_line registrationLine,
@@ -309,14 +445,36 @@ function implementationCandidates(db: Db, workspaceId: number, operation: Record
       CASE WHEN appRepo.id=handlerRepo.id THEN 1 ELSE 0 END sameRepoRegistration,
       CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id AND localService.service_path=?) THEN 1 ELSE 0 END localServicePathMatch,
       CASE WHEN EXISTS (SELECT 1 FROM cds_services localService WHERE localService.repo_id=appRepo.id) THEN 1 ELSE 0 END applicationHasLocalServices,
-      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON (localClass.id=localReg.handler_class_id OR localClass.class_name=localReg.class_name) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
+      CASE WHEN EXISTS (SELECT 1 FROM handler_registrations localReg JOIN handler_classes localClass ON ((localReg.handler_class_id IS NOT NULL AND localClass.id=localReg.handler_class_id) OR (localReg.handler_class_id IS NULL AND localClass.class_name=localReg.class_name AND localClass.repo_id=localReg.repo_id)) JOIN handler_methods localMethod ON localMethod.handler_class_id=localClass.id WHERE localReg.repo_id=appRepo.id AND (localMethod.decorator_value=? OR localMethod.decorator_value=? OR localMethod.method_name=? OR localMethod.decorator_raw_expression LIKE ?)) THEN 1 ELSE 0 END applicationHasLocalRegistrationForOperation,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END appDependsOnModel,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(appRepo.id AS TEXT) AND dep.to_id=CAST(handlerRepo.id AS TEXT)) THEN 1 ELSE 0 END appDependsOnHandler,
       CASE WHEN EXISTS (SELECT 1 FROM graph_edges dep WHERE dep.edge_type='REPO_IMPORTS_HELPER_PACKAGE' AND dep.status='resolved' AND dep.from_kind='repo' AND dep.from_id=CAST(handlerRepo.id AS TEXT) AND dep.to_id=?) THEN 1 ELSE 0 END handlerDependsOnModel
     FROM handler_methods hm
     JOIN handler_classes hc ON hc.id=hm.handler_class_id
     JOIN repositories handlerRepo ON handlerRepo.id=hc.repo_id
-    JOIN handler_registrations hr ON (hr.handler_class_id=hc.id OR (hr.class_name=hc.class_name AND (hr.repo_id=hc.repo_id OR hr.import_source IS NOT NULL)))
+    JOIN handler_registrations hr ON (
+      (hr.handler_class_id IS NOT NULL AND hr.handler_class_id=hc.id)
+      OR (
+        hr.handler_class_id IS NULL
+        AND (
+          (hr.class_name=hc.class_name AND hr.repo_id=hc.repo_id)
+          OR (
+            instr(hr.import_source,'#')>1
+            AND substr(hr.import_source,1,instr(hr.import_source,'#')-1)
+              =handlerRepo.package_name
+            AND (
+              substr(hr.import_source,instr(hr.import_source,'#')+1)
+                =hc.class_name
+              OR (
+                substr(hr.import_source,instr(hr.import_source,'#')+1)
+                  ='default'
+                AND hr.class_name=hc.class_name
+              )
+            )
+          )
+        )
+      )
+    )
     JOIN repositories appRepo ON appRepo.id=hr.repo_id
     WHERE appRepo.workspace_id=?
       AND (hm.decorator_value=? OR hm.decorator_value=? OR hm.method_name=? OR hm.decorator_raw_expression LIKE ?)`).all(
@@ -418,8 +576,16 @@ function candidateEvidence(candidate: ImplementationCandidate, rank: number): Re
     className: candidate.className,
     sourceFile: candidate.sourceFile,
     sourceLine: candidate.sourceLine,
-    registration: { file: candidate.registrationFile, line: candidate.registrationLine, kind: candidate.registrationKind, importSource: candidate.importSource },
+    decoratorResolution: objectJson(candidate.decoratorResolutionJson),
+    registration: registrationEvidence(candidate),
     registrations: candidate.registrations ?? [],
+    registrationPairing: {
+      strategy: registrationPairingStrategy(candidate),
+      registrationId: candidate.registrationId,
+      registrationHandlerClassId: candidate.registrationHandlerClassId,
+      candidateHandlerClassId: candidate.classId,
+      invariantStatus: validRegistrationPair(candidate) ? 'valid' : 'invalid',
+    },
     applicationPackage: { id: candidate.applicationRepoId, name: candidate.applicationRepo, packageName: candidate.applicationPackage },
     handlerPackage: { id: candidate.handlerRepoId, name: candidate.handlerRepo, packageName: candidate.handlerPackage },
     modelPackage: { id: candidate.modelRepoId, name: candidate.modelRepo, packageName: candidate.modelPackage },

package/src/linker/operation-decorator-normalizer.ts

@@ -12,7 +12,7 @@ export function normalizedOperationName(value: string): string {
 function clean(value: string): string {
   return value.replace(/^[`'"]|[`'"]$/g, '');
 }
-function generatedFromConstantName(value: string): string | undefined {
+export function generatedOperationNameFromConstant(value: string): string | undefined {
   for (const prefix of ['Action', 'Func']) {
     if (value.startsWith(prefix) && value.length > prefix.length && /^[A-Z]/.test(value.slice(prefix.length))) return lowerFirst(value.slice(prefix.length));
   }
@@ -20,7 +20,7 @@ function generatedFromConstantName(value: string): string | undefined {
 }
 function resolved(value: string, raw?: string): DecoratorOperationSignal {
   const literal = clean(value);
-  const generated = generatedFromConstantName(literal);
+  const generated = generatedOperationNameFromConstant(literal);
   return { status: 'resolved', operationName: generated ?? normalizedOperationName(literal), raw };
 }
 export function normalizeDecoratorOperationSignal(value: string | undefined, raw: string | undefined, candidateOperation?: string): DecoratorOperationSignal {
@@ -32,7 +32,7 @@ export function normalizeDecoratorOperationSignal(value: string | undefined, raw
   const stringMatch = /^String\(([A-Za-z_$][\w$]*)\)$/.exec(expression);
   if (stringMatch?.[1]) {
     const identifier = stringMatch[1];
-    const generated = generatedFromConstantName(identifier);
+    const generated = generatedOperationNameFromConstant(identifier);
     const normalizedCandidate = candidateOperation ? normalizedOperationName(candidateOperation) : undefined;
     if (generated) return { status: 'resolved', operationName: generated, raw: expression };
     if (normalizedCandidate && identifier === normalizedCandidate) return { status: 'resolved', operationName: identifier, raw: expression };

package/src/output/table-output.ts

@@ -15,8 +15,8 @@ export function renderTraceTable(result: TraceResult): string {
   const lines = ['Step  Type                 From                                To                                  Evidence'];
   for (const e of result.edges) {
     lines.push(`${String(e.step).padEnd(5)} ${e.type.padEnd(20)} ${e.from.slice(0, 34).padEnd(35)} ${e.to.slice(0, 35).padEnd(36)} ${location(e.evidence)}`);
-    const hint = firstHint(e.evidence);
-    if (e.unresolvedReason && hint) lines.push(`      try ${hint}`);
+    if (e.unresolvedReason)
+      lines.push(...hintLines(e.evidence).map((hint) => `      ${hint}`));
   }
   if (result.diagnostics.length > 0) lines.push('', 'Diagnostics:', ...result.diagnostics.flatMap(diagnosticLines));
   return `${lines.join('\n')}\n`;
@@ -24,13 +24,23 @@ export function renderTraceTable(result: TraceResult): string {
 
 function diagnosticLines(diagnostic: Record<string, unknown>): string[] {
   const first = `${String(diagnostic.severity ?? 'info')} ${String(diagnostic.code ?? 'diagnostic')} ${String(diagnostic.message ?? '')}`;
-  const hint = firstHint(diagnostic);
-  return hint ? [first, `  try ${hint}`] : [first];
+  return [first, ...hintLines(diagnostic).map((hint) => `  ${hint}`)];
 }
 
-function firstHint(evidence: Record<string, unknown>): string | undefined {
+function hintLines(evidence: Record<string, unknown>): string[] {
   const suggestions = evidence.implementationHintSuggestions;
-  if (!Array.isArray(suggestions)) return undefined;
-  const first = suggestions.find((item): item is Record<string, unknown> => Boolean(item) && typeof item === 'object');
-  return typeof first?.cli === 'string' ? first.cli : undefined;
+  if (!Array.isArray(suggestions)) return [];
+  const hints = suggestions.flatMap((item) =>
+    isRecord(item) && typeof item.cli === 'string'
+      ? [item.cli]
+      : []);
+  const unique = [...new Set(hints)];
+  const shown = unique.slice(0, 3).map((hint) => `try ${hint}`);
+  if (unique.length > shown.length)
+    shown.push(`... ${unique.length - shown.length} more hint(s) available in JSON`);
+  return shown;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }

package/src/parsers/decorator-parser.ts

@@ -1,9 +1,18 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import ts from 'typescript';
-import type { HandlerClassFact } from '../types.js';
+import type { HandlerClassFact, HandlerMethodFact } from '../types.js';
+import { generatedOperationNameFromConstant } from '../linker/operation-decorator-normalizer.js';
 import { createSourceFile } from './ts-project.js';
-import { normalizePath, stripQuotes } from '../utils/path-utils.js';
+import { normalizePath } from '../utils/path-utils.js';
+
+type DecoratorResolution = HandlerMethodFact['decoratorResolution'];
+interface StringLookups {
+  identifiers: Map<string, string>;
+  enumMembers: Map<string, string>;
+  objectProperties: Map<string, string>;
+}
+
 function line(sf: ts.SourceFile, pos: number): number {
   return sf.getLineAndCharacterOfPosition(pos).line + 1;
 }
@@ -14,11 +23,119 @@ function callName(d: ts.Decorator): string {
   const e = d.expression;
   return ts.isCallExpression(e) ? e.expression.getText() : e.getText();
 }
-function firstArg(d: ts.Decorator): string {
+function firstArg(d: ts.Decorator): ts.Expression | undefined {
   const e = d.expression;
-  return ts.isCallExpression(e) && e.arguments[0]
-    ? e.arguments[0].getText()
-    : '';
+  return ts.isCallExpression(e) ? e.arguments[0] : undefined;
+}
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  let current = expression;
+  while (
+    ts.isParenthesizedExpression(current)
+    || ts.isAsExpression(current)
+    || ts.isTypeAssertionExpression(current)
+    || ts.isSatisfiesExpression(current)
+  ) current = current.expression;
+  return current;
+}
+function stringValue(expression: ts.Expression | undefined): string | undefined {
+  if (!expression) return undefined;
+  const unwrapped = unwrapExpression(expression);
+  return ts.isStringLiteralLike(unwrapped) ? unwrapped.text : undefined;
+}
+function propertyName(node: ts.PropertyName): string | undefined {
+  if (ts.isIdentifier(node) || ts.isStringLiteralLike(node)) return node.text;
+  return undefined;
+}
+function collectEnumMembers(
+  statement: ts.EnumDeclaration,
+  lookups: StringLookups,
+): void {
+  for (const member of statement.members) {
+    const name = propertyName(member.name);
+    const value = stringValue(member.initializer);
+    if (name && value !== undefined)
+      lookups.enumMembers.set(`${statement.name.text}.${name}`, value);
+  }
+}
+function collectObjectProperties(
+  name: string,
+  initializer: ts.Expression,
+  lookups: StringLookups,
+): void {
+  const object = unwrapExpression(initializer);
+  if (!ts.isObjectLiteralExpression(object)) return;
+  for (const property of object.properties) {
+    if (!ts.isPropertyAssignment(property)) continue;
+    const key = propertyName(property.name);
+    const value = stringValue(property.initializer);
+    if (key && value !== undefined)
+      lookups.objectProperties.set(`${name}.${key}`, value);
+  }
+}
+function collectStringLookups(source: ts.SourceFile): StringLookups {
+  const lookups: StringLookups = {
+    identifiers: new Map(),
+    enumMembers: new Map(),
+    objectProperties: new Map(),
+  };
+  for (const statement of source.statements) {
+    if (ts.isEnumDeclaration(statement)) collectEnumMembers(statement, lookups);
+    if (!ts.isVariableStatement(statement)
+      || !(statement.declarationList.flags & ts.NodeFlags.Const)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+      const value = stringValue(declaration.initializer);
+      if (value !== undefined) lookups.identifiers.set(declaration.name.text, value);
+      collectObjectProperties(declaration.name.text, declaration.initializer, lookups);
+    }
+  }
+  return lookups;
+}
+function unresolved(rawExpression: string, reason: string): DecoratorResolution {
+  return { rawExpression, resolutionKind: 'unresolved', unresolvedReason: reason };
+}
+function generatedConstant(rawExpression: string): string | undefined {
+  const match = /(?:^|\.)(Action[A-Z][\w$]*|Func[A-Z][\w$]*)\.name$/
+    .exec(rawExpression.trim());
+  return match?.[1]
+    ? generatedOperationNameFromConstant(match[1])
+    : undefined;
+}
+function resolveDecoratorArgument(
+  argument: ts.Expression | undefined,
+  lookups: StringLookups,
+): DecoratorResolution {
+  if (!argument) return unresolved('', 'decorator_argument_missing');
+  const rawExpression = argument.getText();
+  const expression = unwrapExpression(argument);
+  if (ts.isStringLiteralLike(expression))
+    return { rawExpression, resolvedValue: expression.text, resolutionKind: 'literal' };
+  if (ts.isIdentifier(expression)) {
+    const value = lookups.identifiers.get(expression.text);
+    return value === undefined
+      ? unresolved(rawExpression, 'identifier_not_resolved_to_local_const_string')
+      : { rawExpression, resolvedValue: value, resolutionKind: 'const_identifier' };
+  }
+  if (ts.isPropertyAccessExpression(expression)
+    && ts.isIdentifier(expression.expression)) {
+    const key = `${expression.expression.text}.${expression.name.text}`;
+    const enumValue = lookups.enumMembers.get(key);
+    if (enumValue !== undefined)
+      return { rawExpression, resolvedValue: enumValue, resolutionKind: 'enum_member' };
+    const objectValue = lookups.objectProperties.get(key);
+    if (objectValue !== undefined)
+      return { rawExpression, resolvedValue: objectValue, resolutionKind: 'const_object_property' };
+  }
+  const generatedValue = generatedConstant(rawExpression);
+  if (generatedValue !== undefined)
+    return {
+      rawExpression,
+      resolvedValue: generatedValue,
+      resolutionKind: 'generated_constant_name',
+    };
+  if (ts.isPropertyAccessExpression(expression))
+    return unresolved(rawExpression, 'property_access_not_resolved_to_local_string');
+  return unresolved(rawExpression, 'unsupported_decorator_expression');
 }
 export async function parseDecorators(
   repoPath: string,
@@ -26,16 +143,9 @@ export async function parseDecorators(
 ): Promise<HandlerClassFact[]> {
   const text = await fs.readFile(path.join(repoPath, filePath), 'utf8');
   const sf = createSourceFile(filePath, text);
-  const constants = new Map<string, string>();
+  const lookups = collectStringLookups(sf);
   const handlers: HandlerClassFact[] = [];
   function visit(node: ts.Node): void {
-    if (
-      ts.isVariableDeclaration(node) &&
-      ts.isIdentifier(node.name) &&
-      node.initializer &&
-      ts.isStringLiteralLike(node.initializer)
-    )
-      constants.set(node.name.text, node.initializer.text);
     if (ts.isClassDeclaration(node)) {
       const className = node.name?.text ?? 'AnonymousHandler';
       const hasHandler = decs(node).some((d) => callName(d) === 'Handler');
@@ -45,17 +155,13 @@ export async function parseDecorators(
             ['Func', 'Action', 'On', 'Event'].includes(callName(d))
           )
           .map((d) => {
-            const raw = firstArg(d);
-            const value =
-              raw.startsWith('"') || raw.startsWith("'") || raw.startsWith('`')
-                ? stripQuotes(raw)
-                : (constants.get(raw) ??
-                  (raw.endsWith('.name') ? raw.split('.').at(-2) : undefined));
+            const decoratorResolution = resolveDecoratorArgument(firstArg(d), lookups);
             return {
               methodName: m.name.getText(),
               decoratorKind: callName(d),
-              decoratorValue: value,
-              decoratorRawExpression: raw,
+              decoratorValue: decoratorResolution.resolvedValue,
+              decoratorRawExpression: decoratorResolution.rawExpression,
+              decoratorResolution,
               sourceFile: normalizePath(filePath),
               sourceLine: line(sf, m.getStart())
             };

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

@@ -4,6 +4,11 @@ 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';
+import {
+  analyzeOperationPath,
+  operationPathExpression,
+  pathUnresolvedReason,
+} from './operation-path-analysis.js';
 
 interface WrapperSpec {
   clientIndex: number;
@@ -15,12 +20,6 @@ interface WrapperSpec {
   chain: string[];
 }
 
-interface PathValue {
-  value?: string;
-  sourceKind: string;
-  rawExpression: string;
-}
-
 export async function parseImportedWrapperCalls(
   repoPath: string,
   filePath: string,
@@ -143,11 +142,11 @@ function wrapperCallFact(
 ): 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);
+  const pathAnalysis = analyzeOperationPath(call.arguments[spec.pathIndex], call, method);
+  const operationPathExpr = operationPathExpression(pathAnalysis);
+  const unresolvedReason = pathUnresolvedReason(pathAnalysis);
   return {
     callType: 'remote_action',
     serviceVariableName: client.text,
@@ -157,46 +156,29 @@ function wrapperCallFact(
     sourceFile: normalizePath(filePath),
     sourceLine: lineOf(source, call),
     confidence: operationPathExpr ? 0.85 : 0.5,
-    unresolvedReason: pathValue.value ? undefined : 'dynamic_operation_path_identifier',
+    unresolvedReason,
     evidence: {
       parser: 'typescript_ast',
-      classifier: pathValue.value ? 'imported_wrapper_literal_path' : 'imported_wrapper_dynamic_path',
+      classifier: importedWrapperClassifier(pathAnalysis.status),
       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,
+      rawPathExpression: pathAnalysis.rawExpression,
+      missingPathIdentifier: pathAnalysis.runtimeIdentifier,
+      pathAnalysis,
+      odataPathIntent: operationPathExpr
+        ? 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 importedWrapperClassifier(status: string): string {
+  if (status === 'static') return 'imported_wrapper_literal_path';
+  if (status === 'ambiguous') return 'imported_wrapper_ambiguous_path';
+  return 'imported_wrapper_dynamic_path';
 }
 
 function findFunction(source: ts.SourceFile, exportedName: string): { name: string; fn: ts.FunctionLikeDeclaration } | undefined {
@@ -252,11 +234,3 @@ function propertyName(name: ts.PropertyName): string | 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;
-}