@saptools/service-flow 0.1.4 → 0.1.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.5
+
+- Runtime `--var` substitution now re-runs operation resolution in memory for trace and graph output, clears stale unresolved reasons on exact matches, and traverses into the matched downstream handler without mutating the persisted graph.
+- Operation nodes now use target CDS provenance while call-site evidence remains on edges.
+- Graph edges now carry explicit status values for resolved, terminal, dynamic, ambiguous, and unresolved cases; normal DB, external HTTP, and event terminals no longer receive remote-resolution failure text.
+- Replaced per-statement SQLite shelling with a persistent `node:sqlite` connection, bound parameters, transactions, read-only query openings, WAL, busy timeouts, and connection-local foreign-key enforcement.
+- Added schema user-version migration support for edge status and repository fingerprints.
+- Repository indexing now skips unchanged repositories unless `--force` is supplied and reports indexed/skipped counts.
+- `service-flow --version` now matches package metadata for the 0.1.5 release.
+
 ## 0.1.4
 
 - Resolved helper-returned service bindings exported through named export lists, including aliased exports, while preserving helper-chain evidence.

package/README.md

@@ -24,7 +24,7 @@ Index independent Git repositories, persist CAP/CDS facts in SQLite, resolve cro
 - 🧩 **Static CAP/CDS indexing** — extracts services, actions, functions, events, handler classes, decorator metadata, handler registrations, generated constants, and package-level `cds.requires`
 - 🔗 **Service-to-service linking** — resolves `cds.connect.to(...)`, `remote.send(...)`, `cds.services.*` style calls, helper package imports, dynamic candidates, and unresolved evidence into graph edges
 - 🗄️ **SQLite-backed workspace cache** — stores deterministic facts under `.service-flow/service-flow.db` so large workspaces can be queried repeatedly without reparsing everything
-- 🧠 **Dynamic edge support** — preserves parameterized destinations and service paths such as `svc_${objectCode}_process`, then lets traces apply runtime `--var key=value` values
+- 🧠 **Dynamic edge support** — preserves parameterized destinations and service paths such as `svc_${objectCode}_process`, then lets trace and graph commands apply runtime `--var key=value` values that can turn dynamic candidates into effective traversable operation edges
 - 📊 **Multiple output modes** — renders human-readable tables, JSON for automation, and Mermaid diagrams for architecture docs
 - 🩺 **Diagnostics-first workflow** — records parse/index issues and exposes them through `service-flow doctor` instead of hiding partial analysis
 - 🧩 **CAP helper-aware binding evidence** — follows imported helpers exported directly or through named export lists and separates alias, destination, and service-path expressions for dynamic `cds.connect.to(alias, options)` calls
@@ -47,7 +47,7 @@ npm install @saptools/service-flow
 ```
 
 > [!NOTE]
-> Requires **Node.js ≥ 20**. The analyzer is static: it reads files and package metadata, but it does not start CAP services, connect to SAP BTP, or execute application code.
+> Requires **Node.js ≥ 20**. Version 0.1.5 uses a persistent SQLite driver (`node:sqlite` in supported Node builds) for bound parameters, transactions, WAL, busy timeouts, and read-only query commands. The analyzer is static: it reads files and package metadata, but it does not start CAP services, connect to SAP BTP, or execute application code.
 
 ---
 
@@ -73,7 +73,7 @@ service-flow graph --workspace /path/to/workspace --service /FacadeService --pat
 service-flow doctor --workspace /path/to/workspace
 ```
 
-After `init`, the workspace configuration and SQLite database live below the selected workspace by default. Run `index` whenever source changes, then run `link` to rebuild the graph edges used by `trace` and `graph`.
+After `init`, the workspace configuration and SQLite database live below the selected workspace by default. Run `index` whenever source changes; unchanged repositories are skipped unless `--force` is supplied. Then run `link` to rebuild the graph edges used by `trace` and `graph`.
 
 ---
 

package/TECHNICAL-NOTE.md

