@saptools/service-flow 0.1.40 → 0.1.42

package/dist/index.d.ts

@@ -30,6 +30,14 @@ interface CdsServiceFact {
     sourceFile: string;
     sourceLine: number;
     operations: CdsOperationFact[];
+    extension?: CdsExtensionFact;
+}
+interface CdsExtensionFact {
+    localReference: string;
+    importedSymbol?: string;
+    localAlias?: string;
+    moduleSpecifier?: string;
+    importKind?: 'relative' | 'package' | 'none';
 }
 interface CdsOperationFact {
     operationType: 'action' | 'function' | 'event';
@@ -39,6 +47,8 @@ interface CdsOperationFact {
     returnType?: string;
     sourceFile: string;
     sourceLine: number;
+    provenance?: 'direct' | 'inherited';
+    baseOperationId?: number;
 }
 interface HandlerClassFact {
     className: string;

package/dist/index.js

@@ -16,7 +16,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-774PPGGK.js";
+} from "./chunk-RP3BJ64F.js";
 
 // src/parsers/generated-constants-parser.ts
 import fs from "fs/promises";

package/package.json

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

package/src/db/migrations.ts

@@ -1,6 +1,6 @@
 import type { Db } from './connection.js';
 import { schemaSql } from './schema.js';
-const CURRENT_SCHEMA_VERSION = 8;
+const CURRENT_SCHEMA_VERSION = 9;
 const columns: Record<string, Array<{ name: string; ddl: string }>> = {
   service_bindings: [
     { name: 'helper_chain_json', ddl: 'ALTER TABLE service_bindings ADD COLUMN helper_chain_json TEXT' },
@@ -29,6 +29,19 @@ const columns: Record<string, Array<{ name: string; ddl: string }>> = {
     { name: 'exported_name', ddl: 'ALTER TABLE symbols ADD COLUMN exported_name TEXT' },
     { name: 'evidence_json', ddl: 'ALTER TABLE symbols ADD COLUMN evidence_json TEXT' },
   ],
+  cds_services: [
+    { name: 'extension_local_ref', ddl: 'ALTER TABLE cds_services ADD COLUMN extension_local_ref TEXT' },
+    { name: 'extension_imported_symbol', ddl: 'ALTER TABLE cds_services ADD COLUMN extension_imported_symbol TEXT' },
+    { name: 'extension_local_alias', ddl: 'ALTER TABLE cds_services ADD COLUMN extension_local_alias TEXT' },
+    { name: 'extension_module_specifier', ddl: 'ALTER TABLE cds_services ADD COLUMN extension_module_specifier TEXT' },
+    { name: 'extension_import_kind', ddl: 'ALTER TABLE cds_services ADD COLUMN extension_import_kind TEXT' },
+    { name: 'extension_base_service_id', ddl: 'ALTER TABLE cds_services ADD COLUMN extension_base_service_id INTEGER' },
+    { name: 'extension_base_status', ddl: 'ALTER TABLE cds_services ADD COLUMN extension_base_status TEXT' },
+  ],
+  cds_operations: [
+    { name: 'provenance', ddl: "ALTER TABLE cds_operations ADD COLUMN provenance TEXT NOT NULL DEFAULT 'direct'" },
+    { name: 'base_operation_id', ddl: 'ALTER TABLE cds_operations ADD COLUMN base_operation_id INTEGER' },
+  ],
   outbound_calls: [
     { name: 'local_service_name', ddl: 'ALTER TABLE outbound_calls ADD COLUMN local_service_name TEXT' },
     { name: 'local_service_lookup', ddl: 'ALTER TABLE outbound_calls ADD COLUMN local_service_lookup TEXT' },

package/src/db/repositories.ts

@@ -139,7 +139,7 @@ export function insertService(
   const id = Number(
     db
       .prepare(
-        'INSERT INTO cds_services(repo_id,namespace,service_name,qualified_name,service_path,is_extend,source_file,source_line) VALUES(?,?,?,?,?,?,?,?) RETURNING id',
+        'INSERT INTO cds_services(repo_id,namespace,service_name,qualified_name,service_path,is_extend,source_file,source_line,extension_local_ref,extension_imported_symbol,extension_local_alias,extension_module_specifier,extension_import_kind) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?) RETURNING id',
       )
       .get(
         repoId,
@@ -150,10 +150,15 @@ export function insertService(
         s.isExtend ? 1 : 0,
         s.sourceFile,
         s.sourceLine,
+        s.extension?.localReference,
+        s.extension?.importedSymbol,
+        s.extension?.localAlias,
+        s.extension?.moduleSpecifier,
+        s.extension?.importKind,
       )?.id,
   );
   const stmt = db.prepare(
-    'INSERT INTO cds_operations(service_id,operation_type,operation_name,operation_path,params_json,return_type,source_file,source_line) VALUES(?,?,?,?,?,?,?,?)',
+    'INSERT INTO cds_operations(service_id,operation_type,operation_name,operation_path,params_json,return_type,source_file,source_line,provenance,base_operation_id) VALUES(?,?,?,?,?,?,?,?,?,?)',
   );
   db.prepare(
     'INSERT INTO search_index(kind,name,path,repo) VALUES(?,?,?,?)',
@@ -168,6 +173,8 @@ export function insertService(
       o.returnType,
       o.sourceFile,
       o.sourceLine,
+      o.provenance ?? 'direct',
+      o.baseOperationId ?? null,
     );
   const search = db.prepare(
     'INSERT INTO search_index(kind,name,path,repo) VALUES(?,?,?,?)',

package/src/db/schema.ts

@@ -3,8 +3,8 @@ CREATE TABLE IF NOT EXISTS workspaces (id INTEGER PRIMARY KEY, root_path TEXT UN
 CREATE TABLE IF NOT EXISTS repositories (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, name TEXT NOT NULL, absolute_path TEXT NOT NULL, relative_path TEXT NOT NULL, package_name TEXT, package_version TEXT, dependencies_json TEXT DEFAULT '{}', kind TEXT NOT NULL, is_git_repo INTEGER NOT NULL, last_indexed_at TEXT, index_status TEXT DEFAULT 'pending', error_count INTEGER DEFAULT 0, fingerprint TEXT, fact_generation INTEGER NOT NULL DEFAULT 0, graph_generation INTEGER NOT NULL DEFAULT 0, graph_stale_reason TEXT, graph_stale_at TEXT, fact_analyzer_version TEXT, UNIQUE(workspace_id, absolute_path), FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS files (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, relative_path TEXT NOT NULL, extension TEXT NOT NULL, sha256 TEXT NOT NULL, size_bytes INTEGER NOT NULL, last_indexed_at TEXT NOT NULL, UNIQUE(repo_id, relative_path), FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS cds_requires (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, alias TEXT NOT NULL, kind TEXT, model TEXT, destination TEXT, service_path TEXT, request_timeout INTEGER, raw_json TEXT NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS cds_services (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, namespace TEXT, service_name TEXT NOT NULL, qualified_name TEXT NOT NULL, service_path TEXT NOT NULL, is_extend INTEGER NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
-CREATE TABLE IF NOT EXISTS cds_operations (id INTEGER PRIMARY KEY, service_id INTEGER NOT NULL, operation_type TEXT NOT NULL, operation_name TEXT NOT NULL, operation_path TEXT NOT NULL, params_json TEXT NOT NULL, return_type TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(service_id) REFERENCES cds_services(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS cds_services (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, namespace TEXT, service_name TEXT NOT NULL, qualified_name TEXT NOT NULL, service_path TEXT NOT NULL, is_extend INTEGER NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, extension_local_ref TEXT, extension_imported_symbol TEXT, extension_local_alias TEXT, extension_module_specifier TEXT, extension_import_kind TEXT, extension_base_service_id INTEGER, extension_base_status TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(extension_base_service_id) REFERENCES cds_services(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS cds_operations (id INTEGER PRIMARY KEY, service_id INTEGER NOT NULL, operation_type TEXT NOT NULL, operation_name TEXT NOT NULL, operation_path TEXT NOT NULL, params_json TEXT NOT NULL, return_type TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, provenance TEXT NOT NULL DEFAULT 'direct', base_operation_id INTEGER, FOREIGN KEY(service_id) REFERENCES cds_services(id) ON DELETE CASCADE, FOREIGN KEY(base_operation_id) REFERENCES cds_operations(id) ON DELETE SET NULL);
 CREATE TABLE IF NOT EXISTS symbols (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, file_id INTEGER, kind TEXT NOT NULL, name TEXT NOT NULL, qualified_name TEXT NOT NULL, exported INTEGER NOT NULL, start_line INTEGER NOT NULL, end_line INTEGER NOT NULL, start_offset INTEGER, end_offset INTEGER, source_file TEXT, exported_name TEXT, evidence_json TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS handler_classes (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, symbol_id INTEGER, class_name TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
 CREATE TABLE IF NOT EXISTS handler_methods (id INTEGER PRIMARY KEY, handler_class_id INTEGER NOT NULL, method_name TEXT NOT NULL, decorator_kind TEXT NOT NULL, decorator_value TEXT, decorator_raw_expression TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(handler_class_id) REFERENCES handler_classes(id) ON DELETE CASCADE);
@@ -17,7 +17,9 @@ CREATE TABLE IF NOT EXISTS index_runs (id INTEGER PRIMARY KEY, workspace_id INTE
 CREATE TABLE IF NOT EXISTS diagnostics (id INTEGER PRIMARY KEY, repo_id INTEGER, file_id INTEGER, severity TEXT NOT NULL, code TEXT NOT NULL, message TEXT NOT NULL, source_file TEXT, source_line INTEGER, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE SET NULL);
 CREATE INDEX IF NOT EXISTS idx_repo_name ON repositories(name);
 CREATE INDEX IF NOT EXISTS idx_service_path ON cds_services(service_path);
+CREATE INDEX IF NOT EXISTS idx_extension_import ON cds_services(extension_module_specifier, extension_imported_symbol, is_extend);
 CREATE INDEX IF NOT EXISTS idx_operation_name ON cds_operations(operation_name, operation_path);
+CREATE INDEX IF NOT EXISTS idx_operation_base ON cds_operations(base_operation_id);
 CREATE INDEX IF NOT EXISTS idx_calls_repo ON outbound_calls(repo_id, call_type);
 CREATE INDEX IF NOT EXISTS idx_symbol_calls_caller ON symbol_calls(repo_id, caller_symbol_id);
 CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(kind, name, path, repo);

package/src/indexer/cds-extension-resolver.ts

@@ -0,0 +1,88 @@
+import type { Db } from '../db/connection.js';
+
+interface ExtensionRow {
+  id: number;
+  repoId: number;
+  serviceName: string;
+  qualifiedName: string;
+  sourceFile: string;
+  moduleSpecifier?: string | null;
+  importedSymbol?: string | null;
+  importKind?: string | null;
+}
+interface BaseRow { id: number; repoId: number }
+
+export function materializeCdsExtensionOperations(db: Db, workspaceId: number): void {
+  const extensions = db.prepare(`SELECT s.id,r.id repoId,s.service_name serviceName,s.qualified_name qualifiedName,s.source_file sourceFile,s.extension_module_specifier moduleSpecifier,s.extension_imported_symbol importedSymbol,s.extension_import_kind importKind
+    FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND s.is_extend=1`).all(workspaceId) as unknown as ExtensionRow[];
+  for (const extension of extensions) {
+    const bases = resolveBase(db, workspaceId, extension);
+    const status = bases.length === 1 ? 'resolved' : bases.length > 1 ? 'ambiguous' : 'unresolved';
+    db.prepare('UPDATE cds_services SET extension_base_status=?, extension_base_service_id=? WHERE id=?').run(status, status === 'resolved' ? bases[0]?.id : null, extension.id);
+    if (bases.length !== 1) {
+      db.prepare("DELETE FROM cds_operations WHERE service_id=? AND provenance='inherited'").run(extension.id);
+      db.prepare("DELETE FROM search_index WHERE repo=? AND kind='operation' AND name NOT IN (SELECT operation_name FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE s.repo_id=?)").run(String(extension.repoId), extension.repoId);
+      continue;
+    }
+    reconcileInheritedOperations(db, extension, bases[0]);
+  }
+}
+
+function reconcileInheritedOperations(db: Db, extension: ExtensionRow, base: BaseRow): void {
+  const existing = db.prepare("SELECT id,operation_name operationName,operation_path operationPath,base_operation_id baseOperationId FROM cds_operations WHERE service_id=? AND provenance='inherited'").all(extension.id) as Array<{ id: number; operationName: string; operationPath: string; baseOperationId: number | null }>;
+  const desired = db.prepare("SELECT id,operation_type operationType,operation_name operationName,operation_path operationPath,params_json paramsJson,return_type returnType,source_file sourceFile,source_line sourceLine FROM cds_operations WHERE service_id=? AND provenance='direct' AND NOT EXISTS (SELECT 1 FROM cds_operations direct WHERE direct.service_id=? AND direct.provenance='direct' AND direct.operation_name=cds_operations.operation_name AND direct.operation_path=cds_operations.operation_path)").all(base.id, extension.id) as Array<Record<string, unknown>>;
+  const desiredKeys = new Set(desired.map((row) => `${String(row.operationName)}\0${String(row.operationPath)}`));
+  const byKey = new Map(existing.map((row) => [`${row.operationName}\0${row.operationPath}`, row]));
+  for (const row of existing) {
+    if (!desiredKeys.has(`${row.operationName}\0${row.operationPath}`)) db.prepare('DELETE FROM cds_operations WHERE id=?').run(row.id);
+  }
+  const update = db.prepare('UPDATE cds_operations SET operation_type=?,params_json=?,return_type=?,source_file=?,source_line=?,base_operation_id=? WHERE id=?');
+  const add = db.prepare("INSERT INTO cds_operations(service_id,operation_type,operation_name,operation_path,params_json,return_type,source_file,source_line,provenance,base_operation_id) VALUES(?,?,?,?,?,?,?,?,'inherited',?)");
+  const search = db.prepare('INSERT INTO search_index(kind,name,path,repo) SELECT ?,?,?,? WHERE NOT EXISTS (SELECT 1 FROM search_index WHERE kind=? AND name=? AND path=? AND repo=?)');
+  for (const row of desired) {
+    const key = `${String(row.operationName)}\0${String(row.operationPath)}`;
+    const current = byKey.get(key);
+    if (current) update.run(row.operationType, row.paramsJson, row.returnType, row.sourceFile, row.sourceLine, row.id, current.id);
+    else add.run(extension.id, row.operationType, row.operationName, row.operationPath, row.paramsJson, row.returnType, row.sourceFile, row.sourceLine, row.id);
+    search.run('operation', row.operationName, row.operationPath, String(extension.repoId), 'operation', row.operationName, row.operationPath, String(extension.repoId));
+  }
+}
+
+function resolveBase(db: Db, workspaceId: number, extension: ExtensionRow): BaseRow[] {
+  const symbol = extension.importedSymbol ?? extension.serviceName;
+  if (extension.importKind === 'relative' && extension.moduleSpecifier) return relativeBase(db, extension, symbol);
+  if (extension.importKind === 'package' && extension.moduleSpecifier) return packageBase(db, workspaceId, extension.moduleSpecifier, symbol);
+  return sameRepoBase(db, extension, symbol);
+}
+
+function relativeBase(db: Db, extension: ExtensionRow, symbol: string): BaseRow[] {
+  const modulePath = normalizeModulePath(extension.sourceFile, extension.moduleSpecifier ?? '');
+  return db.prepare(`SELECT s.id,s.repo_id repoId FROM cds_services s WHERE s.repo_id=? AND s.is_extend=0 AND (s.qualified_name=? OR s.service_name=?) AND (s.source_file=? OR s.source_file=?) ORDER BY s.id`).all(extension.repoId, symbol, symbol, modulePath, `${modulePath}.cds`) as unknown as BaseRow[];
+}
+
+function packageBase(db: Db, workspaceId: number, specifier: string, symbol: string): BaseRow[] {
+  const packageName = packageNameFromSpecifier(specifier);
+  const moduleSuffix = specifier.slice(packageName.length).replace(/^\//, '');
+  return db.prepare(`SELECT s.id,s.repo_id repoId FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND s.is_extend=0 AND r.package_name=? AND (s.qualified_name=? OR s.service_name=?) AND (?='' OR s.source_file=? OR s.source_file=?) ORDER BY s.id`).all(workspaceId, packageName, symbol, symbol, moduleSuffix, moduleSuffix, `${moduleSuffix}.cds`) as unknown as BaseRow[];
+}
+
+function sameRepoBase(db: Db, extension: ExtensionRow, symbol: string): BaseRow[] {
+  return db.prepare('SELECT id,repo_id repoId FROM cds_services WHERE repo_id=? AND is_extend=0 AND (qualified_name=? OR service_name=?) ORDER BY id').all(extension.repoId, symbol, symbol) as unknown as BaseRow[];
+}
+
+function normalizeModulePath(sourceFile: string, specifier: string): string {
+  const base = sourceFile.split('/').slice(0, -1).join('/');
+  const parts = `${base}/${specifier}`.split('/');
+  const out: string[] = [];
+  for (const part of parts) {
+    if (!part || part === '.') continue;
+    if (part === '..') out.pop();
+    else out.push(part);
+  }
+  return out.join('/').replace(/\.cds$/, '');
+}
+
+function packageNameFromSpecifier(specifier: string): string {
+  const parts = specifier.split('/');
+  return specifier.startsWith('@') ? `${parts[0]}/${parts[1]}` : parts[0] ?? specifier;
+}

package/src/indexer/workspace-indexer.ts

@@ -2,6 +2,7 @@ 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 { materializeCdsExtensionOperations } from './cds-extension-resolver.js';
 export async function indexWorkspace(
   db: Db,
   workspaceId: number,
@@ -20,6 +21,7 @@ export async function indexWorkspace(
       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);
     return { repoCount: repos.length, indexedCount: repos.length - skippedCount, skippedCount, fileCount, diagnosticCount };
   } catch (error) {

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

@@ -150,13 +150,14 @@ function callEvidence(call: Record<string, unknown>, resolution: { target?: { re
 }
 
 function linkImplementations(db: Db, workspaceId: number, generation: number): { edgeCount: number; resolvedCount: number; ambiguousCount: number; unresolvedCount: number } {
-  const operations = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=?`).all(workspaceId) as Array<Record<string, unknown>>;
+  const operations = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=?`).all(workspaceId) as Array<Record<string, unknown>>;
   let edgeCount = 0;
   let resolvedCount = 0;
   let ambiguousCount = 0;
   let unresolvedCount = 0;
   for (const operation of operations) {
-    const candidates = rankedImplementationCandidates(db, workspaceId, operation);
+    const implementationContext = implementationContextForOperation(db, operation);
+    const candidates = rankedImplementationCandidates(db, workspaceId, implementationContext);
     if (candidates.length === 0) continue;
     const accepted = candidates.filter((candidate) => candidate.accepted);
     const topScore = accepted[0]?.score ?? 0;
@@ -167,6 +168,9 @@ function linkImplementations(db: Db, workspaceId: number, generation: number): {
       operationPath: operation.operationPath,
       operationName: operation.operationName,
       modelPackage: { id: operation.modelRepoId, name: operation.modelRepo, packageName: operation.modelPackage },
+      implementationSource: implementationContext.operationId === operation.operationId ? 'direct_or_concrete_override' : 'inherited_from_base_operation',
+      baseOperationId: operation.baseOperationId,
+      implementationOperationId: implementationContext.operationId,
       candidates: candidates.map((candidate, index) => candidateEvidence(candidate, index + 1)),
     };
     if (accepted.length === 0) {
@@ -190,6 +194,12 @@ interface ImplementationCandidate extends Record<string, unknown> {
   acceptedReasons: string[];
   rejectedReasons: string[];
 }
+function implementationContextForOperation(db: Db, operation: Record<string, unknown>): Record<string, unknown> {
+  if (operation.provenance !== 'inherited' || !operation.baseOperationId) return operation;
+  const base = db.prepare(`SELECT o.id operationId,o.operation_path operationPath,o.operation_name operationName,o.provenance provenance,o.base_operation_id baseOperationId,s.service_path servicePath,s.repo_id modelRepoId,r.name modelRepo,r.package_name modelPackage,r.kind modelKind FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE o.id=?`).get(operation.baseOperationId) as Record<string, unknown> | undefined;
+  if (!base) return operation;
+  return { ...base, effectiveOperationId: operation.operationId, effectiveServicePath: operation.servicePath, effectiveOperationPath: operation.operationPath };
+}
 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);

package/src/parsers/cds-parser.ts

@@ -45,6 +45,23 @@ function maskCommentsAndStrings(text: string): string {
   return out;
 }
 
+function maskComments(text: string): string {
+  let out = '';
+  let mode: 'code' | 'line' | 'block' | 'single' | 'double' | 'template' = 'code';
+  for (let i = 0; i < text.length; i += 1) {
+    const c = text[i] ?? '';
+    const n = text[i + 1] ?? '';
+    if (mode === 'code' && c === '/' && n === '/') { mode = 'line'; out += '  '; i += 1; continue; }
+    if (mode === 'code' && c === '/' && n === '*') { mode = 'block'; out += '  '; i += 1; continue; }
+    if (mode === 'line' && c === '\n') mode = 'code';
+    if (mode === 'block' && c === '*' && n === '/') { mode = 'code'; out += '  '; i += 1; continue; }
+    if (mode === 'code' && (c === "'" || c === '"' || c === '`')) mode = c === "'" ? 'single' : c === '"' ? 'double' : 'template';
+    else if ((mode === 'single' && c === "'") || (mode === 'double' && c === '"') || (mode === 'template' && c === '`')) mode = 'code';
+    out += mode === 'line' || mode === 'block' ? (c === '\n' ? '\n' : ' ') : c;
+  }
+  return out;
+}
+
 function readAnnotation(text: string, index: number): { end: number; raw: string } | undefined {
   if (text[index] !== '@') return undefined;
   let i = index + 1;
@@ -90,6 +107,23 @@ function annotationRawAt(original: string, masked: string, index: number): { end
   return { end: collected.end, raw: original.slice(index, collected.end) };
 }
 
+
+interface CdsUsing { importedSymbol: string; localAlias: string; moduleSpecifier: string; importKind: 'relative' | 'package' }
+function collectUsings(masked: string): Map<string, CdsUsing> {
+  const imports = new Map<string, CdsUsing>();
+  for (const m of masked.matchAll(/\busing\s*\{([^}]*)\}\s*from\s*(['"])(.*?)\2\s*;/gs)) {
+    const moduleSpecifier = m[3] ?? '';
+    for (const part of (m[1] ?? '').split(',')) {
+      const text = part.trim();
+      if (!text) continue;
+      const alias = /^(\w+)\s+as\s+(\w+)$/.exec(text) ?? /^(\w+)\s*:\s*(\w+)$/.exec(text);
+      const importedSymbol = alias?.[1] ?? text;
+      const localAlias = alias?.[2] ?? importedSymbol;
+      imports.set(localAlias, { importedSymbol, localAlias, moduleSpecifier, importKind: moduleSpecifier.startsWith('.') ? 'relative' : 'package' });
+    }
+  }
+  return imports;
+}
 function operationsFromBody(text: string, maskedBody: string, bodyOffset: number, filePath: string): CdsOperationFact[] {
   return [...maskedBody.matchAll(/\b(action|function|event)\s+(\w+)\s*(?:\(([^)]*)\))?\s*(?:returns\s+([^;{]+))?/g)].map((m) => ({
     operationType: (m[1] as 'action' | 'function' | 'event') ?? 'action',
@@ -109,6 +143,7 @@ export async function parseCdsFile(repoPath: string, filePath: string): Promise<
   const namespace = /namespace\s+([\w.]+)\s*;/.exec(masked)?.[1];
   const services: CdsServiceFact[] = [];
   const pendingAnnotations: Array<{ end: number; raw: string }> = [];
+  const usings = collectUsings(maskComments(text));
   for (const a of masked.matchAll(/@\s*\(/g)) pendingAnnotations.push(annotationRawAt(text, masked, a.index ?? 0));
   const serviceRegex = /\b(?:(extend)\s+)?(?:(service)\s+)?([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\b/g;
   let match: RegExpExecArray | null;
@@ -131,6 +166,7 @@ export async function parseCdsFile(repoPath: string, filePath: string): Promise<
     const body = masked.slice(open + 1, end);
     const name = match[3] ?? 'UnknownService';
     const serviceName = name.split('.').pop() ?? name;
+    const imported = isExtend ? usings.get(name) ?? usings.get(serviceName) : undefined;
     const servicePath = ensureLeadingSlash(pathAnnotation(annotations) ?? serviceName);
     services.push({
       namespace,
@@ -140,14 +176,16 @@ export async function parseCdsFile(repoPath: string, filePath: string): Promise<
       isExtend,
       sourceFile: normalizePath(filePath),
       sourceLine: lineOf(text, match.index),
-      operations: operationsFromBody(text, body, open + 1, filePath)
+      operations: operationsFromBody(text, body, open + 1, filePath),
+      extension: isExtend ? { localReference: name, importedSymbol: imported?.importedSymbol, localAlias: imported?.localAlias, moduleSpecifier: imported?.moduleSpecifier, importKind: imported?.importKind ?? 'none' } : undefined
     });
     serviceRegex.lastIndex = end + 1;
   }
   const baseOps = new Map(services.filter((s) => !s.isExtend).map((s) => [s.qualifiedName, s.operations]));
   for (const service of services.filter((s) => s.isExtend && s.operations.length === 0)) {
+    if (service.extension?.moduleSpecifier) continue;
     const inherited = baseOps.get(service.qualifiedName) ?? baseOps.get(service.serviceName);
-    if (inherited) service.operations = inherited.map((op) => ({ ...op, sourceFile: service.sourceFile, sourceLine: service.sourceLine }));
+    if (inherited) service.operations = inherited.map((op) => ({ ...op, provenance: 'inherited' }));
   }
   return services;
 }

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

@@ -105,37 +105,54 @@ function placeholders(expr: ts.TemplateExpression): string[] {
 function isFunctionLikeScope(node: ts.Node): boolean {
   return ts.isFunctionLike(node) || ts.isSourceFile(node);
 }
-function containingScope(node: ts.Node): ts.Node {
-  let current: ts.Node | undefined = node.parent;
-  while (current && !isFunctionLikeScope(current)) current = current.parent;
-  return current ?? node.getSourceFile();
-}
 function nodeContains(parent: ts.Node, child: ts.Node): boolean {
-  return child.getStart(child.getSourceFile()) >= parent.getStart(parent.getSourceFile()) && child.getEnd() <= parent.getEnd();
+  const source = child.getSourceFile();
+  return child.getStart(source) >= parent.getStart(source) && child.getEnd() <= parent.getEnd();
+}
+function declarationScope(node: ts.VariableDeclaration | ts.ParameterDeclaration): ts.Node {
+  if (ts.isParameter(node)) return node.parent;
+  const list = node.parent;
+  const blockScoped = (list.flags & (ts.NodeFlags.Const | ts.NodeFlags.Let)) !== 0;
+  let current: ts.Node = list.parent;
+  if (!blockScoped) {
+    while (current.parent && !isFunctionLikeScope(current)) current = current.parent;
+    return current;
+  }
+  while (current.parent && !ts.isBlock(current) && !ts.isSourceFile(current) && !ts.isModuleBlock(current) && !ts.isCaseBlock(current) && !ts.isCatchClause(current) && !ts.isForStatement(current) && !ts.isForInStatement(current) && !ts.isForOfStatement(current) && !isFunctionLikeScope(current)) current = current.parent;
+  return current;
 }
-function nestedFunctionContains(scope: ts.Node, candidate: ts.Node, use: ts.Node): boolean {
-  let current = candidate.parent;
-  while (current && current !== scope) {
-    if (isFunctionLikeScope(current) && !nodeContains(current, use)) return true;
+function declarationScopedAncestor(node: ts.Node): ts.Node | undefined {
+  let current: ts.Node | undefined = node.parent;
+  while (current) {
+    if (ts.isCatchClause(current) || ts.isForStatement(current) || ts.isForInStatement(current) || ts.isForOfStatement(current)) return current;
+    if (ts.isSourceFile(current) || ts.isFunctionLike(current)) return undefined;
     current = current.parent;
   }
-  return false;
+  return undefined;
+}
+function isAccessibleDeclaration(declaration: ts.VariableDeclaration | ts.ParameterDeclaration, use: ts.Node): boolean {
+  const source = use.getSourceFile();
+  if (declaration.name.getStart(source) >= use.getStart(source)) return false;
+  const scopedAncestor = declarationScopedAncestor(declaration);
+  if (scopedAncestor && ts.isCatchClause(scopedAncestor)) return nodeContains(scopedAncestor.block, use);
+  if (scopedAncestor && (ts.isForStatement(scopedAncestor) || ts.isForInStatement(scopedAncestor) || ts.isForOfStatement(scopedAncestor))) return nodeContains(scopedAncestor.statement, use);
+  const scope = declarationScope(declaration);
+  if (ts.isCatchClause(scope)) return nodeContains(scope.block, use);
+  if (ts.isForStatement(scope) || ts.isForInStatement(scope) || ts.isForOfStatement(scope)) return nodeContains(scope.statement, use);
+  return ts.isSourceFile(scope) || nodeContains(scope, use);
 }
 function resolveBinding(identifier: ts.Identifier, use: ts.Node): BindingResolution {
-  const scope = containingScope(use);
   const source = use.getSourceFile();
   let best: ts.VariableDeclaration | ts.ParameterDeclaration | undefined;
   const visit = (node: ts.Node): void => {
-    if (node !== scope && isFunctionLikeScope(node)) return;
-    if (node.getStart(source) >= identifier.getStart(source)) return;
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === identifier.text && !nestedFunctionContains(scope, node, use)) best = node;
-    if (ts.isParameter(node) && ts.isIdentifier(node.name) && node.name.text === identifier.text && !nestedFunctionContains(scope, node, use)) best = node;
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
+    if (ts.isParameter(node) && ts.isIdentifier(node.name) && node.name.text === identifier.text && isAccessibleDeclaration(node, use)) best = node;
     ts.forEachChild(node, visit);
   };
-  visit(scope);
+  visit(source);
   if (!best) return { immutable: false, evidence: ['binding_not_found'] };
   const immutable = ts.isVariableDeclaration(best) && (best.parent.flags & ts.NodeFlags.Const) !== 0;
-  return { declaration: best, initializer: ts.isVariableDeclaration(best) ? best.initializer : undefined, immutable, evidence: [immutable ? 'const_binding_before_use' : 'mutable_or_parameter_binding'] };
+  return { declaration: best, initializer: ts.isVariableDeclaration(best) ? best.initializer : undefined, immutable, evidence: [immutable ? 'lexical_const_binding_before_use' : 'lexical_mutable_or_parameter_binding'] };
 }
 function resolveExpression(expr: ts.Expression | undefined, use: ts.Node, policy: 'operation_path' | 'external' | 'literal', depth = 0, seen = new Set<ts.Node>()): ExpressionResolution {
   if (!expr) return { status: 'unknown', sourceKind: 'dynamic_expression', placeholderKeys: [], evidence: ['expression_missing'] };
@@ -177,7 +194,6 @@ function staticPathCandidates(identifier: ts.Identifier, call: ts.Node, method:
   const binding = resolveBinding(identifier, call);
   const declaration = binding.declaration;
   if (!declaration) return undefined;
-  const scope = containingScope(call);
   const source = call.getSourceFile();
   const paths: string[] = [];
   let hasDynamicAssignments = false;
@@ -188,12 +204,15 @@ function staticPathCandidates(identifier: ts.Identifier, call: ts.Node, method:
   };
   if (ts.isVariableDeclaration(declaration)) addExpr(declaration.initializer, declaration);
   const visit = (node: ts.Node): void => {
-    if (node !== scope && isFunctionLikeScope(node)) return;
+    if (node !== source && isFunctionLikeScope(node) && !nodeContains(node, call)) return;
     if (node.getStart(source) >= call.getStart(source)) return;
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(node.left) && node.left.text === identifier.text) addExpr(node.right, node);
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(node.left)) {
+      const target = resolveBinding(node.left, node);
+      if (target.declaration === declaration) addExpr(node.right, node);
+    }
     ts.forEachChild(node, visit);
   };
-  visit(scope);
+  visit(source);
   const candidatePaths = [...new Set(paths)];
   if (candidatePaths.length === 0) return undefined;
   const normalizedCandidateOperations = [...new Set(candidatePaths.map((candidate) => classifyODataPathIntent(candidate, method).topLevelOperationName).filter((value): value is string => Boolean(value)))];
@@ -404,6 +423,20 @@ export function classifyOutboundCallsInSource(source: ts.SourceFile, filePath: s
           const entityCallType = entityCallTypes[intent.kind];
           const isODataQueryRead = method.toUpperCase() === 'GET' && ['entity_query', 'entity_key_read', 'entity_navigation_query'].includes(intent.kind);
           add(node, { callType: query ? 'remote_query' : entityCallType ?? (isODataQueryRead ? 'remote_query' : 'remote_action'), serviceVariableName: receiver, method, operationPathExpr, queryEntity: query ? extractQueryEntity(query) : isODataQueryRead ? intent.entitySegment : undefined, payloadSummary: summarizeExpression(objectArg.getText(source)), confidence: op || query ? 0.8 : 0.4, unresolvedReason: !query && pathExpr && !operationPathExpr ? 'dynamic_operation_path_identifier' : undefined }, { receiver, classifier: 'service_client_send_object', operationPathExpression: shorthandPath ? op : undefined, rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? (resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : resolvedPath.sourceKind) : undefined, odataPathIntent: operationPathExpr ? intent : undefined, staticPathCandidates: candidateEvidence, parserWarning: !query && pathExpr && !operationPathExpr ? 'dynamic_operation_path_identifier' : undefined });
+        } else {
+          const receiver = receiverName(expr.expression);
+          const rootReceiver = rootReceiverName(expr.expression);
+          const method = resolveExpression(node.arguments[0], node, 'literal').value?.toUpperCase();
+          const pathArg = node.arguments[1];
+          const supported = method && ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'].includes(method);
+          if (receiver && supported && serviceVariables.has(rootReceiver ?? receiver)) {
+            const resolvedPath = staticPathExpression(pathArg, node);
+            const operationPathExpr = operationPathFromStatic(resolvedPath.text);
+            const intent = classifyODataPathIntent(operationPathExpr, method);
+            add(node, { callType: 'remote_action', serviceVariableName: rootReceiver ?? receiver, method, operationPathExpr, payloadSummary: summarizeExpression(node.getText(source)), confidence: operationPathExpr ? 0.8 : 0.45, unresolvedReason: operationPathExpr ? undefined : 'dynamic_operation_path_identifier' }, { receiver, rootReceiver, classifier: 'service_client_send_method_path', rawPathExpression: resolvedPath.rawExpression, literalPathSource: resolvedPath.text ? (resolvedPath.sourceKind === 'const' ? 'same_scope_const_initializer' : resolvedPath.sourceKind) : undefined, odataPathIntent: operationPathExpr ? intent : undefined, parserWarning: operationPathExpr ? undefined : 'dynamic_operation_path_identifier' });
+          } else if (receiver && serviceVariables.has(rootReceiver ?? receiver)) {
+            add(node, { callType: 'remote_action', serviceVariableName: rootReceiver ?? receiver, method, payloadSummary: summarizeExpression(node.getText(source)), confidence: 0.35, unresolvedReason: 'unsupported_cap_send_signature' }, { receiver, rootReceiver, classifier: 'service_client_send_unsupported_signature' });
+          }
         }
       } else if (((ts.isCallExpression(expr) && ts.isIdentifier(expr.expression) && wrapperSpecs.has(expr.expression.text)) || (ts.isIdentifier(expr) && wrapperSpecs.has(expr.text)))) {
         const wrapperName = ts.isIdentifier(expr) ? expr.text : ts.isCallExpression(expr) && ts.isIdentifier(expr.expression) ? expr.expression.text : '';
@@ -467,7 +500,7 @@ function parseLocalServiceCalls(text: string, filePath: string): OutboundCallFac
       if (origin) aliases.set(node.name.text, { ...origin, chain: [...origin.chain, node.name.text] });
     }
     if (ts.isCallExpression(node)) {
-      const parsed = serviceOperationCall(node.expression, aliases);
+      const parsed = serviceOperationCall(node, aliases);
       if (parsed && parsed.operation !== 'entities') calls.push({
         callType: 'local_service_call',
         operationPathExpr: `/${parsed.operation}`,
@@ -480,7 +513,8 @@ function parseLocalServiceCalls(text: string, filePath: string): OutboundCallFac
         confidence: 0.9,
         unresolvedReason: ['send', 'emit', 'publish', 'on'].includes(parsed.operation) ? 'transport_client_method' : undefined,
         evidence: parserEvidence(source, node, {
-          classifier: 'local_cap_service_call',
+          classifier: parsed.classifier,
+          parserCallType: parsed.operation === 'send' ? 'transport_client_method' : parsed.classifier,
           localServiceLookup: parsed.lookup,
           localServiceName: parsed.service,
           operation: parsed.operation,
@@ -499,10 +533,17 @@ function serviceLookup(expr: ts.Expression, aliases: Map<string, { service: stri
   if (ts.isElementAccessExpression(expr) && expr.expression.getText() === 'cds.services' && ts.isStringLiteral(expr.argumentExpression)) return { service: expr.argumentExpression.text, lookup: expr.getText(), chain: [expr.getText()] };
   return undefined;
 }
-function serviceOperationCall(expr: ts.Expression, aliases: Map<string, { service: string; lookup: string; chain: string[] }>): { service: string; lookup: string; chain: string[]; operation: string } | undefined {
+function serviceOperationCall(node: ts.CallExpression, aliases: Map<string, { service: string; lookup: string; chain: string[] }>): { service: string; lookup: string; chain: string[]; operation: string; classifier: string } | undefined {
+  const expr = node.expression;
   if (!ts.isPropertyAccessExpression(expr)) return undefined;
-  const operation = expr.name.text;
   const origin = serviceLookup(expr.expression, aliases);
   if (!origin) return undefined;
-  return { ...origin, operation };
+  if (expr.name.text === 'send') {
+    const first = literalText(node.arguments[0]);
+    const second = literalText(node.arguments[1]);
+    const method = first?.toUpperCase();
+    if (method && ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'].includes(method) && second) return { ...origin, operation: second.replace(/^\//, ''), classifier: 'cap_service_send_method_path' };
+    if (first) return { ...origin, operation: first.replace(/^\//, ''), classifier: 'cap_service_send_local_dispatch' };
+  }
+  return { ...origin, operation: expr.name.text, classifier: 'local_cap_service_call' };
 }

package/src/types.ts

@@ -70,6 +70,14 @@ export interface CdsServiceFact {
   sourceFile: string;
   sourceLine: number;
   operations: CdsOperationFact[];
+  extension?: CdsExtensionFact;
+}
+export interface CdsExtensionFact {
+  localReference: string;
+  importedSymbol?: string;
+  localAlias?: string;
+  moduleSpecifier?: string;
+  importKind?: 'relative' | 'package' | 'none';
 }
 export interface CdsOperationFact {
   operationType: 'action' | 'function' | 'event';
@@ -79,6 +87,8 @@ export interface CdsOperationFact {
   returnType?: string;
   sourceFile: string;
   sourceLine: number;
+  provenance?: 'direct' | 'inherited';
+  baseOperationId?: number;
 }
 export interface HandlerClassFact {
   className: string;