@saptools/service-flow 0.1.10 → 0.1.12

package/dist/cli.js

@@ -10,12 +10,12 @@ import {
   parsePackageJson,
   parseServiceBindings,
   trace
-} from "./chunk-LQT67AU5.js";
+} from "./chunk-MXYYARUP.js";
 
 // src/cli.ts
 import { Command } from "commander";
-import path5 from "path";
-import fs5 from "fs/promises";
+import path6 from "path";
+import fs6 from "fs/promises";
 import pc from "picocolors";
 
 // src/config/defaults.ts
@@ -95,12 +95,13 @@ CREATE TABLE IF NOT EXISTS files (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NU
 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 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, 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 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);
 CREATE TABLE IF NOT EXISTS handler_registrations (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, handler_class_id INTEGER, class_name TEXT, import_source TEXT, registration_file TEXT NOT NULL, registration_line INTEGER NOT NULL, registration_kind TEXT NOT NULL, confidence REAL NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(handler_class_id) REFERENCES handler_classes(id) ON DELETE SET NULL);
 CREATE TABLE IF NOT EXISTS service_bindings (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, symbol_id INTEGER, variable_name TEXT NOT NULL, alias TEXT, alias_expr TEXT, destination_expr TEXT, service_path_expr TEXT, is_dynamic INTEGER NOT NULL, placeholders_json TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, helper_chain_json TEXT, 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 outbound_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, source_symbol_id INTEGER, call_type TEXT NOT NULL, service_binding_id INTEGER, method TEXT, operation_path_expr TEXT, query_entity TEXT, event_name_expr TEXT, payload_summary TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, confidence REAL NOT NULL, unresolved_reason TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(source_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL, FOREIGN KEY(service_binding_id) REFERENCES service_bindings(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS outbound_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, source_symbol_id INTEGER, call_type TEXT NOT NULL, service_binding_id INTEGER, method TEXT, operation_path_expr TEXT, query_entity TEXT, event_name_expr TEXT, payload_summary TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, confidence REAL NOT NULL, unresolved_reason TEXT, local_service_name TEXT, local_service_lookup TEXT, alias_chain_json TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(source_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL, FOREIGN KEY(service_binding_id) REFERENCES service_bindings(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS symbol_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, caller_symbol_id INTEGER NOT NULL, callee_symbol_id INTEGER, callee_expression TEXT NOT NULL, import_source TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, status TEXT NOT NULL, confidence REAL NOT NULL, evidence_json TEXT NOT NULL, unresolved_reason TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(caller_symbol_id) REFERENCES symbols(id) ON DELETE CASCADE, FOREIGN KEY(callee_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
 CREATE TABLE IF NOT EXISTS graph_edges (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, edge_type TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'unresolved', from_kind TEXT NOT NULL, from_id TEXT NOT NULL, to_kind TEXT NOT NULL, to_id TEXT NOT NULL, confidence REAL NOT NULL, evidence_json TEXT NOT NULL, is_dynamic INTEGER NOT NULL, unresolved_reason TEXT, generation INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS index_runs (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, started_at TEXT NOT NULL, finished_at TEXT, status TEXT NOT NULL, repo_count INTEGER NOT NULL, file_count INTEGER NOT NULL, diagnostic_count INTEGER NOT NULL, error_message TEXT, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
 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);
@@ -108,11 +109,12 @@ 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_operation_name ON cds_operations(operation_name, operation_path);
 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);
 `;
 
 // src/db/migrations.ts
-var CURRENT_SCHEMA_VERSION = 3;
+var CURRENT_SCHEMA_VERSION = 4;
 var columns = {
   service_bindings: [
     { name: "helper_chain_json", ddl: "ALTER TABLE service_bindings ADD COLUMN helper_chain_json TEXT" },
@@ -133,6 +135,18 @@ var columns = {
     { name: "class_name", ddl: "ALTER TABLE handler_registrations ADD COLUMN class_name TEXT" },
     { name: "import_source", ddl: "ALTER TABLE handler_registrations ADD COLUMN import_source TEXT" }
   ],
+  symbols: [
+    { name: "start_offset", ddl: "ALTER TABLE symbols ADD COLUMN start_offset INTEGER" },
+    { name: "end_offset", ddl: "ALTER TABLE symbols ADD COLUMN end_offset INTEGER" },
+    { name: "source_file", ddl: "ALTER TABLE symbols ADD COLUMN source_file TEXT" },
+    { name: "exported_name", ddl: "ALTER TABLE symbols ADD COLUMN exported_name TEXT" },
+    { name: "evidence_json", ddl: "ALTER TABLE symbols ADD COLUMN evidence_json TEXT" }
+  ],
+  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" },
+    { name: "alias_chain_json", ddl: "ALTER TABLE outbound_calls ADD COLUMN alias_chain_json TEXT" }
+  ],
   index_runs: [
     { name: "error_message", ddl: "ALTER TABLE index_runs ADD COLUMN error_message TEXT" }
   ]
@@ -171,7 +185,7 @@ function migrate(db) {
 // package.json
 var package_default = {
   name: "@saptools/service-flow",
-  version: "0.1.10",
+  version: "0.1.12",
   description: "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   type: "module",
   publishConfig: {
@@ -384,11 +398,12 @@ function clearRepoFacts(db, repoId) {
   for (const t of [
     "cds_requires",
     "cds_services",
-    "symbols",
     "handler_classes",
+    "outbound_calls",
+    "symbol_calls",
     "handler_registrations",
     "service_bindings",
-    "outbound_calls",
+    "symbols",
     "diagnostics",
     "files"
   ])
@@ -523,13 +538,26 @@ function insertBindings(db, repoId, rows) {
       r.helperChain ? JSON.stringify(r.helperChain) : null
     );
 }
+function insertExecutableSymbols(db, repoId, rows) {
+  const stmt = db.prepare("INSERT INTO symbols(repo_id,file_id,kind,name,qualified_name,exported,start_line,end_line,start_offset,end_offset,source_file,exported_name,evidence_json) VALUES(?,(SELECT id FROM files WHERE repo_id=? AND relative_path=?),?,?,?,?,?,?,?,?,?,?,?)");
+  for (const r of rows) stmt.run(repoId, repoId, r.sourceFile, r.kind, r.localName, r.qualifiedName, r.exported ? 1 : 0, r.startLine, r.endLine, r.startOffset, r.endOffset, r.sourceFile, r.exportedName, r.importExportEvidence ? JSON.stringify(r.importExportEvidence) : null);
+}
+function insertSymbolCalls(db, repoId, rows) {
+  const stmt = db.prepare(`INSERT INTO symbol_calls(repo_id,caller_symbol_id,callee_symbol_id,callee_expression,import_source,source_file,source_line,status,confidence,evidence_json,unresolved_reason) VALUES(?,(SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1),(SELECT id FROM symbols WHERE repo_id=? AND ((source_file=? AND (name=? OR qualified_name=?)) OR (source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?))) ORDER BY CASE WHEN source_file=? THEN 0 ELSE 1 END,id LIMIT 1),?,?,?,?,?,0.8,?,CASE WHEN (SELECT id FROM symbols WHERE repo_id=? AND ((source_file=? AND (name=? OR qualified_name=?)) OR (source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?))) ORDER BY CASE WHEN source_file=? THEN 0 ELSE 1 END,id LIMIT 1) IS NULL THEN 'No local symbol target matched exactly' ELSE NULL END)`);
+  for (const r of rows) stmt.run(repoId, repoId, r.sourceFile, r.callerQualifiedName, repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName, r.sourceFile, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, JSON.stringify(r.evidence), repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName, r.sourceFile);
+  db.prepare("UPDATE symbol_calls SET status=CASE WHEN callee_symbol_id IS NULL THEN 'unresolved' ELSE 'resolved' END, unresolved_reason=CASE WHEN callee_symbol_id IS NULL THEN COALESCE(unresolved_reason,'No local symbol target matched exactly') ELSE NULL END WHERE repo_id=?").run(repoId);
+}
 function insertCalls(db, repoId, rows) {
   const stmt = db.prepare(
-    "INSERT INTO outbound_calls(repo_id,call_type,method,operation_path_expr,query_entity,event_name_expr,payload_summary,source_file,source_line,confidence,unresolved_reason,service_binding_id) VALUES(?,?,?,?,?,?,?,?,?,?,?,(SELECT id FROM service_bindings WHERE repo_id=? AND variable_name=? AND source_file=? ORDER BY CASE WHEN source_line<=? THEN 0 ELSE 1 END, ABS(source_line-?) ASC, id DESC LIMIT 1))"
+    "INSERT INTO outbound_calls(repo_id,source_symbol_id,call_type,method,operation_path_expr,query_entity,event_name_expr,payload_summary,source_file,source_line,confidence,unresolved_reason,local_service_name,local_service_lookup,alias_chain_json,service_binding_id) VALUES(?,(SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND start_line<=? AND end_line>=? ORDER BY (end_line-start_line),id LIMIT 1),?,?,?,?,?,?,?,?,?,?,?,?,?,(SELECT id FROM service_bindings WHERE repo_id=? AND variable_name=? AND source_file=? ORDER BY CASE WHEN source_line<=? THEN 0 ELSE 1 END, ABS(source_line-?) ASC, id DESC LIMIT 1))"
   );
   for (const r of rows)
     stmt.run(
       repoId,
+      repoId,
+      r.sourceFile,
+      r.sourceLine,
+      r.sourceLine,
       r.callType,
       r.method,
       r.operationPathExpr,
@@ -540,6 +568,9 @@ function insertCalls(db, repoId, rows) {
       r.sourceLine,
       r.confidence,
       r.unresolvedReason,
+      r.localServiceName,
+      r.localServiceLookup,
+      r.aliasChain ? JSON.stringify(r.aliasChain) : null,
       repoId,
       r.serviceVariableName,
       r.sourceFile,
@@ -591,8 +622,130 @@ function errorMessage(error) {
 }
 
 // src/indexer/repository-indexer.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+
+// src/parsers/symbol-parser.ts
 import fs4 from "fs/promises";
 import path4 from "path";
+import ts from "typescript";
+function lineOf(source, pos) {
+  return source.getLineAndCharacterOfPosition(pos).line + 1;
+}
+function nameOf(node) {
+  if (!node) return void 0;
+  if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node)) return node.text;
+  return void 0;
+}
+function isFunctionLike(node) {
+  return ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node);
+}
+function exported(node) {
+  return Boolean(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export);
+}
+function exportDeclarations(source) {
+  const exports = /* @__PURE__ */ new Map();
+  const visit = (node) => {
+    if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) {
+      for (const el of node.exportClause.elements) exports.set((el.propertyName ?? el.name).text, el.name.text);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return exports;
+}
+function isRelativeImport(value) {
+  return Boolean(value?.startsWith("."));
+}
+function isObjectFunction(node) {
+  return ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
+}
+function callName(expr) {
+  if (ts.isIdentifier(expr)) return { expression: expr.text, local: expr.text };
+  if (ts.isPropertyAccessExpression(expr)) {
+    const left = expr.expression.getText();
+    return { expression: expr.getText(), local: left === "this" ? void 0 : left, member: expr.name.text };
+  }
+  return { expression: expr.getText() };
+}
+function nearest(symbols, line) {
+  return symbols.filter((s) => s.startLine <= line && s.endLine >= line).sort((a, b) => a.endLine - a.startLine - (b.endLine - b.startLine))[0];
+}
+async function parseExecutableSymbols(repoPath, filePath) {
+  const text = await fs4.readFile(path4.join(repoPath, filePath), "utf8");
+  const source = ts.createSourceFile(filePath, text, ts.ScriptTarget.Latest, true, filePath.endsWith(".ts") ? ts.ScriptKind.TS : ts.ScriptKind.JS);
+  const sourceFile = normalizePath(filePath);
+  const symbols = [];
+  const calls = [];
+  const imports = /* @__PURE__ */ new Map();
+  const exportNames = exportDeclarations(source);
+  const objectExports = /* @__PURE__ */ new Set();
+  const addSymbol = (kind, localName, node, parentName, exportedName) => {
+    const declaredExportName = exportedName ?? exportNames.get(parentName ? parentName.split(".")[0] ?? localName : localName);
+    const qualifiedName = parentName ? `${parentName}.${localName}` : localName;
+    const objectExported = parentName ? objectExports.has(parentName.split(".")[0] ?? "") : false;
+    symbols.push({ kind, localName: kind === "object_method" ? qualifiedName : localName, exportedName: objectExported ? qualifiedName : declaredExportName, qualifiedName, sourceFile, startLine: lineOf(source, node.getStart(source)), endLine: lineOf(source, node.getEnd()), startOffset: node.getStart(source), endOffset: node.getEnd(), exported: exported(node) || Boolean(declaredExportName) || objectExported, importExportEvidence: declaredExportName ? { exportedName: declaredExportName, source: "export_declaration" } : objectExported ? { exportedName: qualifiedName, source: "exported_object_literal" } : void 0 });
+  };
+  const visitImports = (node) => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+      const sourceText = node.moduleSpecifier.text;
+      const clause = node.importClause;
+      if (clause?.name) imports.set(clause.name.text, sourceText);
+      const named = clause?.namedBindings;
+      if (named && ts.isNamedImports(named)) for (const el of named.elements) imports.set(el.name.text, sourceText);
+      if (named && ts.isNamespaceImport(named)) imports.set(named.name.text, sourceText);
+    }
+    ts.forEachChild(node, visitImports);
+  };
+  visitImports(source);
+  const visitSymbols = (node, parentClass) => {
+    if (ts.isClassDeclaration(node) && node.name) {
+      for (const member of node.members) visitSymbols(member, node.name.text);
+      return;
+    }
+    if (ts.isMethodDeclaration(node)) {
+      const localName = nameOf(node.name);
+      if (localName) addSymbol("method", localName, node, parentClass);
+    } else if (ts.isFunctionDeclaration(node) && node.name) addSymbol("function", node.name.text, node, void 0, exported(node) ? node.name.text : void 0);
+    else if (ts.isVariableStatement(node)) {
+      for (const d of node.declarationList.declarations) {
+        const localName = nameOf(d.name);
+        if (!localName || !d.initializer) continue;
+        if (isFunctionLike(d.initializer)) addSymbol("function", localName, d.initializer, void 0, exported(node) ? localName : exportNames.get(localName));
+        if (ts.isObjectLiteralExpression(d.initializer)) {
+          if (exported(node) || exportNames.has(localName)) objectExports.add(localName);
+          for (const prop of d.initializer.properties) {
+            if (ts.isPropertyAssignment(prop) && isObjectFunction(prop.initializer)) {
+              const propName = nameOf(prop.name);
+              if (propName) addSymbol("object_method", propName, prop.initializer, localName);
+            } else if (ts.isMethodDeclaration(prop)) {
+              const propName = nameOf(prop.name);
+              if (propName) addSymbol("object_method", propName, prop, localName);
+            }
+          }
+        }
+      }
+    } else ts.forEachChild(node, (child) => visitSymbols(child, parentClass));
+  };
+  visitSymbols(source);
+  const localCallables = new Set(symbols.flatMap((sym) => [sym.localName, sym.qualifiedName]));
+  const visitCalls = (node) => {
+    if (ts.isCallExpression(node)) {
+      const line = lineOf(source, node.getStart(source));
+      const caller = nearest(symbols, line);
+      if (caller) {
+        const callee = callName(node.expression);
+        const importSource = (callee.local ? imports.get(callee.local) : void 0) ?? (callee.member && callee.local ? imports.get(callee.local) : void 0);
+        const targetName = callee.expression.startsWith("this.") ? callee.member : callee.member && callee.local ? `${callee.local}.${callee.member}` : callee.local;
+        const keep = Boolean(targetName) && (localCallables.has(String(targetName)) || callee.expression.startsWith("this.") || isRelativeImport(importSource));
+        if (keep) calls.push({ callerQualifiedName: caller.qualifiedName, calleeExpression: callee.expression, calleeLocalName: targetName, receiverLocalName: callee.member ? callee.local : void 0, importSource, sourceFile, sourceLine: line, evidence: { relation: importSource ? "relative_import" : callee.expression.startsWith("this.") ? "this_method" : "local", caller: caller.qualifiedName, targetName } });
+      }
+    }
+    ts.forEachChild(node, visitCalls);
+  };
+  visitCalls(source);
+  return { symbols, calls };
+}
 
 // src/utils/hashing.ts
 import { createHash } from "crypto";
@@ -621,6 +774,8 @@ async function indexRepository(db, repo, force) {
       for (const file of parsed.fileRecords) fileStmt.run(repo.id, file.relativePath, file.extension, file.sha256, file.sizeBytes, (/* @__PURE__ */ 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);
@@ -636,16 +791,19 @@ async function indexRepository(db, repo, force) {
   }
 }
 async function parseAllSourceFacts(root, files) {
-  const facts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], fileRecords: [] };
+  const facts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], symbols: [], symbolCalls: [], fileRecords: [] };
   for (const file of files) {
-    const abs = path4.join(root, file);
-    const stat = await fs4.stat(abs);
-    facts.fileRecords.push({ relativePath: normalizePath(file), extension: path4.extname(file), sha256: await sha256File(abs), sizeBytes: stat.size });
+    const abs = path5.join(root, file);
+    const stat = await fs5.stat(abs);
+    facts.fileRecords.push({ relativePath: normalizePath(file), extension: path5.extname(file), sha256: await sha256File(abs), sizeBytes: stat.size });
     if (file.endsWith(".cds")) facts.services.push(...await parseCdsFile(root, file));
     if (/\.[jt]s$/.test(file)) {
       facts.handlers.push(...await parseDecorators(root, file));
       facts.registrations.push(...await parseHandlerRegistrations(root, file));
       facts.bindings.push(...await parseServiceBindings(root, file));
+      const symbolFacts = await parseExecutableSymbols(root, file);
+      facts.symbols.push(...symbolFacts.symbols);
+      facts.symbolCalls.push(...symbolFacts.calls);
       facts.calls.push(...await parseOutboundCalls(root, file));
     }
   }
@@ -654,11 +812,11 @@ async function parseAllSourceFacts(root, files) {
 async function findSourceFiles(root) {
   const out = [];
   async function walk(dir, prefix = "") {
-    const entries = await fs4.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await fs5.readdir(dir, { withFileTypes: true }).catch(() => []);
     for (const e of entries) {
       const rel = prefix ? `${prefix}/${e.name}` : e.name;
       if (e.isDirectory()) {
-        if (!["node_modules", "dist", "gen", "coverage", ".git"].includes(e.name)) await walk(path4.join(dir, e.name), rel);
+        if (!["node_modules", "dist", "gen", "coverage", ".git"].includes(e.name)) await walk(path5.join(dir, e.name), rel);
       } else if (/\.(cds|ts|js)$/.test(e.name) && !isDefaultTestFile(rel)) out.push(rel);
     }
   }
@@ -671,7 +829,7 @@ function isDefaultTestFile(relativeFile) {
   return /\.(test|spec)\.[jt]s$/.test(parts.at(-1) ?? "");
 }
 async function repositoryFingerprint(root, files, facts) {
-  const packageJson = await fs4.readFile(path4.join(root, "package.json"), "utf8").catch(() => "");
+  const packageJson = await fs5.readFile(path5.join(root, "package.json"), "utf8").catch(() => "");
   const normalizedFacts = {
     analyzerVersion: ANALYZER_VERSION,
     packageName: facts.packageName,
@@ -684,7 +842,7 @@ async function repositoryFingerprint(root, files, facts) {
   };
   const entries = [`facts:${JSON.stringify(normalizedFacts)}`];
   for (const file of files) {
-    const content = await fs4.readFile(path4.join(root, file), "utf8");
+    const content = await fs5.readFile(path5.join(root, file), "utf8");
     entries.push(`${file}:${sha256Text(content)}`);
   }
   return sha256Text(entries.join("\n"));
@@ -722,25 +880,25 @@ function parseVars(values) {
   }
   return out;
 }
-function startLabel(start) {
-  return [
-    start.repo,
-    start.servicePath,
-    start.operation ?? start.operationPath ?? start.handler
-  ].filter(Boolean).join(" ");
-}
 
 // src/output/table-output.ts
-function renderTraceTable(trace2) {
-  const lines = [
-    `Start: ${startLabel(trace2.start)}`,
-    "",
-    "Step  Type                 From                                To                                  Evidence"
-  ];
-  for (const e of trace2.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)} ${String(e.evidence.file ?? "")}:${String(e.evidence.line ?? "")}`
-    );
+function location(evidence) {
+  const file = evidence.file ?? evidence.sourceFile ?? evidence.handlerSourceFile ?? evidence.operationSourceFile ?? evidence.registrationSourceFile;
+  const line = evidence.line ?? evidence.sourceLine ?? evidence.handlerSourceLine ?? evidence.operationSourceLine ?? evidence.registrationSourceLine;
+  if (file || line) return `${String(file ?? "")}:${String(line ?? "")}`;
+  const candidates = evidence.candidates;
+  if (Array.isArray(candidates) && candidates.length > 0) {
+    const first = candidates[0];
+    return `${String(first.sourceFile ?? "")}:${String(first.sourceLine ?? "")}`;
+  }
+  return ":";
+}
+function renderTraceTable(result) {
+  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)}`);
+  }
+  if (result.diagnostics.length > 0) lines.push("", "Diagnostics:", ...result.diagnostics.map((d) => `${String(d.severity ?? "info")} ${String(d.code ?? "diagnostic")} ${String(d.message ?? "")}`));
   return `${lines.join("\n")}
 `;
 }
@@ -758,11 +916,15 @@ function renderTraceJson(trace2) {
 function safe(value) {
   return value.replace(/[^\w-]/g, "_").slice(0, 60);
 }
+function label(trace2, idOrLabel) {
+  const node = trace2.nodes.find((item) => item.id === idOrLabel || item.label === idOrLabel);
+  return String(node?.label ?? idOrLabel);
+}
 function renderMermaid(trace2) {
   const lines = ["flowchart TD"];
   for (const e of trace2.edges)
     lines.push(
-      `  ${safe(e.from)}["${e.from}"] -->|${e.type}| ${safe(e.to)}["${e.to}"]`
+      `  ${safe(e.from)}["${label(trace2, e.from)}"] -->|${e.type}| ${safe(e.to)}["${label(trace2, e.to)}"]`
     );
   return `${lines.join("\n")}
 `;
@@ -846,7 +1008,7 @@ function createProgram() {
     (opts) => void withWorkspace(opts.workspace, (db, workspaceId) => {
       const r = linkWorkspace(db, workspaceId);
       process.stdout.write(
-        `Linked ${r.edgeCount} edges: ${r.resolvedCount} remote resolved, ${r.unresolvedCount} remote unresolved, ${r.ambiguousCount} remote ambiguous, ${r.dynamicCount} dynamic, ${r.terminalCount} terminal, ${r.dependencyResolvedCount} dependency resolved, ${r.dependencyAmbiguousCount} dependency ambiguous, ${r.implementationResolvedCount} implementation resolved, ${r.implementationAmbiguousCount} implementation ambiguous
+        `Linked ${r.edgeCount} edges: ${r.resolvedCount} remote resolved, ${r.unresolvedCount} remote unresolved, ${r.ambiguousCount} remote ambiguous, ${r.dynamicCount} dynamic, ${r.terminalCount} terminal, ${r.dependencyResolvedCount} dependency resolved, ${r.dependencyAmbiguousCount} dependency ambiguous, ${r.implementationResolvedCount} implementation resolved, ${r.implementationAmbiguousCount} implementation ambiguous, ${r.implementationUnresolvedCount} implementation unresolved
 `
       );
     }).catch(fail)