@@ -1,10 +1,10 @@
-# Service Flow 0.1.4 Resolution Notes
+# Service Flow 0.1.5 Resolution Notes
 
 - Imported helper bindings: TypeScript imports are resolved for relative modules. When a caller assigns `const client = await connectToService()`, the analyzer follows the imported symbol to an exported helper that returns `cds.connect.to(...)` and persists caller-variable evidence plus the helper source/export chain.
 - Candidate ranking: operation-path matches start as weak candidates. A resolved operation edge requires a strong signal such as exact service path, CDS alias/destination context, or explicit dynamic variable overrides. Otherwise candidates are preserved in edge evidence as ambiguous or unresolved.
 - Edge states: `REMOTE_CALL_RESOLVES_TO_OPERATION` is used only above the resolution threshold; `DYNAMIC_EDGE_CANDIDATE` preserves runtime-dependent service paths/destinations; `UNRESOLVED_EDGE` carries candidate counts and reasons when static evidence is insufficient.
 - Trace cycle safety: trace queues carry repository IDs, visited scope keys are independent of depth, graph edge IDs are emitted once, and revisiting an already-seen downstream operation scope creates a cycle marker instead of recursive expansion.
-- SQLite reliability: the package uses WAL, foreign keys, busy timeouts, and retries around the SQLite adapter. Statement failures throw before output rendering so commands do not report successful JSON/table/Mermaid results after an internal database failure.
+- SQLite reliability: the package uses a persistent SQLite connection per opened database, bound parameters, transactions, WAL, busy timeouts, read-only openings for query commands, and connection-local foreign-key enforcement. Native driver loading failures produce an actionable startup error before output rendering.
 
 ## 0.1.4 trace-correctness additions
 
@@ -12,3 +12,10 @@
 - Two-argument CAP connections keep alias expressions distinct from `credentials.destination` and `credentials.path` / `credentials.servicePath`; dynamic placeholders from all three fields are retained for later `--var` substitution.
 - Repository discovery validates `.git` markers using `HEAD`, `config`, or gitfile `gitdir:` content and keeps scanning children so outer workspaces can contain many nested repositories.
 - Fresh SQLite stores now declare core parent/child foreign keys with cascading cleanup for repository-owned facts.
+
+## 0.1.5 hardening additions
+
+- Runtime variables are applied to alias, destination, service path, and operation path evidence. Trace/graph then perform an effective in-memory resolution requiring both operation-path compatibility and an exact service-path signal.
+- Edge evidence and target operation provenance are separate: call file/line and helper chains stay on the edge, while operation nodes are loaded from CDS operation/service/repository rows.
+- The linker stores explicit edge status categories and summary counts. Valid DB, event, and external terminals keep `unresolved_reason` null.
+- Repository-level fingerprints include source paths/hashes, package dependencies, and analyzer schema version. Unchanged repositories are skipped unless `--force` is used.

package/dist/{chunk-JY6GBGZT.js → chunk-I33ASGX3.js}

