@saptools/service-flow 0.1.0

package/dist/chunk-RFBHT6BQ.js

@@ -0,0 +1,686 @@
+#!/usr/bin/env node
+
+// src/discovery/discover-repositories.ts
+import fs from "fs/promises";
+import path2 from "path";
+
+// src/utils/path-utils.ts
+import path from "path";
+function normalizePath(value) {
+  return value.split(path.sep).join("/");
+}
+function relativePath(root, value) {
+  return normalizePath(path.relative(root, value) || ".");
+}
+function ensureLeadingSlash(value) {
+  return value.startsWith("/") ? value : `/${value}`;
+}
+function stripQuotes(value) {
+  return value.replace(/^['"`]|['"`]$/g, "");
+}
+
+// src/discovery/discover-repositories.ts
+async function discoverRepositories(rootPath, ignore) {
+  const root = path2.resolve(rootPath);
+  const ignored = new Set(ignore);
+  const found = [];
+  async function walk(dir) {
+    const rel = relativePath(root, dir);
+    if (rel !== "." && rel.split("/").some((part) => ignored.has(part))) return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    if (entries.some((e) => e.name === ".git" || e.name === ".git-fixture")) {
+      found.push({
+        name: path2.basename(dir),
+        absolutePath: dir,
+        relativePath: relativePath(root, dir),
+        isGitRepo: true
+      });
+      return;
+    }
+    for (const entry of entries)
+      if (entry.isDirectory() && !ignore.includes(entry.name))
+        await walk(path2.join(dir, entry.name));
+  }
+  await walk(root);
+  return found.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+
+// src/parsers/package-json-parser.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+function recordOfString(value) {
+  if (!value || typeof value !== "object") return {};
+  return Object.fromEntries(
+    Object.entries(value).filter(([, v]) => typeof v === "string")
+  );
+}
+function readRequires(cds) {
+  const requires = cds && typeof cds === "object" && "requires" in cds ? cds.requires : void 0;
+  if (!requires || typeof requires !== "object") return [];
+  return Object.entries(requires).flatMap(([alias, raw]) => {
+    if (!raw || typeof raw !== "object") return [];
+    const obj = raw;
+    const credentials = obj.credentials && typeof obj.credentials === "object" ? obj.credentials : {};
+    return [
+      {
+        alias,
+        kind: typeof obj.kind === "string" ? obj.kind : void 0,
+        model: typeof obj.model === "string" ? obj.model : void 0,
+        destination: typeof credentials.destination === "string" ? credentials.destination : void 0,
+        servicePath: typeof credentials.path === "string" ? credentials.path : void 0,
+        requestTimeout: typeof credentials.requestTimeout === "number" ? credentials.requestTimeout : void 0,
+        rawJson: JSON.stringify(raw)
+      }
+    ];
+  });
+}
+async function parsePackageJson(repoPath) {
+  try {
+    const raw = await fs2.readFile(path3.join(repoPath, "package.json"), "utf8");
+    const json = JSON.parse(raw);
+    return {
+      packageName: typeof json.name === "string" ? json.name : void 0,
+      packageVersion: typeof json.version === "string" ? json.version : void 0,
+      dependencies: {
+        ...recordOfString(json.dependencies),
+        ...recordOfString(json.devDependencies)
+      },
+      cdsRequires: readRequires(json.cds),
+      scripts: recordOfString(json.scripts)
+    };
+  } catch {
+    return { dependencies: {}, cdsRequires: [], scripts: {} };
+  }
+}
+
+// src/parsers/cds-parser.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+function lineOf(text, index) {
+  return text.slice(0, index).split("\n").length;
+}
+function pathAnno(prefix) {
+  return /@\s*\(?\s*path\s*:\s*['"]([^'"]+)['"]\s*\)?/.exec(prefix)?.[1];
+}
+async function parseCdsFile(repoPath, filePath) {
+  const absolute = path4.join(repoPath, filePath);
+  const text = await fs3.readFile(absolute, "utf8");
+  const namespace = /namespace\s+([\w.]+)\s*;/.exec(text)?.[1];
+  const services = [];
+  const serviceRegex = /((?:@\s*\(?\s*path\s*:\s*['"][^'"]+['"]\s*\)?\s*)?)(extend\s+)?service\s+(\w+)\s*(?:@\s*\(?\s*path\s*:\s*['"]([^'"]+)['"]\s*\)?\s*)?\{/g;
+  let match;
+  while (match = serviceRegex.exec(text)) {
+    const serviceName = match[3] ?? "UnknownService";
+    const start = match.index + match[0].length;
+    let depth = 1;
+    let end = start;
+    for (; end < text.length; end += 1) {
+      const c = text[end];
+      if (c === "{") depth += 1;
+      if (c === "}") depth -= 1;
+      if (depth === 0) break;
+    }
+    const body = text.slice(start, end);
+    const servicePath = ensureLeadingSlash(
+      match[4] ?? pathAnno(match[1] ?? "") ?? serviceName
+    );
+    const ops = [
+      ...body.matchAll(
+        /\b(action|function|event)\s+(\w+)\s*(?:\(([^)]*)\))?\s*(?:returns\s+([^;{]+))?/g
+      )
+    ].map((m) => ({
+      operationType: m[1] ?? "action",
+      operationName: m[2] ?? "unknown",
+      operationPath: ensureLeadingSlash(m[2] ?? "unknown"),
+      paramsJson: JSON.stringify(
+        (m[3] ?? "").split(",").map((p) => p.trim()).filter(Boolean)
+      ),
+      returnType: m[4]?.trim(),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf(text, start + (m.index ?? 0))
+    }));
+    services.push({
+      namespace,
+      serviceName,
+      qualifiedName: namespace ? `${namespace}.${serviceName}` : serviceName,
+      servicePath,
+      isExtend: Boolean(match[2]),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf(text, match.index),
+      operations: ops
+    });
+    serviceRegex.lastIndex = end;
+  }
+  return services;
+}
+
+// src/parsers/decorator-parser.ts
+import fs4 from "fs/promises";
+import path5 from "path";
+import ts2 from "typescript";
+
+// src/parsers/ts-project.ts
+import ts from "typescript";
+function createSourceFile(filePath, text) {
+  return ts.createSourceFile(
+    filePath,
+    text,
+    ts.ScriptTarget.Latest,
+    true,
+    filePath.endsWith(".js") ? ts.ScriptKind.JS : ts.ScriptKind.TS
+  );
+}
+
+// src/parsers/decorator-parser.ts
+function line(sf, pos) {
+  return sf.getLineAndCharacterOfPosition(pos).line + 1;
+}
+function decs(node) {
+  return ts2.canHaveDecorators(node) ? [...ts2.getDecorators(node) ?? []] : [];
+}
+function callName(d) {
+  const e = d.expression;
+  return ts2.isCallExpression(e) ? e.expression.getText() : e.getText();
+}
+function firstArg(d) {
+  const e = d.expression;
+  return ts2.isCallExpression(e) && e.arguments[0] ? e.arguments[0].getText() : "";
+}
+async function parseDecorators(repoPath, filePath) {
+  const text = await fs4.readFile(path5.join(repoPath, filePath), "utf8");
+  const sf = createSourceFile(filePath, text);
+  const constants = /* @__PURE__ */ new Map();
+  const handlers = [];
+  function visit(node) {
+    if (ts2.isVariableDeclaration(node) && ts2.isIdentifier(node.name) && node.initializer && ts2.isStringLiteralLike(node.initializer))
+      constants.set(node.name.text, node.initializer.text);
+    if (ts2.isClassDeclaration(node)) {
+      const className = node.name?.text ?? "AnonymousHandler";
+      const hasHandler = decs(node).some((d) => callName(d) === "Handler");
+      const methods = node.members.filter(ts2.isMethodDeclaration).flatMap(
+        (m) => decs(m).filter(
+          (d) => ["Func", "Action", "On", "Event"].includes(callName(d))
+        ).map((d) => {
+          const raw = firstArg(d);
+          const value = raw.startsWith('"') || raw.startsWith("'") || raw.startsWith("`") ? stripQuotes(raw) : constants.get(raw) ?? (raw.endsWith(".name") ? raw.split(".").at(-2) : void 0);
+          return {
+            methodName: m.name.getText(),
+            decoratorKind: callName(d),
+            decoratorValue: value,
+            decoratorRawExpression: raw,
+            sourceFile: normalizePath(filePath),
+            sourceLine: line(sf, m.getStart())
+          };
+        })
+      );
+      if (hasHandler || methods.length > 0)
+        handlers.push({
+          className,
+          sourceFile: normalizePath(filePath),
+          sourceLine: line(sf, node.getStart()),
+          methods
+        });
+    }
+    ts2.forEachChild(node, visit);
+  }
+  visit(sf);
+  return handlers;
+}
+
+// src/parsers/handler-registration-parser.ts
+import fs5 from "fs/promises";
+import path6 from "path";
+function lineOf2(text, idx) {
+  return text.slice(0, idx).split("\n").length;
+}
+async function parseHandlerRegistrations(repoPath, filePath) {
+  const text = await fs5.readFile(path6.join(repoPath, filePath), "utf8");
+  const out = [];
+  for (const m of text.matchAll(
+    /createCombinedHandler\s*\(|srv\.prepend\s*\(|cds\.serve\s*\(/g
+  ))
+    out.push({
+      registrationFile: normalizePath(filePath),
+      registrationLine: lineOf2(text, m.index ?? 0),
+      registrationKind: m[0].startsWith("cds") ? "cds.serve" : "combined-handler",
+      confidence: 0.8
+    });
+  for (const m of text.matchAll(
+    /(?:const|export\s+const)\s+handlers\s*=\s*\[([\s\S]*?)\]/g
+  ))
+    for (const c of (m[1] ?? "").matchAll(/\b(\w+Handler)\b/g))
+      out.push({
+        className: c[1],
+        registrationFile: normalizePath(filePath),
+        registrationLine: lineOf2(text, (m.index ?? 0) + (c.index ?? 0)),
+        registrationKind: "handler-array",
+        confidence: 0.9
+      });
+  return out;
+}
+
+// src/utils/redaction.ts
+var SENSITIVE = /authorization|cookie|token|secret|password|key|credential/i;
+function redactText(text) {
+  return text.replace(
+    /(authorization|cookie|token|secret|password|key|credential)\s*[:=]\s*(['"`]?)[^,'"`}\s]+\2/gi,
+    "$1: [REDACTED]"
+  );
+}
+function redactValue(value) {
+  if (Array.isArray(value)) return value.map(redactValue);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value))
+      out[k] = SENSITIVE.test(k) ? "[REDACTED]" : redactValue(v);
+    return out;
+  }
+  return typeof value === "string" ? redactText(value) : value;
+}
+function summarizeExpression(text) {
+  return redactText(text).slice(0, 240);
+}
+
+// src/parsers/outbound-call-parser.ts
+import fs6 from "fs/promises";
+import path7 from "path";
+function lineOf3(text, idx) {
+  return text.slice(0, idx).split("\n").length;
+}
+function firstArg2(body, key) {
+  return new RegExp(`${key}\\s*:\\s*([^,}\\n]+)`).exec(body)?.[1]?.trim();
+}
+async function parseOutboundCalls(repoPath, filePath) {
+  const text = await fs6.readFile(path7.join(repoPath, filePath), "utf8");
+  const out = [];
+  for (const m of text.matchAll(/(\w+)\.send\s*\(\s*\{([\s\S]*?)\}\s*\)/g)) {
+    const body = m[2] ?? "";
+    const query = firstArg2(body, "query");
+    const op = firstArg2(body, "path");
+    out.push({
+      callType: query ? "remote_query" : "remote_action",
+      serviceVariableName: m[1],
+      method: stripQuotes(firstArg2(body, "method") ?? "POST"),
+      operationPathExpr: op ? stripQuotes(op) : void 0,
+      queryEntity: /SELECT\.from\((\w+)\)/.exec(query ?? "")?.[1],
+      payloadSummary: summarizeExpression(body),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: op || query ? 0.8 : 0.4
+    });
+  }
+  for (const m of text.matchAll(/cds\.run\s*\(([\s\S]*?)\)/g))
+    out.push({
+      callType: "local_db_query",
+      queryEntity: /(?:SELECT\.from|INSERT\.into)\((\w+)\)/.exec(
+        m[1] ?? ""
+      )?.[1],
+      payloadSummary: summarizeExpression(m[1] ?? ""),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: 0.85
+    });
+  for (const m of text.matchAll(
+    /(\w+)\.(emit|publish|on)\s*\(\s*(['"`])([^'"`]+)\3/g
+  ))
+    out.push({
+      callType: m[2] === "on" ? "async_subscribe" : "async_emit",
+      serviceVariableName: m[1],
+      eventNameExpr: m[4],
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: 0.8
+    });
+  for (const m of text.matchAll(
+    /(?:axios\s*\(|executeHttpRequest\s*\(|useOrFetchDestination\s*\()([\s\S]*?)\)/g
+  ))
+    out.push({
+      callType: "external_http",
+      payloadSummary: summarizeExpression(m[1] ?? ""),
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: 0.7,
+      unresolvedReason: "External HTTP destination is outside indexed CAP services"
+    });
+  for (const m of text.matchAll(
+    /cds\.services(?:\[['"]([^'"]+)['"]\]|\.(\w+))\.(\w+)\s*\(/g
+  ))
+    out.push({
+      callType: "local_service_call",
+      operationPathExpr: `/${m[3] ?? ""}`,
+      payloadSummary: m[1] ?? m[2],
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf3(text, m.index ?? 0),
+      confidence: 0.75
+    });
+  return out;
+}
+
+// src/parsers/service-binding-parser.ts
+import fs7 from "fs/promises";
+import path8 from "path";
+function lineOf4(text, idx) {
+  return text.slice(0, idx).split("\n").length;
+}
+function placeholders(value) {
+  return [...(value ?? "").matchAll(/\$\{\s*(\w+)\s*\}/g)].map((m) => m[1] ?? "").filter(Boolean);
+}
+async function parseServiceBindings(repoPath, filePath) {
+  const text = await fs7.readFile(path8.join(repoPath, filePath), "utf8");
+  const out = [];
+  for (const m of text.matchAll(
+    /(?:const|let|this\.)\s*(\w+)\s*=\s*(?:await\s*)?cds\.connect\.to\((['"`])([^'"`]+)\2\)/g
+  ))
+    out.push({
+      variableName: m[1] ?? "service",
+      alias: m[3],
+      isDynamic: false,
+      placeholders: [],
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf4(text, m.index ?? 0)
+    });
+  for (const m of text.matchAll(
+    /(?:const|let|this\.)\s*(\w+)\s*=\s*(?:await\s*)?cds\.connect\.to\(\{([\s\S]*?)\}\s*\)/g
+  )) {
+    const body = m[2] ?? "";
+    const destination = /destination\s*:\s*([^,\n]+)/.exec(body)?.[1];
+    const servicePath = /path\s*:\s*([^,\n]+)/.exec(body)?.[1];
+    const dest = destination ? stripQuotes(destination.trim()) : void 0;
+    const svc = servicePath ? stripQuotes(servicePath.trim()) : void 0;
+    const ph = [...placeholders(dest), ...placeholders(svc)];
+    out.push({
+      variableName: m[1] ?? "service",
+      destinationExpr: dest,
+      servicePathExpr: svc,
+      isDynamic: ph.length > 0,
+      placeholders: ph,
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf4(text, m.index ?? 0)
+    });
+  }
+  for (const m of text.matchAll(
+    /function\s+(\w+)\s*\([^)]*\)\s*\{[\s\S]*?return\s+cds\.connect\.to\((['"])([^'"]+)\2\)/g
+  ))
+    out.push({
+      variableName: m[1] ?? "connect",
+      alias: m[3],
+      isDynamic: false,
+      placeholders: [],
+      sourceFile: normalizePath(filePath),
+      sourceLine: lineOf4(text, m.index ?? 0)
+    });
+  return out;
+}
+
+// src/linker/dynamic-edge-resolver.ts
+function applyVariables(template, vars) {
+  if (!template) return void 0;
+  return template.replace(
+    /\$\{\s*(\w+)\s*\}/g,
+    (_m, key) => vars[key] ?? `\${${key}}`
+  );
+}
+
+// src/linker/service-resolver.ts
+function findOperation(db, servicePath, operationPath, workspaceId) {
+  if (!operationPath) return void 0;
+  const row = db.prepare(
+    `SELECT o.id operationId,r.name repoName,s.service_path servicePath,o.operation_path operationPath,o.operation_name operationName,o.source_file sourceFile,o.source_line sourceLine
+       FROM cds_operations o
+       JOIN cds_services s ON s.id=o.service_id
+       JOIN repositories r ON r.id=s.repo_id
+       WHERE (? IS NULL OR r.workspace_id=?)
+         AND (? IS NULL OR s.service_path=?)
+         AND (o.operation_path=? OR o.operation_name=?)
+       ORDER BY CASE WHEN s.service_path=? THEN 0 ELSE 1 END
+       LIMIT 1`
+  ).get(
+    workspaceId,
+    workspaceId,
+    servicePath,
+    servicePath,
+    operationPath,
+    operationPath.replace(/^\//, ""),
+    servicePath
+  );
+  return row;
+}
+
+// src/linker/helper-package-linker.ts
+function linkHelperPackages(db, workspaceId) {
+  const repos = db.prepare(
+    "SELECT id,name,dependencies_json FROM repositories WHERE workspace_id=?"
+  ).all(workspaceId);
+  let count = 0;
+  for (const repo of repos) {
+    const deps = JSON.parse(repo.dependencies_json);
+    for (const dep of Object.keys(deps)) {
+      const helper = repos.find((r) => r.name === dep || dep.endsWith(r.name));
+      if (helper) {
+        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,
+          "REPO_IMPORTS_HELPER_PACKAGE",
+          "repo",
+          String(repo.id),
+          "repo",
+          String(helper.id),
+          0.9,
+          JSON.stringify({ dependency: dep }),
+          0
+        );
+        count += 1;
+      }
+    }
+  }
+  return count;
+}
+
+// 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.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,b.placeholders_json placeholdersJson,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 target = callType.startsWith("remote") ? findOperation(db, servicePath, op, workspaceId) : void 0;
+    const evidence = {
+      sourceFile: call.source_file,
+      sourceLine: call.source_line,
+      serviceAlias: call.alias,
+      destination: call.destinationExpr ?? call.requireDestination,
+      servicePath,
+      operationPath: op,
+      targetRepo: target?.repoName,
+      targetOperation: target?.operationName
+    };
+    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),
+        call.isDynamic ? 0.6 : 0.9,
+        JSON.stringify(evidence),
+        call.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" : call.isDynamic ? "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),
+        call.isDynamic ? 1 : 0,
+        String(call.unresolved_reason ?? "No indexed target operation matched")
+      );
+      edges += 1;
+      unresolved += edgeType === "UNRESOLVED_EDGE" ? 1 : 0;
+    }
+  }
+  return { edgeCount: edges, unresolvedCount: unresolved };
+}
+
+// src/trace/traversal.ts
+function limitDepth(edges, depth) {
+  return edges.filter((edge) => edge.step <= depth);
+}
+
+// src/trace/trace-engine.ts
+function normalizeOperation(value) {
+  if (!value) return void 0;
+  return value.startsWith("/") ? value.slice(1) : value;
+}
+function positiveDepth(value) {
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 25;
+}
+function sourceFilesForStart(db, repoId, start) {
+  const handler = start.handler;
+  const operation = normalizeOperation(start.operation ?? start.operationPath);
+  if (!handler && !operation) return void 0;
+  const rows = db.prepare(
+    `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=?)`
+  ).all(
+    repoId,
+    repoId,
+    handler,
+    handler,
+    handler,
+    operation,
+    operation,
+    operation
+  );
+  if (rows.length === 0) return void 0;
+  return new Set(
+    rows.map((row) => row.sourceFile).filter(Boolean)
+  );
+}
+function startScope(db, start) {
+  const repo = start.repo ? db.prepare(
+    "SELECT id,name FROM repositories WHERE name=? OR package_name=?"
+  ).get(start.repo, start.repo) : void 0;
+  if (start.repo && !repo)
+    return {
+      repo,
+      selectorMatched: false
+    };
+  const sourceFiles = sourceFilesForStart(db, repo?.id, start);
+  const hasSelector = Boolean(
+    start.handler ?? start.operation ?? start.operationPath
+  );
+  return {
+    repo,
+    sourceFiles,
+    selectorMatched: !hasSelector || sourceFiles !== void 0
+  };
+}
+function trace(db, start, options) {
+  const scope = startScope(db, start);
+  const calls = db.prepare(
+    `SELECT c.*,r.name repoName,b.alias,b.destination_expr destinationExpr,b.service_path_expr servicePathExpr,b.is_dynamic isDynamic,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 (? IS NULL OR c.repo_id=?) ORDER BY c.source_file,c.source_line`
+  ).all(scope.repo?.id, scope.repo?.id);
+  const vars = options.vars ?? {};
+  const filtered = calls.filter((c) => {
+    if (!scope.selectorMatched) return false;
+    if (scope.sourceFiles && !scope.sourceFiles.has(String(c.source_file)))
+      return false;
+    const type = String(c.call_type);
+    if (!options.includeDb && type === "local_db_query") return false;
+    if (!options.includeExternal && type === "external_http") return false;
+    if (!options.includeAsync && type.startsWith("async_")) return false;
+    return true;
+  });
+  const edges = filtered.map((c, index) => {
+    const operation = applyVariables(
+      c.operation_path_expr,
+      vars
+    );
+    const servicePath = applyVariables(
+      c.servicePathExpr ?? c.requireServicePath,
+      vars
+    );
+    const type = String(c.call_type);
+    const to = type === "local_db_query" ? `Entity: ${String(c.query_entity ?? "unknown")}` : type === "async_emit" ? `Topic: ${String(c.event_name_expr ?? "unknown")}` : type === "async_subscribe" ? `Topic: ${String(c.event_name_expr ?? "unknown")}` : type === "external_http" ? "External HTTP destination" : `${servicePath ?? ""}${operation ?? ""}` || String(c.event_name_expr ?? "unknown");
+    return {
+      step: index + 1,
+      type: c.isDynamic ? "dynamic_action" : type,
+      from: `${String(c.repoName)}:${String(c.source_file)}`,
+      to,
+      evidence: {
+        file: c.source_file,
+        line: c.source_line,
+        alias: c.alias,
+        destination: c.destinationExpr ?? c.requireDestination,
+        servicePath,
+        operationPath: operation,
+        method: c.method,
+        payloadSummary: c.payload_summary
+      },
+      confidence: Number(c.confidence ?? 0.5),
+      unresolvedReason: c.unresolved_reason
+    };
+  });
+  const diagnostics = db.prepare(
+    "SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics WHERE (? IS NULL OR repo_id=?)"
+  ).all(scope.repo?.id, scope.repo?.id);
+  if (!scope.selectorMatched)
+    diagnostics.unshift({
+      severity: "warning",
+      code: "trace_start_not_found",
+      message: "No handler source matched the requested trace start selector"
+    });
+  return {
+    start,
+    nodes: [],
+    edges: limitDepth(edges, positiveDepth(options.depth)),
+    diagnostics
+  };
+}
+
+export {
+  normalizePath,
+  stripQuotes,
+  discoverRepositories,
+  parsePackageJson,
+  parseCdsFile,
+  parseDecorators,
+  parseHandlerRegistrations,
+  redactText,
+  redactValue,
+  parseOutboundCalls,
+  parseServiceBindings,
+  applyVariables,
+  linkWorkspace,
+  trace
+};
+//# sourceMappingURL=chunk-RFBHT6BQ.js.map