@saptools/service-flow 0.1.0

package/dist/cli.js

@@ -0,0 +1,804 @@
+#!/usr/bin/env node
+import {
+  discoverRepositories,
+  linkWorkspace,
+  normalizePath,
+  parseCdsFile,
+  parseDecorators,
+  parseHandlerRegistrations,
+  parseOutboundCalls,
+  parsePackageJson,
+  parseServiceBindings,
+  trace
+} from "./chunk-RFBHT6BQ.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import path6 from "path";
+import fs6 from "fs/promises";
+import pc from "picocolors";
+
+// src/config/defaults.ts
+var DEFAULT_IGNORES = [
+  "node_modules",
+  "gen",
+  "dist",
+  "coverage",
+  ".git",
+  ".turbo",
+  ".next",
+  ".cache",
+  ".service-flow"
+];
+var CONFIG_DIR = ".service-flow";
+var CONFIG_FILE = "config.json";
+var DEFAULT_DB_FILE = "service-flow.db";
+
+// src/config/workspace-config.ts
+import fs from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var schema = z.object({
+  rootPath: z.string(),
+  dbPath: z.string(),
+  ignore: z.array(z.string()),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+function configPath(rootPath) {
+  return path.join(rootPath, CONFIG_DIR, CONFIG_FILE);
+}
+function defaultDbPath(rootPath) {
+  return path.join(rootPath, CONFIG_DIR, DEFAULT_DB_FILE);
+}
+async function saveWorkspaceConfig(config) {
+  await fs.mkdir(path.dirname(configPath(config.rootPath)), {
+    recursive: true
+  });
+  await fs.writeFile(
+    configPath(config.rootPath),
+    `${JSON.stringify(config, null, 2)}
+`
+  );
+}
+async function loadWorkspaceConfig(workspace) {
+  const root = path.resolve(workspace ?? process.cwd());
+  const data = await fs.readFile(configPath(root), "utf8");
+  return schema.parse(JSON.parse(data));
+}
+function createWorkspaceConfig(rootPath, dbPath, ignore = [...DEFAULT_IGNORES]) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const root = path.resolve(rootPath);
+  return {
+    rootPath: root,
+    dbPath: path.resolve(dbPath ?? defaultDbPath(root)),
+    ignore,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+
+// src/db/connection.ts
+import { execFileSync } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+
+// src/db/schema.ts
+var schemaSql = `
+CREATE TABLE IF NOT EXISTS workspaces (id INTEGER PRIMARY KEY, root_path TEXT UNIQUE NOT NULL, db_path TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);
+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, UNIQUE(workspace_id, absolute_path));
+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));
+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);
+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);
+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);
+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);
+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);
+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);
+CREATE TABLE IF NOT EXISTS handler_registrations (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, handler_class_id INTEGER, registration_file TEXT NOT NULL, registration_line INTEGER NOT NULL, registration_kind TEXT NOT NULL, confidence REAL NOT 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, 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);
+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);
+CREATE TABLE IF NOT EXISTS graph_edges (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, edge_type TEXT NOT NULL, 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);
+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);
+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);
+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 VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(kind, name, path, repo);
+`;
+
+// src/db/migrations.ts
+function migrate(db) {
+  db.exec(schemaSql);
+}
+
+// src/db/connection.ts
+function quote(value) {
+  if (value === null || value === void 0) return "NULL";
+  if (typeof value === "number")
+    return Number.isFinite(value) ? String(value) : "NULL";
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return `'${String(value).replaceAll("'", "''")}'`;
+}
+function bind(sql, params) {
+  let index = 0;
+  return sql.replaceAll("?", () => quote(params[index++]));
+}
+function call(dbPath, args) {
+  return execFileSync("sqlite3", [dbPath, ...args], { encoding: "utf8" });
+}
+function jsonRows(dbPath, sql) {
+  const out = call(dbPath, ["-json", sql]);
+  if (!out.trim()) return [];
+  return JSON.parse(out);
+}
+function openDatabase(dbPath) {
+  fs2.mkdirSync(path2.dirname(dbPath), { recursive: true });
+  const db = {
+    path: dbPath,
+    exec(sql) {
+      call(dbPath, [sql]);
+    },
+    prepare(sql) {
+      return {
+        run: (...params) => {
+          call(dbPath, [bind(sql, params)]);
+          return { changes: 0 };
+        },
+        get: (...params) => jsonRows(dbPath, bind(sql, params))[0],
+        all: (...params) => jsonRows(dbPath, bind(sql, params))
+      };
+    },
+    pragma(sql) {
+      call(dbPath, [`PRAGMA ${sql}`]);
+    },
+    close() {
+    }
+  };
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  migrate(db);
+  return db;
+}
+
+// src/db/repositories.ts
+function upsertWorkspace(db, rootPath, dbPath) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    "INSERT INTO workspaces(root_path,db_path,created_at,updated_at) VALUES(?,?,?,?) ON CONFLICT(root_path) DO UPDATE SET db_path=excluded.db_path,updated_at=excluded.updated_at"
+  ).run(rootPath, dbPath, now, now);
+  return Number(
+    db.prepare("SELECT id FROM workspaces WHERE root_path=?").get(rootPath)?.id
+  );
+}
+function getWorkspace(db, rootPath) {
+  return db.prepare("SELECT * FROM workspaces WHERE root_path=?").get(rootPath);
+}
+function upsertRepository(db, workspaceId, r) {
+  db.prepare(
+    `INSERT INTO repositories(workspace_id,name,absolute_path,relative_path,package_name,package_version,dependencies_json,kind,is_git_repo) VALUES(?,?,?,?,?,?,?,?,?) ON CONFLICT(workspace_id,absolute_path) DO UPDATE SET name=excluded.name,relative_path=excluded.relative_path,package_name=excluded.package_name,package_version=excluded.package_version,dependencies_json=excluded.dependencies_json,kind=excluded.kind`
+  ).run(
+    workspaceId,
+    r.name,
+    r.absolutePath,
+    r.relativePath,
+    r.packageName,
+    r.packageVersion,
+    JSON.stringify(r.dependencies ?? {}),
+    r.kind ?? "unknown",
+    r.isGitRepo ? 1 : 0
+  );
+  return Number(
+    db.prepare(
+      "SELECT id FROM repositories WHERE workspace_id=? AND absolute_path=?"
+    ).get(workspaceId, r.absolutePath)?.id
+  );
+}
+function listRepositories(db) {
+  return db.prepare("SELECT * FROM repositories ORDER BY name").all();
+}
+function repoByName(db, name) {
+  return db.prepare("SELECT * FROM repositories WHERE name=? OR package_name=?").get(name, name);
+}
+function clearRepoFacts(db, repoId) {
+  for (const t of [
+    "cds_requires",
+    "cds_services",
+    "symbols",
+    "handler_classes",
+    "handler_registrations",
+    "service_bindings",
+    "outbound_calls",
+    "diagnostics",
+    "files"
+  ])
+    db.prepare(`DELETE FROM ${t} WHERE repo_id=?`).run(repoId);
+}
+function insertRequires(db, repoId, rows) {
+  const stmt = db.prepare(
+    "INSERT INTO cds_requires(repo_id,alias,kind,model,destination,service_path,request_timeout,raw_json) VALUES(?,?,?,?,?,?,?,?)"
+  );
+  for (const r of rows)
+    stmt.run(
+      repoId,
+      r.alias,
+      r.kind,
+      r.model,
+      r.destination,
+      r.servicePath,
+      r.requestTimeout,
+      r.rawJson
+    );
+}
+function insertService(db, repoId, s) {
+  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"
+    ).get(
+      repoId,
+      s.namespace,
+      s.serviceName,
+      s.qualifiedName,
+      s.servicePath,
+      s.isExtend ? 1 : 0,
+      s.sourceFile,
+      s.sourceLine
+    )?.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(?,?,?,?,?,?,?,?)"
+  );
+  for (const o of s.operations)
+    stmt.run(
+      id,
+      o.operationType,
+      o.operationName,
+      o.operationPath,
+      o.paramsJson,
+      o.returnType,
+      o.sourceFile,
+      o.sourceLine
+    );
+  return id;
+}
+function insertHandler(db, repoId, h) {
+  const sid = Number(
+    db.prepare(
+      "INSERT INTO symbols(repo_id,kind,name,qualified_name,exported,start_line,end_line) VALUES(?,?,?,?,?,?,?) RETURNING id"
+    ).get(
+      repoId,
+      "class",
+      h.className,
+      h.className,
+      1,
+      h.sourceLine,
+      h.sourceLine
+    )?.id
+  );
+  const hid = Number(
+    db.prepare(
+      "INSERT INTO handler_classes(repo_id,symbol_id,class_name,source_file,source_line) VALUES(?,?,?,?,?) RETURNING id"
+    ).get(repoId, sid, h.className, h.sourceFile, h.sourceLine)?.id
+  );
+  const stmt = db.prepare(
+    "INSERT INTO handler_methods(handler_class_id,method_name,decorator_kind,decorator_value,decorator_raw_expression,source_file,source_line) VALUES(?,?,?,?,?,?,?)"
+  );
+  for (const m of h.methods)
+    stmt.run(
+      hid,
+      m.methodName,
+      m.decoratorKind,
+      m.decoratorValue,
+      m.decoratorRawExpression,
+      m.sourceFile,
+      m.sourceLine
+    );
+  return hid;
+}
+function insertRegistrations(db, repoId, rows) {
+  const stmt = db.prepare(
+    "INSERT INTO handler_registrations(repo_id,handler_class_id,registration_file,registration_line,registration_kind,confidence) VALUES(?,?,?,?,?,?)"
+  );
+  for (const r of rows)
+    stmt.run(
+      repoId,
+      null,
+      r.registrationFile,
+      r.registrationLine,
+      r.registrationKind,
+      r.confidence
+    );
+}
+function insertBindings(db, repoId, rows) {
+  const stmt = db.prepare(
+    "INSERT INTO service_bindings(repo_id,variable_name,alias,destination_expr,service_path_expr,is_dynamic,placeholders_json,source_file,source_line) VALUES(?,?,?,?,?,?,?,?,?)"
+  );
+  for (const r of rows)
+    stmt.run(
+      repoId,
+      r.variableName,
+      r.alias,
+      r.destinationExpr,
+      r.servicePathExpr,
+      r.isDynamic ? 1 : 0,
+      JSON.stringify(r.placeholders),
+      r.sourceFile,
+      r.sourceLine
+    );
+}
+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=? ORDER BY id DESC LIMIT 1))"
+  );
+  for (const r of rows)
+    stmt.run(
+      repoId,
+      r.callType,
+      r.method,
+      r.operationPathExpr,
+      r.queryEntity,
+      r.eventNameExpr,
+      r.payloadSummary,
+      r.sourceFile,
+      r.sourceLine,
+      r.confidence,
+      r.unresolvedReason,
+      repoId,
+      r.serviceVariableName
+    );
+}
+
+// src/discovery/classify-repository.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+async function classifyRepository(repoPath, facts) {
+  const hasCdsDep = Boolean(
+    facts.dependencies["@sap/cds"] ?? facts.dependencies.cds ?? facts.dependencies["cds-routing-handlers"]
+  );
+  const cdsFiles = await findFiles(repoPath, ".cds");
+  const serverFiles = await Promise.all(
+    ["srv/server.ts", "srv/server.js", "src/server.ts", "src/server.js"].map(
+      async (f) => fs3.access(path3.join(repoPath, f)).then(() => true).catch(() => false)
+    )
+  );
+  const helper = Object.keys(facts.dependencies).includes("cds-routing-handlers") || facts.packageName?.includes("helper") === true;
+  if (helper && cdsFiles.length > 0) return "mixed";
+  if (helper) return "helper-package";
+  if (hasCdsDep && (cdsFiles.length > 0 || serverFiles.some(Boolean)))
+    return "cap-service";
+  if (cdsFiles.length > 0)
+    return serverFiles.some(Boolean) ? "cap-service" : "cap-db-model";
+  return "unknown";
+}
+async function findFiles(root, suffix) {
+  const out = [];
+  async function walk(dir) {
+    const entries = await fs3.readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!["node_modules", "dist", "gen", ".git"].includes(e.name))
+          await walk(path3.join(dir, e.name));
+      } else if (e.name.endsWith(suffix)) out.push(path3.join(dir, e.name));
+    }
+  }
+  await walk(root);
+  return out;
+}
+
+// src/indexer/repository-indexer.ts
+import fs5 from "fs/promises";
+import path5 from "path";
+
+// src/indexer/incremental-index.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+
+// src/utils/hashing.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+async function sha256File(filePath) {
+  return createHash("sha256").update(await readFile(filePath)).digest("hex");
+}
+
+// src/indexer/incremental-index.ts
+async function recordFile(db, repoId, repoPath, relativeFile) {
+  const abs = path4.join(repoPath, relativeFile);
+  const stat = await fs4.stat(abs);
+  const hash = await sha256File(abs);
+  db.prepare(
+    "INSERT INTO files(repo_id,relative_path,extension,sha256,size_bytes,last_indexed_at) VALUES(?,?,?,?,?,?) ON CONFLICT(repo_id,relative_path) DO UPDATE SET sha256=excluded.sha256,size_bytes=excluded.size_bytes,last_indexed_at=excluded.last_indexed_at"
+  ).run(
+    repoId,
+    normalizePath(relativeFile),
+    path4.extname(relativeFile),
+    hash,
+    stat.size,
+    (/* @__PURE__ */ new Date()).toISOString()
+  );
+}
+
+// src/utils/diagnostics.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/indexer/repository-indexer.ts
+async function indexRepository(db, repo, force) {
+  void force;
+  let diagnostics = 0;
+  let files = 0;
+  const facts = await parsePackageJson(repo.absolute_path);
+  const kind = await classifyRepository(repo.absolute_path, facts);
+  db.prepare(
+    "UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?"
+  ).run(
+    facts.packageName,
+    facts.packageVersion,
+    JSON.stringify(facts.dependencies),
+    kind,
+    "indexing",
+    repo.id
+  );
+  clearRepoFacts(db, repo.id);
+  insertRequires(db, repo.id, facts.cdsRequires);
+  const sourceFiles = await findSourceFiles(repo.absolute_path);
+  for (const file of sourceFiles) {
+    try {
+      await recordFile(db, repo.id, repo.absolute_path, file);
+      files += 1;
+      if (file.endsWith(".cds"))
+        for (const s of await parseCdsFile(repo.absolute_path, file))
+          insertService(db, repo.id, s);
+      if (/\.[jt]s$/.test(file)) {
+        for (const h of await parseDecorators(repo.absolute_path, file))
+          insertHandler(db, repo.id, h);
+        insertRegistrations(
+          db,
+          repo.id,
+          await parseHandlerRegistrations(repo.absolute_path, file)
+        );
+        insertBindings(
+          db,
+          repo.id,
+          await parseServiceBindings(repo.absolute_path, file)
+        );
+        insertCalls(
+          db,
+          repo.id,
+          await parseOutboundCalls(repo.absolute_path, file)
+        );
+      }
+    } catch (error) {
+      diagnostics += 1;
+      db.prepare(
+        "INSERT INTO diagnostics(repo_id,severity,code,message,source_file) VALUES(?,?,?,?,?)"
+      ).run(repo.id, "warning", "parse_failed", errorMessage(error), file);
+    }
+  }
+  db.prepare(
+    "UPDATE repositories SET last_indexed_at=?, index_status=?, error_count=? WHERE id=?"
+  ).run(
+    (/* @__PURE__ */ new Date()).toISOString(),
+    diagnostics ? "partial" : "indexed",
+    diagnostics,
+    repo.id
+  );
+  return { fileCount: files, diagnosticCount: diagnostics };
+}
+async function findSourceFiles(root) {
+  const out = [];
+  async function walk(dir, prefix = "") {
+    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(path5.join(dir, e.name), rel);
+      } else if (/\.(cds|ts|js)$/.test(e.name)) out.push(rel);
+    }
+  }
+  await walk(root);
+  return out.sort();
+}
+
+// src/indexer/workspace-indexer.ts
+async function indexWorkspace(db, workspaceId, options) {
+  const started = (/* @__PURE__ */ new Date()).toISOString();
+  const repos = options.repo ? [repoByName(db, options.repo)].filter((r) => r !== void 0) : listRepositories(db);
+  const runId = Number(
+    db.prepare(
+      "INSERT INTO index_runs(workspace_id,started_at,status,repo_count,file_count,diagnostic_count) VALUES(?,?,?,?,?,?) RETURNING id"
+    ).get(workspaceId, started, "running", repos.length, 0, 0)?.id
+  );
+  let fileCount = 0;
+  let diagnosticCount = 0;
+  for (const repo of repos) {
+    const result = await indexRepository(db, repo, options.force);
+    fileCount += result.fileCount;
+    diagnosticCount += result.diagnosticCount;
+  }
+  db.prepare(
+    "UPDATE index_runs SET finished_at=?, status=?, file_count=?, diagnostic_count=? WHERE id=?"
+  ).run(
+    (/* @__PURE__ */ new Date()).toISOString(),
+    diagnosticCount ? "partial" : "success",
+    fileCount,
+    diagnosticCount,
+    runId
+  );
+  return { repoCount: repos.length, fileCount, diagnosticCount };
+}
+
+// src/trace/selectors.ts
+function parseVars(values) {
+  const out = {};
+  for (const value of values ?? []) {
+    const [key, ...rest] = value.split("=");
+    if (key && rest.length > 0) out[key] = rest.join("=");
+  }
+  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 ?? "")}`
+    );
+  return `${lines.join("\n")}
+`;
+}
+
+// src/output/json-output.ts
+function renderJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function renderTraceJson(trace2) {
+  return renderJson(trace2);
+}
+
+// src/output/mermaid-output.ts
+function safe(value) {
+  return value.replace(/[^\w-]/g, "_").slice(0, 60);
+}
+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}"]`
+    );
+  return `${lines.join("\n")}
+`;
+}
+
+// src/cli.ts
+async function init(workspace, options) {
+  const config = createWorkspaceConfig(
+    workspace,
+    options.db,
+    options.ignore?.length ? options.ignore : [...DEFAULT_IGNORES]
+  );
+  const repos = await discoverRepositories(config.rootPath, config.ignore);
+  await saveWorkspaceConfig(config);
+  const db = openDatabase(config.dbPath);
+  const workspaceId = upsertWorkspace(db, config.rootPath, config.dbPath);
+  for (const repo of repos) {
+    const pkg = await parsePackageJson(repo.absolutePath);
+    const kind = await classifyRepository(repo.absolutePath, pkg);
+    upsertRepository(db, workspaceId, {
+      ...repo,
+      packageName: pkg.packageName,
+      packageVersion: pkg.packageVersion,
+      dependencies: pkg.dependencies,
+      kind
+    });
+  }
+  db.close();
+  process.stdout.write(
+    `Workspace: ${config.rootPath}
+Database: ${config.dbPath}
+Repositories: ${repos.length}
+Ignored: ${config.ignore.join(", ")}
+Next: service-flow index --workspace ${config.rootPath}
+`
+  );
+}
+async function withWorkspace(workspace, fn) {
+  const config = await loadWorkspaceConfig(workspace);
+  const db = openDatabase(config.dbPath);
+  try {
+    const row = getWorkspace(db, config.rootPath);
+    const workspaceId = row?.id ?? upsertWorkspace(db, config.rootPath, config.dbPath);
+    return await fn(db, workspaceId, config.rootPath);
+  } finally {
+    db.close();
+  }
+}
+function createProgram() {
+  const program = new Command();
+  program.name("service-flow").description(
+    "Trace SAP CAP service-to-service flows across multi-repository workspaces"
+  ).version("0.1.0");
+  program.command("init").argument("<workspace>").option("--db <path>").option("--ignore <pattern...>").action(
+    (workspace, opts) => void init(workspace, opts).catch(fail)
+  );
+  program.command("index").option("--workspace <path>").option("--repo <name>").option("--force").option("--concurrency <n>", "reserved for future parallel indexing", "1").action(
+    (opts) => void withWorkspace(opts.workspace, async (db, workspaceId) => {
+      const r = await indexWorkspace(db, workspaceId, {
+        repo: opts.repo,
+        force: Boolean(opts.force)
+      });
+      process.stdout.write(
+        `Indexed ${r.repoCount} repositories, ${r.fileCount} files, ${r.diagnosticCount} diagnostics
+`
+      );
+    }).catch(fail)
+  );
+  program.command("link").option("--workspace <path>").option("--force").action(
+    (opts) => void withWorkspace(opts.workspace, (db, workspaceId) => {
+      const r = linkWorkspace(db, workspaceId);
+      process.stdout.write(
+        `Linked ${r.edgeCount} edges, ${r.unresolvedCount} unresolved
+`
+      );
+    }).catch(fail)
+  );
+  program.command("trace").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").option("--handler <name>").option("--depth <n>", "trace depth", "25").option("--format <format>", "table|json|mermaid", "table").option("--include-external").option("--include-db").option("--include-async").option("--var <key=value>", "dynamic variable", collect, []).action(
+    (opts) => void withWorkspace(opts.workspace, (db) => {
+      const result = trace(
+        db,
+        {
+          repo: opts.repo,
+          servicePath: opts.service,
+          operation: opts.operation,
+          operationPath: opts.path,
+          handler: opts.handler
+        },
+        {
+          depth: Number(opts.depth),
+          vars: parseVars(opts.var),
+          includeExternal: Boolean(opts.includeExternal),
+          includeDb: Boolean(opts.includeDb),
+          includeAsync: Boolean(opts.includeAsync)
+        }
+      );
+      process.stdout.write(
+        opts.format === "json" ? renderTraceJson(result) : opts.format === "mermaid" ? renderMermaid(result) : renderTraceTable(result)
+      );
+    }).catch(fail)
+  );
+  const list = program.command("list");
+  list.command("repos").option("--workspace <path>").action(
+    (opts) => void withWorkspace(
+      opts.workspace,
+      (db) => process.stdout.write(
+        renderJson(
+          listRepositories(db).map((r) => ({
+            name: r.name,
+            kind: r.kind,
+            packageName: r.package_name
+          }))
+        )
+      )
+    ).catch(fail)
+  );
+  list.command("services").option("--workspace <path>").option("--repo <name>").action(
+    (opts) => void withWorkspace(opts.workspace, (db) => {
+      const repo = opts.repo ? repoByName(db, opts.repo) : void 0;
+      const rows = db.prepare(
+        "SELECT r.name repo,s.service_path servicePath,s.qualified_name qualifiedName FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE (? IS NULL OR s.repo_id=?) ORDER BY r.name,s.service_path"
+      ).all(repo?.id, repo?.id);
+      process.stdout.write(renderJson(rows));
+    }).catch(fail)
+  );
+  list.command("operations").option("--workspace <path>").option("--repo <name>").option("--service <path>").action(
+    (opts) => void withWorkspace(opts.workspace, (db) => {
+      const repo = opts.repo ? repoByName(db, opts.repo) : void 0;
+      const rows = db.prepare(
+        "SELECT r.name repo,s.service_path servicePath,o.operation_name operation,o.operation_path path 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 s.repo_id=?) AND (? IS NULL OR s.service_path=?)"
+      ).all(repo?.id, repo?.id, opts.service, opts.service);
+      process.stdout.write(renderJson(rows));
+    }).catch(fail)
+  );
+  list.command("calls").option("--workspace <path>").option("--repo <name>").option("--operation <name>").action(
+    (opts) => void withWorkspace(opts.workspace, (db) => {
+      const repo = opts.repo ? repoByName(db, opts.repo) : void 0;
+      const rows = db.prepare(
+        "SELECT r.name repo,c.call_type type,c.operation_path_expr path,c.source_file file,c.source_line line FROM outbound_calls c JOIN repositories r ON r.id=c.repo_id WHERE (? IS NULL OR c.repo_id=?)"
+      ).all(repo?.id, repo?.id);
+      process.stdout.write(renderJson(rows));
+    }).catch(fail)
+  );
+  program.command("graph").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").option("--format <format>", "mermaid|json", "mermaid").action(
+    (opts) => void withWorkspace(opts.workspace, (db) => {
+      const result = trace(
+        db,
+        {
+          repo: opts.repo,
+          operation: opts.operation,
+          servicePath: opts.service,
+          operationPath: opts.path
+        },
+        {
+          depth: 100,
+          includeAsync: true,
+          includeDb: true,
+          includeExternal: true
+        }
+      );
+      process.stdout.write(
+        opts.format === "json" ? renderTraceJson(result) : renderMermaid(result)
+      );
+    }).catch(fail)
+  );
+  const inspect = program.command("inspect");
+  inspect.command("repo").argument("<name>").option("--workspace <path>").action(
+    (name, opts) => void withWorkspace(
+      opts.workspace,
+      (db) => process.stdout.write(
+        renderJson(repoByName(db, name) ?? { error: "repo not found" })
+      )
+    ).catch(fail)
+  );
+  inspect.command("operation").argument("<selector>").option("--workspace <path>").action(
+    (selector, opts) => void withWorkspace(opts.workspace, (db) => {
+      const rows = db.prepare(
+        "SELECT * FROM cds_operations WHERE operation_name=? OR operation_path=?"
+      ).all(selector, selector);
+      process.stdout.write(renderJson(rows));
+    }).catch(fail)
+  );
+  program.command("doctor").option("--workspace <path>").action(
+    (opts) => void withWorkspace(opts.workspace, (db) => {
+      const diagnostics = db.prepare(
+        "SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics ORDER BY id"
+      ).all();
+      process.stdout.write(
+        diagnostics.length ? renderJson(diagnostics) : `${pc.green("No diagnostics recorded")}
+`
+      );
+    }).catch(fail)
+  );
+  program.command("clean").option("--workspace <path>").option("--db-only").action(
+    (opts) => void (async () => {
+      const config = await loadWorkspaceConfig(opts.workspace);
+      await fs6.rm(config.dbPath, { force: true });
+      if (!opts.dbOnly)
+        await fs6.rm(path6.dirname(config.dbPath), {
+          recursive: true,
+          force: true
+        });
+      process.stdout.write("Cleaned service-flow state\n");
+    })().catch(fail)
+  );
+  return program;
+}
+function collect(value, previous) {
+  previous.push(value);
+  return previous;
+}
+function fail(error) {
+  process.stderr.write(
+    `${error instanceof Error ? error.message : String(error)}
+`
+  );
+  process.exitCode = 1;
+}
+createProgram().parse(process.argv);
+export {
+  createProgram
+};
+//# sourceMappingURL=cli.js.map