@@ -895,6 +895,13 @@ function rows(db, operationPath, workspaceId) {
   );
 }
 function resolveOperation(db, signals, workspaceId) {
+  const missing = [signals.servicePath, signals.alias, signals.destination, signals.operationPath].flatMap((value) => [...(value ?? "").matchAll(/\$\{\s*(\w+)\s*\}/g)].map((match) => match[1] ?? "")).filter(Boolean);
+  if (missing.length > 0)
+    return {
+      status: "dynamic",
+      candidates: signals.operationPath ? rows(db, signals.operationPath, workspaceId) : [],
+      reasons: [...new Set(missing)].map((name) => `missing_variable:${name}`)
+    };
   if (!signals.operationPath)
     return {
       status: "unresolved",
@@ -946,7 +953,7 @@ function resolveOperation(db, signals, workspaceId) {
       candidates,
       reasons: ["operation_path_only_has_no_strong_target_signal"]
     };
-  if (best && best.score >= 0.9 && (!second || best.score - second.score >= 0.25))
+  if (best && best.score >= 0.9 && best.servicePath === signals.servicePath && (best.operationPath === signals.operationPath || best.operationName === signals.operationPath.replace(/^\//, "")) && (!second || best.score - second.score >= 0.25))
     return {
       status: "resolved",
       target: best,
@@ -993,91 +1000,105 @@ function linkHelperPackages(db, workspaceId) {
 
 // src/linker/cross-repo-linker.ts
 function linkWorkspace(db, workspaceId, vars = {}) {
-  db.prepare("DELETE FROM graph_edges WHERE workspace_id=?").run(workspaceId);
-  let edges = linkHelperPackages(db, workspaceId);
-  let unresolved = 0;
-  const calls = db.prepare(
-    `SELECT c.*,r.name repoName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,b.helper_chain_json helperChainJson,req.service_path requireServicePath,req.destination requireDestination FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id LEFT JOIN service_bindings b ON b.id=c.service_binding_id LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias WHERE r.workspace_id=?`
-  ).all(workspaceId);
-  for (const call of calls) {
-    const callType = String(call.call_type);
-    const op = applyVariables(String(call.operation_path_expr ?? ""), vars);
-    const servicePath = applyVariables(
-      call.servicePathExpr ?? call.requireServicePath,
-      vars
-    );
-    const destination = call.destinationExpr ?? call.requireDestination;
-    const isDynamic = Boolean(Number(call.isDynamic ?? 0));
-    const resolution = callType.startsWith("remote") ? resolveOperation(
-      db,
-      {
+  return db.transaction(() => {
+    db.prepare("DELETE FROM graph_edges WHERE workspace_id=?").run(workspaceId);
+    let edges = linkHelperPackages(db, workspaceId);
+    let unresolved = 0;
+    let resolvedCount = 0;
+    let ambiguousCount = 0;
+    let dynamicCount = 0;
+    let terminalCount = 0;
+    const calls = db.prepare(
+      `SELECT c.*,r.name repoName,b.alias,b.alias_expr aliasExpr,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,b.helper_chain_json helperChainJson,req.service_path requireServicePath,req.destination requireDestination FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id LEFT JOIN service_bindings b ON b.id=c.service_binding_id LEFT JOIN cds_requires req ON req.repo_id=c.repo_id AND req.alias=b.alias WHERE r.workspace_id=?`
+    ).all(workspaceId);
+    for (const call of calls) {
+      const callType = String(call.call_type);
+      const op = applyVariables(String(call.operation_path_expr ?? ""), vars);
+      const servicePath = applyVariables(
+        call.servicePathExpr ?? call.requireServicePath,
+        vars
+      );
+      const destination = call.destinationExpr ?? call.requireDestination;
+      const isDynamic = Boolean(Number(call.isDynamic ?? 0));
+      const resolution = callType.startsWith("remote") ? resolveOperation(
+        db,
+        {
+          servicePath,
+          operationPath: op,
+          alias: applyVariables(call.aliasExpr ?? call.alias, vars),
+          destination: applyVariables(destination, vars),
+          isDynamic,
+          hasExplicitOverride: Object.keys(vars).length > 0
+        },
+        workspaceId
+      ) : { status: "unresolved", candidates: [], reasons: [] };
+      const target = resolution.target;
+      const evidence = {
+        sourceFile: call.source_file,
+        sourceLine: call.source_line,
+        file: call.source_file,
+        line: call.source_line,
+        repo: call.repoName,
+        serviceAlias: call.alias,
+        serviceAliasExpr: call.aliasExpr,
+        destination: applyVariables(destination, vars),
         servicePath,
         operationPath: op,
-        alias: call.alias,
-        destination,
-        isDynamic,
-        hasExplicitOverride: Object.keys(vars).length > 0
-      },
-      workspaceId
-    ) : { status: "unresolved", candidates: [], reasons: [] };
-    const target = resolution.target;
-    const evidence = {
-      sourceFile: call.source_file,
-      sourceLine: call.source_line,
-      file: call.source_file,
-      line: call.source_line,
-      repo: call.repoName,
-      serviceAlias: call.alias,
-      serviceAliasExpr: call.aliasExpr,
-      destination,
-      servicePath,
-      operationPath: op,
-      targetRepo: target?.repoName,
-      targetOperation: target?.operationName,
-      helperChain: call.helperChainJson ? JSON.parse(String(call.helperChainJson)) : void 0,
-      candidates: resolution.candidates,
-      candidateCount: resolution.candidates.length,
-      resolutionStatus: resolution.status,
-      resolutionReasons: resolution.reasons
-    };
-    if (target) {
-      db.prepare(
-        "INSERT INTO graph_edges(workspace_id,edge_type,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic) VALUES(?,?,?,?,?,?,?,?,?)"
-      ).run(
-        workspaceId,
-        "REMOTE_CALL_RESOLVES_TO_OPERATION",
-        "call",
-        String(call.id),
-        "operation",
-        String(target.operationId),
-        target.score,
-        JSON.stringify(evidence),
-        isDynamic ? 1 : 0
-      );
-      edges += 1;
-    } else {
-      const edgeType = callType === "local_db_query" ? "HANDLER_RUNS_DB_QUERY" : callType === "external_http" ? "HANDLER_CALLS_EXTERNAL_HTTP" : callType === "async_emit" ? "HANDLER_EMITS_EVENT" : callType === "async_subscribe" ? "EVENT_CONSUMED_BY_HANDLER" : resolution.status === "dynamic" ? "DYNAMIC_EDGE_CANDIDATE" : "UNRESOLVED_EDGE";
-      db.prepare(
-        "INSERT INTO graph_edges(workspace_id,edge_type,from_kind,from_id,to_kind,to_id,confidence,evidence_json,is_dynamic,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?)"
-      ).run(
-        workspaceId,
-        edgeType,
-        "call",
-        String(call.id),
-        callType.startsWith("async_") ? "event" : "external",
-        String(call.event_name_expr ?? call.query_entity ?? op ?? call.id),
-        Number(call.confidence ?? 0.2),
-        JSON.stringify(evidence),
-        isDynamic || resolution.status === "dynamic" ? 1 : 0,
-        String(
-          call.unresolved_reason ?? (resolution.status === "ambiguous" ? "Ambiguous operation candidates require a strong service signal" : resolution.status === "dynamic" ? "Dynamic target requires runtime variable overrides" : "No indexed target operation matched")
-        )
-      );
-      edges += 1;
-      unresolved += edgeType === "UNRESOLVED_EDGE" ? 1 : 0;
+        targetRepo: target?.repoName,
+        targetOperation: target?.operationName,
+        helperChain: call.helperChainJson ? JSON.parse(String(call.helperChainJson)) : void 0,
+        candidates: resolution.candidates,
+        candidateCount: resolution.candidates.length,
+        resolutionStatus: resolution.status,
+        resolutionReasons: resolution.reasons
+      };
+      if (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) VALUES(?,?,?,?,?,?,?,?,?,?)"
+        ).run(
+          workspaceId,
+          "REMOTE_CALL_RESOLVES_TO_OPERATION",
+          "resolved",
+          "call",
+          String(call.id),
+          "operation",
+          String(target.operationId),
+          target.score,
+          JSON.stringify(evidence),
+          isDynamic ? 1 : 0
+        );
+        edges += 1;
+        resolvedCount += 1;
+      } else {
+        const edgeType = callType === "local_db_query" ? "HANDLER_RUNS_DB_QUERY" : callType === "external_http" ? "HANDLER_CALLS_EXTERNAL_HTTP" : callType === "async_emit" ? "HANDLER_EMITS_EVENT" : callType === "async_subscribe" ? "EVENT_CONSUMED_BY_HANDLER" : resolution.status === "dynamic" ? "DYNAMIC_EDGE_CANDIDATE" : "UNRESOLVED_EDGE";
+        const status = edgeType === "DYNAMIC_EDGE_CANDIDATE" ? "dynamic" : resolution.status === "ambiguous" ? "ambiguous" : edgeType === "UNRESOLVED_EDGE" ? "unresolved" : "terminal";
+        const unresolvedReason = status === "terminal" ? null : String(
+          call.unresolved_reason ?? (resolution.status === "ambiguous" ? "Ambiguous operation candidates require a strong service signal" : resolution.status === "dynamic" ? `Dynamic target requires runtime variable overrides: ${(resolution.reasons.length ? resolution.reasons : ["missing runtime variables"]).join(", ")}` : "No indexed target operation matched")
+        );
+        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) VALUES(?,?,?,?,?,?,?,?,?,?,?)"
+        ).run(
+          workspaceId,
+          edgeType,
+          status,
+          "call",
+          String(call.id),
+          callType.startsWith("async_") ? "event" : "external",
+          String(call.event_name_expr ?? call.query_entity ?? op ?? call.id),
+          Number(call.confidence ?? 0.2),
+          JSON.stringify(evidence),
+          isDynamic || resolution.status === "dynamic" ? 1 : 0,
+          unresolvedReason
+        );
+        edges += 1;
+        unresolved += status === "unresolved" ? 1 : 0;
+        ambiguousCount += status === "ambiguous" ? 1 : 0;
+        dynamicCount += status === "dynamic" ? 1 : 0;
+        terminalCount += status === "terminal" ? 1 : 0;
+      }
     }
-  }
-  return { edgeCount: edges, unresolvedCount: unresolved };
+    return { edgeCount: edges, unresolvedCount: unresolved, resolvedCount, ambiguousCount, dynamicCount, terminalCount };
+  });
 }
 
 // src/trace/trace-engine.ts
@@ -1096,7 +1117,8 @@ function sourceFilesForStart(db, repoId, start) {
     `SELECT DISTINCT hc.source_file sourceFile
        FROM handler_classes hc LEFT JOIN handler_methods hm ON hm.handler_class_id=hc.id
        WHERE (? IS NULL OR hc.repo_id=?) AND (? IS NULL OR hc.class_name=? OR hm.method_name=?)
-         AND (? IS NULL OR hm.decorator_value=? OR hm.method_name=?)`
+         AND (? IS NULL OR hm.decorator_value=? OR hm.method_name=?)
+         AND (? IS NULL OR EXISTS (SELECT 1 FROM cds_services s JOIN cds_operations o ON o.service_id=s.id WHERE s.repo_id=hc.repo_id AND s.service_path=? AND (? IS NULL OR o.operation_path=? OR o.operation_name=? OR hm.decorator_value=? OR hm.method_name=?)))`
   ).all(
     repoId,
     repoId,
@@ -1105,8 +1127,16 @@ function sourceFilesForStart(db, repoId, start) {
     handler,
     operation,
     operation,
+    operation,
+    start.servicePath,
+    start.servicePath,
+    operation,
+    operation,
+    operation,
+    operation,
     operation
   );
+  if (start.servicePath && rows2.length === 0) return void 0;
   if (rows2.length === 0) return void 0;
   return new Set(rows2.map((row) => row.sourceFile).filter(Boolean));
 }
@@ -1150,7 +1180,7 @@ function graphForCalls(db, callIds) {
   if (callIds.length === 0) return map;
   const rows2 = db.prepare(
     `SELECT * FROM graph_edges WHERE from_kind='call' AND from_id IN (${callIds.map(() => "?").join(",")}) ORDER BY id`
-  ).all(...callIds);
+  ).all(...callIds.map((id) => String(id)));
   for (const row of rows2) {
     const id = Number(row.from_id);
     map.set(id, [...map.get(id) ?? [], row]);
@@ -1182,6 +1212,30 @@ function evidenceWithRuntimeVariables(evidence, vars) {
     } : void 0
   };
 }
+function operationNode(db, operationId) {
+  const row = db.prepare(`SELECT o.id operationId,o.operation_name operationName,o.operation_type operationType,o.operation_path operationPath,o.source_file sourceFile,o.source_line sourceLine,s.id serviceId,s.service_name serviceName,s.qualified_name qualifiedName,s.service_path servicePath,r.id repoId,r.name repoName 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(operationId);
+  if (!row) return void 0;
+  return { id: `operation:${operationId}`, kind: "operation", label: `${String(row.repoName)}:${String(row.servicePath)}${String(row.operationPath)}`, ...row };
+}
+function workspaceIdForCall(db, callId) {
+  return db.prepare("SELECT r.workspace_id workspaceId FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE c.id=?").get(callId)?.workspaceId;
+}
+function runtimeResolution(db, row, evidence, vars) {
+  if (!vars || Object.keys(vars).length === 0) return { row, evidence, unresolvedReason: row.unresolved_reason };
+  const nextEvidence = evidenceWithRuntimeVariables(evidence, vars);
+  const servicePath = typeof nextEvidence.servicePath === "string" ? nextEvidence.servicePath : void 0;
+  const operationPath = typeof nextEvidence.operationPath === "string" ? nextEvidence.operationPath : void 0;
+  const alias = typeof nextEvidence.serviceAliasExpr === "string" ? applyVariables(nextEvidence.serviceAliasExpr, vars) : typeof nextEvidence.serviceAlias === "string" ? applyVariables(nextEvidence.serviceAlias, vars) : void 0;
+  const destination = typeof nextEvidence.destination === "string" ? applyVariables(nextEvidence.destination, vars) : void 0;
+  const resolution = resolveOperation(db, { servicePath, operationPath, alias, destination, hasExplicitOverride: true, isDynamic: Boolean(row.status === "dynamic" || nextEvidence.resolutionStatus === "dynamic") }, workspaceIdForCall(db, row.from_id));
+  nextEvidence.runtimeResolutionStatus = resolution.status;
+  nextEvidence.runtimeResolutionReasons = resolution.reasons;
+  if (resolution.target) {
+    nextEvidence.runtimeResolvedCandidate = resolution.target;
+    return { row: { ...row, to_kind: "operation", to_id: String(resolution.target.operationId), unresolved_reason: void 0, confidence: resolution.target.score }, evidence: nextEvidence, target: resolution.target };
+  }
+  return { row, evidence: nextEvidence, unresolvedReason: resolution.status === "dynamic" ? `Dynamic target is missing runtime variables: ${resolution.reasons.join(", ")}` : resolution.status === "ambiguous" ? "Ambiguous runtime operation candidates" : "No runtime operation candidate matched substituted service and operation path" };
+}
 function edgeTarget(row, evidence) {
   const runtimeCandidate = evidence.runtimeResolvedCandidate;
   if (runtimeCandidate?.servicePath && runtimeCandidate.operationPath)
@@ -1242,33 +1296,32 @@ function trace(db, start, options) {
         const rawEvidence = JSON.parse(
           String(row.evidence_json || "{}")
         );
-        const evidence = evidenceWithRuntimeVariables(
-          rawEvidence,
-          options.vars
-        );
-        const targetNode = `${row.to_kind}:${row.to_id}`;
-        nodes.set(targetNode, {
+        const effective = runtimeResolution(db, row, rawEvidence, options.vars);
+        const evidence = effective.evidence;
+        const effectiveRow = effective.row;
+        const targetNode = `${effectiveRow.to_kind}:${effectiveRow.to_id}`;
+        const opNode = effectiveRow.to_kind === "operation" ? operationNode(db, effectiveRow.to_id) : void 0;
+        nodes.set(targetNode, opNode ?? {
           id: targetNode,
-          kind: row.to_kind,
-          label: row.to_id,
-          ...evidence
+          kind: effectiveRow.to_kind,
+          label: effectiveRow.to_id
         });
-        const to = edgeTarget(row, evidence);
+        const to = edgeTarget(effectiveRow, evidence);
         edges.push({
           step: current.depth,
           type: String(call.call_type),
           from: `${call.repoName}:${call.source_file}`,
           to,
           evidence,
-          confidence: Number(row.confidence ?? call.confidence),
-          unresolvedReason: row.unresolved_reason
+          confidence: Number(effectiveRow.confidence ?? call.confidence),
+          unresolvedReason: effective.unresolvedReason
         });
-        if (row.to_kind === "operation" && current.depth < maxDepth) {
-          const files = handlerFilesForOperation(db, row.to_id);
+        if (effectiveRow.to_kind === "operation" && current.depth < maxDepth) {
+          const files = handlerFilesForOperation(db, effectiveRow.to_id);
           if (files.size > 0) {
             const targetRepoId = db.prepare(
               "SELECT s.repo_id repoId FROM cds_operations o JOIN cds_services s ON s.id=o.service_id WHERE o.id=?"
-            ).get(row.to_id)?.repoId;
+            ).get(effectiveRow.to_id)?.repoId;
             const nextKey = `${targetRepoId ?? "*"}:${[...files].sort().join(",")}`;
             if (seenScopes.has(nextKey))
               edges.push({
@@ -1310,4 +1363,4 @@ export {
   linkWorkspace,
   trace
 };
-//# sourceMappingURL=chunk-JY6GBGZT.js.map
+//# sourceMappingURL=chunk-I33ASGX3.js.map