@@ -1013,12 +1175,24 @@ function createProgram() {
                JOIN cds_services s ON s.id=o.service_id
                WHERE remote.edge_type='REMOTE_CALL_RESOLVES_TO_OPERATION' AND remote.to_kind='operation' AND NOT EXISTS (SELECT 1 FROM graph_edges impl WHERE impl.edge_type='OPERATION_IMPLEMENTED_BY_HANDLER' AND impl.from_kind='operation' AND impl.from_id=remote.to_id) AND ?
                UNION ALL
+               SELECT CASE WHEN ? THEN 'warning' ELSE 'error' END,'local_service_calls_all_unresolved','All local service calls are unresolved; verify local service alias parsing and linking',NULL,NULL
+               WHERE EXISTS (SELECT 1 FROM outbound_calls WHERE call_type='local_service_call') AND NOT EXISTS (SELECT 1 FROM graph_edges e JOIN outbound_calls c ON e.from_kind='call' AND c.id=CAST(e.from_id AS INTEGER) WHERE c.call_type='local_service_call' AND e.status='resolved')
+               UNION ALL
+               SELECT 'error','local_service_accessor_misclassified','Entity accessor calls were indexed as /entities operations',source_file,source_line
+               FROM outbound_calls WHERE call_type='local_service_call' AND operation_path_expr='/entities' AND (? OR 1)
+               UNION ALL
+               SELECT 'warning','outbound_calls_without_source_symbol','Outbound calls lack source symbol ownership: ' || COUNT(*),NULL,NULL
+               FROM outbound_calls WHERE source_symbol_id IS NULL AND ? HAVING COUNT(*) >= 1
+               UNION ALL
+               SELECT 'warning','trace_scope_fell_back_to_file','Trace may fall back to source-file scope for calls without symbols',NULL,NULL
+               WHERE EXISTS (SELECT 1 FROM outbound_calls WHERE source_symbol_id IS NULL) AND ?
+               UNION ALL
                SELECT 'warning','graph_stale','Graph is stale after repository fact changes; run service-flow link',NULL,NULL
                WHERE EXISTS (SELECT 1 FROM repositories WHERE graph_stale_reason IS NOT NULL)
                UNION ALL
                SELECT 'warning','index_run_abandoned','Index run ' || id || ' started at ' || started_at || ' is still running after the 60 minute abandonment threshold',NULL,NULL
                FROM index_runs WHERE status='running' AND datetime(started_at) < datetime('now','-60 minutes')`
-      ).all(Boolean(opts.strict), Boolean(opts.strict), Boolean(opts.strict), Boolean(opts.strict));
+      ).all(Boolean(opts.strict), Boolean(opts.strict), Boolean(opts.strict), Boolean(opts.strict), Boolean(opts.strict), Boolean(opts.strict), Boolean(opts.strict), Boolean(opts.strict));
       const allDiagnostics = [...diagnostics, ...health];
       process.stdout.write(
         allDiagnostics.length ? renderJson(allDiagnostics) : `${pc.green("No diagnostics recorded")}
@@ -1029,20 +1203,20 @@ function createProgram() {
   program.command("clean").option("--workspace <path>").option("--db-only").action(
     (opts) => void (async () => {
       const config = await loadWorkspaceConfig(opts.workspace);
-      const dbDir = path5.resolve(path5.dirname(config.dbPath));
-      const workspaceRoot = path5.resolve(config.rootPath);
-      await fs5.rm(config.dbPath, { force: true });
+      const dbDir = path6.resolve(path6.dirname(config.dbPath));
+      const workspaceRoot = path6.resolve(config.rootPath);
+      await fs6.rm(config.dbPath, { force: true });
       if (!opts.dbOnly) {
-        const marker = path5.join(dbDir, ".service-flow-state");
+        const marker = path6.join(dbDir, ".service-flow-state");
         const dangerous = /* @__PURE__ */ new Set([
-          path5.parse(dbDir).root,
+          path6.parse(dbDir).root,
           "/tmp",
-          process.env.HOME ? path5.resolve(process.env.HOME) : "",
+          process.env.HOME ? path6.resolve(process.env.HOME) : "",
           workspaceRoot
         ]);
         let ownsState;
         try {
-          ownsState = (await fs5.stat(marker)).isFile();
+          ownsState = (await fs6.stat(marker)).isFile();
         } catch {
           ownsState = false;
         }
@@ -1050,7 +1224,7 @@ function createProgram() {
           throw new Error(
             `Refusing to recursively delete unowned or dangerous state directory: ${dbDir}. Use --db-only to remove only the database file.`
           );
-        await fs5.rm(dbDir, { recursive: true, force: true });
+        await fs6.rm(dbDir, { recursive: true, force: true });
       }
       process.stdout.write("Cleaned service-flow state\n");
     })().catch(fail)