@saptools/service-flow 0.1.5 → 0.1.7

package/dist/cli.js

@@ -10,12 +10,12 @@ import {
   parsePackageJson,
   parseServiceBindings,
   trace
-} from "./chunk-I33ASGX3.js";
+} from "./chunk-YFT57U54.js";
 
 // src/cli.ts
 import { Command } from "commander";
-import path6 from "path";
-import fs6 from "fs/promises";
+import path5 from "path";
+import fs5 from "fs/promises";
 import pc from "picocolors";
 
 // src/config/defaults.ts
@@ -90,7 +90,7 @@ 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, fingerprint TEXT, UNIQUE(workspace_id, absolute_path), FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS repositories (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, name TEXT NOT NULL, absolute_path TEXT NOT NULL, relative_path TEXT NOT NULL, package_name TEXT, package_version TEXT, dependencies_json TEXT DEFAULT '{}', kind TEXT NOT NULL, is_git_repo INTEGER NOT NULL, last_indexed_at TEXT, index_status TEXT DEFAULT 'pending', error_count INTEGER DEFAULT 0, fingerprint TEXT, fact_generation INTEGER NOT NULL DEFAULT 0, graph_generation INTEGER NOT NULL DEFAULT 0, graph_stale_reason TEXT, graph_stale_at TEXT, UNIQUE(workspace_id, absolute_path), FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS files (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, relative_path TEXT NOT NULL, extension TEXT NOT NULL, sha256 TEXT NOT NULL, size_bytes INTEGER NOT NULL, last_indexed_at TEXT NOT NULL, UNIQUE(repo_id, relative_path), FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS cds_requires (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, alias TEXT NOT NULL, kind TEXT, model TEXT, destination TEXT, service_path TEXT, request_timeout INTEGER, raw_json TEXT NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
 CREATE TABLE IF NOT EXISTS cds_services (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, namespace TEXT, service_name TEXT NOT NULL, qualified_name TEXT NOT NULL, service_path TEXT NOT NULL, is_extend INTEGER NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE);
@@ -98,11 +98,11 @@ CREATE TABLE IF NOT EXISTS cds_operations (id INTEGER PRIMARY KEY, service_id IN
 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 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, 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 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 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, 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, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
+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);
 CREATE INDEX IF NOT EXISTS idx_repo_name ON repositories(name);
 CREATE INDEX IF NOT EXISTS idx_service_path ON cds_services(service_path);
@@ -112,7 +112,31 @@ CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(kind, name, path, rep
 `;
 
 // src/db/migrations.ts
-var CURRENT_SCHEMA_VERSION = 2;
+var CURRENT_SCHEMA_VERSION = 3;
+var columns = {
+  service_bindings: [
+    { name: "helper_chain_json", ddl: "ALTER TABLE service_bindings ADD COLUMN helper_chain_json TEXT" },
+    { name: "alias_expr", ddl: "ALTER TABLE service_bindings ADD COLUMN alias_expr TEXT" }
+  ],
+  repositories: [
+    { name: "fingerprint", ddl: "ALTER TABLE repositories ADD COLUMN fingerprint TEXT" },
+    { name: "fact_generation", ddl: "ALTER TABLE repositories ADD COLUMN fact_generation INTEGER NOT NULL DEFAULT 0" },
+    { name: "graph_generation", ddl: "ALTER TABLE repositories ADD COLUMN graph_generation INTEGER NOT NULL DEFAULT 0" },
+    { name: "graph_stale_reason", ddl: "ALTER TABLE repositories ADD COLUMN graph_stale_reason TEXT" },
+    { name: "graph_stale_at", ddl: "ALTER TABLE repositories ADD COLUMN graph_stale_at TEXT" }
+  ],
+  graph_edges: [
+    { name: "status", ddl: "ALTER TABLE graph_edges ADD COLUMN status TEXT NOT NULL DEFAULT 'unresolved'" },
+    { name: "generation", ddl: "ALTER TABLE graph_edges ADD COLUMN generation INTEGER NOT NULL DEFAULT 0" }
+  ],
+  handler_registrations: [
+    { 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" }
+  ],
+  index_runs: [
+    { name: "error_message", ddl: "ALTER TABLE index_runs ADD COLUMN error_message TEXT" }
+  ]
+};
 function hasColumn(db, table, column) {
   return db.prepare(`PRAGMA table_info(${table})`).all().some((row) => row.name === column);
 }
@@ -120,25 +144,43 @@ function userVersion(db) {
   const row = db.pragma("user_version")[0];
   return Number(row?.user_version ?? 0);
 }
+function addMissingColumns(db) {
+  for (const [table, tableColumns] of Object.entries(columns)) {
+    for (const column of tableColumns) {
+      if (!hasColumn(db, table, column.name)) db.prepare(column.ddl).run();
+    }
+  }
+}
+function normalizeLegacyStatus(db) {
+  db.prepare("UPDATE graph_edges SET status=CASE WHEN edge_type='REMOTE_CALL_RESOLVES_TO_OPERATION' THEN 'resolved' WHEN edge_type IN ('HANDLER_RUNS_DB_QUERY','HANDLER_CALLS_EXTERNAL_HTTP','HANDLER_EMITS_EVENT','EVENT_CONSUMED_BY_HANDLER') THEN 'terminal' WHEN edge_type='DYNAMIC_EDGE_CANDIDATE' THEN 'dynamic' WHEN status='ambiguous' THEN 'ambiguous' ELSE status END").run();
+  db.prepare("UPDATE repositories SET graph_stale_reason='schema_migration_requires_relink', graph_stale_at=COALESCE(graph_stale_at, datetime('now')) WHERE EXISTS (SELECT 1 FROM graph_edges WHERE graph_edges.workspace_id=repositories.workspace_id) AND graph_generation=0").run();
+}
 function migrate(db) {
   db.transaction(() => {
+    const version = userVersion(db);
+    if (version > CURRENT_SCHEMA_VERSION) throw new Error(`Unsupported future service-flow schema version ${version}`);
     db.exec(schemaSql);
-    if (!hasColumn(db, "service_bindings", "helper_chain_json")) db.prepare("ALTER TABLE service_bindings ADD COLUMN helper_chain_json TEXT").run();
-    if (!hasColumn(db, "service_bindings", "alias_expr")) db.prepare("ALTER TABLE service_bindings ADD COLUMN alias_expr TEXT").run();
-    if (!hasColumn(db, "repositories", "fingerprint")) db.prepare("ALTER TABLE repositories ADD COLUMN fingerprint TEXT").run();
-    if (!hasColumn(db, "graph_edges", "status")) db.prepare("ALTER TABLE graph_edges ADD COLUMN status TEXT NOT NULL DEFAULT 'unresolved'").run();
-    db.prepare("UPDATE graph_edges SET status=CASE WHEN edge_type='REMOTE_CALL_RESOLVES_TO_OPERATION' THEN 'resolved' WHEN edge_type IN ('HANDLER_RUNS_DB_QUERY','HANDLER_CALLS_EXTERNAL_HTTP','HANDLER_EMITS_EVENT','EVENT_CONSUMED_BY_HANDLER') THEN 'terminal' WHEN edge_type='DYNAMIC_EDGE_CANDIDATE' THEN 'dynamic' ELSE status END").run();
-    db.pragma(`user_version = ${Math.max(userVersion(db), CURRENT_SCHEMA_VERSION)}`);
+    addMissingColumns(db);
+    normalizeLegacyStatus(db);
+    const violations = db.pragma("foreign_key_check");
+    if (violations.length > 0) throw new Error("SQLite foreign_key_check failed during migration");
+    db.pragma(`user_version = ${CURRENT_SCHEMA_VERSION}`);
   });
 }
 
 // src/db/connection.ts
 function loadSqlite() {
   try {
-    return process.getBuiltinModule("node:sqlite");
+    const moduleValue = process.getBuiltinModule("node:sqlite");
+    if (!moduleValue || typeof moduleValue !== "object" || !("DatabaseSync" in moduleValue))
+      throw new Error("node:sqlite DatabaseSync is unavailable");
+    const sqlite = moduleValue;
+    if (typeof sqlite.DatabaseSync !== "function")
+      throw new Error("node:sqlite DatabaseSync is not a constructor");
+    return sqlite;
   } catch (error) {
     throw new Error(
-      "service-flow requires a persistent SQLite driver. This build uses node:sqlite; run on Node.js with node:sqlite support or install a package build with its native SQLite dependency.",
+      "service-flow 0.1.7 requires Node.js >=24 with node:sqlite DatabaseSync support. Upgrade Node.js or install a service-flow build with a compatible SQLite driver.",
       { cause: error }
     );
   }
@@ -354,17 +396,23 @@ function insertHandler(db, repoId, h) {
 }
 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(?,?,?,?,?,?)"
+    "INSERT INTO handler_registrations(repo_id,handler_class_id,class_name,import_source,registration_file,registration_line,registration_kind,confidence) VALUES(?,?,?,?,?,?,?,?)"
   );
-  for (const r of rows)
+  for (const r of rows) {
+    const handlerClass = r.className ? db.prepare(
+      "SELECT id FROM handler_classes WHERE repo_id=? AND class_name=? ORDER BY id"
+    ).all(repoId, r.className) : [];
     stmt.run(
       repoId,
-      null,
+      handlerClass.length === 1 ? handlerClass[0]?.id : null,
+      r.className,
+      r.importSource,
       r.registrationFile,
       r.registrationLine,
       r.registrationKind,
       r.confidence
     );
+  }
 }
 function insertBindings(db, repoId, rows) {
   const stmt = db.prepare(
@@ -447,11 +495,12 @@ async function findFiles(root, suffix) {
   return out;
 }
 
-// src/indexer/repository-indexer.ts
-import fs5 from "fs/promises";
-import path5 from "path";
+// src/utils/diagnostics.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
-// src/indexer/incremental-index.ts
+// src/indexer/repository-indexer.ts
 import fs4 from "fs/promises";
 import path4 from "path";
 
@@ -465,104 +514,138 @@ function sha256Text(text) {
   return createHash("sha256").update(text).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()
-  );
-}
+// package.json
+var package_default = {
+  name: "@saptools/service-flow",
+  version: "0.1.7",
+  description: "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
+  type: "module",
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/"
+  },
+  bin: {
+    "service-flow": "dist/cli.js"
+  },
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js"
+    }
+  },
+  files: [
+    "CHANGELOG.md",
+    "README.md",
+    "TECHNICAL-NOTE.md",
+    "dist"
+  ],
+  engines: {
+    node: ">=24.0.0"
+  },
+  scripts: {
+    build: "tsup",
+    typecheck: "tsc --noEmit",
+    lint: "eslint src tests",
+    "test:unit": "vitest run tests/unit",
+    "test:e2e": "vitest run tests/e2e",
+    "test:e2e:fake": "vitest run tests/e2e"
+  },
+  keywords: [
+    "sap",
+    "cap",
+    "cds",
+    "btp",
+    "cli",
+    "service-graph",
+    "call-graph",
+    "sqlite",
+    "saptools"
+  ],
+  author: "Dong Tran",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/dongitran/saptools.git",
+    directory: "packages/service-flow"
+  },
+  homepage: "https://github.com/dongitran/saptools/tree/main/packages/service-flow#readme",
+  bugs: {
+    url: "https://github.com/dongitran/saptools/issues"
+  },
+  dependencies: {
+    commander: "13.1.0",
+    picocolors: "1.1.1",
+    typescript: "5.9.3",
+    zod: "4.4.3"
+  },
+  devDependencies: {
+    "@vitest/coverage-v8": "3.2.4",
+    tsup: "8.5.1",
+    vitest: "3.2.4"
+  }
+};
 
-// src/utils/diagnostics.ts
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
+// src/version.ts
+var VERSION = package_default.version;
+var ANALYZER_VERSION = package_default.version;
 
 // src/indexer/repository-indexer.ts
 async function indexRepository(db, repo, force) {
-  let diagnostics = 0;
-  let files = 0;
   const sourceFiles = await findSourceFiles(repo.absolute_path);
-  const facts = await parsePackageJson(repo.absolute_path);
-  const fingerprint = await repositoryFingerprint(repo.absolute_path, sourceFiles, facts.dependencies, Boolean(force));
+  const packageFacts = await parsePackageJson(repo.absolute_path);
+  const fingerprint = await repositoryFingerprint(repo.absolute_path, sourceFiles, packageFacts);
   if (!force && repo.fingerprint === fingerprint) return { fileCount: 0, diagnosticCount: 0, skipped: true };
-  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);
-  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);
+  const kind = await classifyRepository(repo.absolute_path, packageFacts);
+  try {
+    const parsed = await parseAllSourceFacts(repo.absolute_path, sourceFiles);
+    db.transaction(() => {
+      db.prepare("UPDATE repositories SET package_name=?, package_version=?, dependencies_json=?, kind=?, index_status=? WHERE id=?").run(packageFacts.packageName, packageFacts.packageVersion, JSON.stringify(packageFacts.dependencies), kind, "indexing", repo.id);
+      clearRepoFacts(db, repo.id);
+      insertRequires(db, repo.id, packageFacts.cdsRequires);
+      const fileStmt = 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");
+      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);
+      insertRegistrations(db, repo.id, parsed.registrations);
+      insertBindings(db, repo.id, parsed.bindings);
+      insertCalls(db, repo.id, parsed.calls);
+      db.prepare("UPDATE repositories SET last_indexed_at=?, index_status='indexed', error_count=0, fingerprint=?, fact_generation=COALESCE(fact_generation,0)+1, graph_stale_reason='facts_changed', graph_stale_at=? WHERE id=?").run((/* @__PURE__ */ new Date()).toISOString(), fingerprint, (/* @__PURE__ */ new Date()).toISOString(), repo.id);
+    });
+    return { fileCount: sourceFiles.length, diagnosticCount: 0, skipped: false };
+  } catch (error) {
+    const message = errorMessage(error);
+    db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repo.id);
+    db.prepare("INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)").run(repo.id, "error", "index_failed_snapshot_preserved", message);
+    return { fileCount: 0, diagnosticCount: 1, skipped: false };
+  }
+}
+async function parseAllSourceFacts(root, files) {
+  const facts = { services: [], handlers: [], registrations: [], bindings: [], calls: [], 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 });
+    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));
+      facts.calls.push(...await parseOutboundCalls(root, file));
     }
   }
-  db.prepare(
-    "UPDATE repositories SET last_indexed_at=?, index_status=?, error_count=?, fingerprint=? WHERE id=?"
-  ).run(
-    (/* @__PURE__ */ new Date()).toISOString(),
-    diagnostics ? "partial" : "indexed",
-    diagnostics,
-    fingerprint,
-    repo.id
-  );
-  return { fileCount: files, diagnosticCount: diagnostics, skipped: false };
+  return facts;
 }
 async function findSourceFiles(root) {
   const out = [];
   async function walk(dir, prefix = "") {
-    const entries = await fs5.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const entries = await fs4.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) && !isDefaultTestFile(rel))
-        out.push(rel);
+        if (!["node_modules", "dist", "gen", "coverage", ".git"].includes(e.name)) await walk(path4.join(dir, e.name), rel);
+      } else if (/\.(cds|ts|js)$/.test(e.name) && !isDefaultTestFile(rel)) out.push(rel);
     }
   }
   await walk(root);
@@ -570,15 +653,24 @@ async function findSourceFiles(root) {
 }
 function isDefaultTestFile(relativeFile) {
   const parts = relativeFile.split("/");
-  if (parts.some((part) => ["test", "tests", "__tests__"].includes(part)))
-    return true;
+  if (parts.some((part) => ["test", "tests", "__tests__"].includes(part))) return true;
   return /\.(test|spec)\.[jt]s$/.test(parts.at(-1) ?? "");
 }
-async function repositoryFingerprint(root, files, dependencies, force) {
-  void force;
-  const entries = ["schema:2", `deps:${JSON.stringify(Object.entries(dependencies).sort())}`];
+async function repositoryFingerprint(root, files, facts) {
+  const packageJson = await fs4.readFile(path4.join(root, "package.json"), "utf8").catch(() => "");
+  const normalizedFacts = {
+    analyzerVersion: ANALYZER_VERSION,
+    packageName: facts.packageName,
+    packageVersion: facts.packageVersion,
+    dependencies: Object.fromEntries(Object.entries(facts.dependencies).sort()),
+    cdsRequires: [...facts.cdsRequires].sort((a, b) => a.alias.localeCompare(b.alias)),
+    scripts: Object.fromEntries(Object.entries(facts.scripts).sort()),
+    includeTests: false,
+    packageJsonHash: sha256Text(packageJson)
+  };
+  const entries = [`facts:${JSON.stringify(normalizedFacts)}`];
   for (const file of files) {
-    const content = await fs5.readFile(path5.join(root, file), "utf8").catch(() => "");
+    const content = await fs4.readFile(path4.join(root, file), "utf8");
     entries.push(`${file}:${sha256Text(content)}`);
   }
   return sha256Text(entries.join("\n"));
@@ -588,30 +680,23 @@ async function repositoryFingerprint(root, files, dependencies, force) {
 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
-  );
+  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;
   let skippedCount = 0;
-  for (const repo of repos) {
-    const result = await indexRepository(db, repo, options.force);
-    fileCount += result.fileCount;
-    diagnosticCount += result.diagnosticCount;
-    skippedCount += result.skipped ? 1 : 0;
+  try {
+    for (const repo of repos) {
+      const result = await indexRepository(db, repo, options.force);
+      fileCount += result.fileCount;
+      diagnosticCount += result.diagnosticCount;
+      skippedCount += result.skipped ? 1 : 0;
+    }
+    db.prepare("UPDATE index_runs SET finished_at=?, status=?, file_count=?, diagnostic_count=? WHERE id=?").run((/* @__PURE__ */ new Date()).toISOString(), diagnosticCount ? "failed" : "success", fileCount, diagnosticCount, runId);
+    return { repoCount: repos.length, indexedCount: repos.length - skippedCount, skippedCount, fileCount, diagnosticCount };
+  } catch (error) {
+    db.prepare("UPDATE index_runs SET finished_at=?, status='failed', file_count=?, diagnostic_count=?, error_message=? WHERE id=?").run((/* @__PURE__ */ new Date()).toISOString(), fileCount, diagnosticCount + 1, errorMessage(error), runId);
+    throw error;
   }
-  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, indexedCount: repos.length - skippedCount, skippedCount, fileCount, diagnosticCount };
 }
 
 // src/trace/selectors.ts
@@ -727,7 +812,7 @@ 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.5");
+  ).version(VERSION);
   program.command("init").argument("<workspace>").option("--db <path>").option("--ignore <pattern...>").action(
     (workspace, opts) => void init(workspace, opts).catch(fail)
   );
@@ -747,7 +832,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} ambiguous, ${r.dynamicCount} dynamic, ${r.terminalCount} terminal
+        `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
 `
       );
     }).catch(fail)
@@ -794,6 +879,10 @@ function createProgram() {
   list.command("services").option("--workspace <path>").option("--repo <name>").action(
     (opts) => void withReadOnlyWorkspace(opts.workspace, (db) => {
       const repo = opts.repo ? repoByName(db, opts.repo) : void 0;
+      if (opts.repo && !repo) {
+        process.stdout.write(renderJson([{ severity: "warning", code: "selector_repo_not_found", message: `Repository selector not found: ${opts.repo}` }]));
+        return;
+      }
       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);
@@ -803,6 +892,10 @@ function createProgram() {
   list.command("operations").option("--workspace <path>").option("--repo <name>").option("--service <path>").action(
     (opts) => void withReadOnlyWorkspace(opts.workspace, (db) => {
       const repo = opts.repo ? repoByName(db, opts.repo) : void 0;
+      if (opts.repo && !repo) {
+        process.stdout.write(renderJson([{ severity: "warning", code: "selector_repo_not_found", message: `Repository selector not found: ${opts.repo}` }]));
+        return;
+      }
       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);
@@ -812,6 +905,10 @@ function createProgram() {
   list.command("calls").option("--workspace <path>").option("--repo <name>").option("--operation <name>").action(
     (opts) => void withReadOnlyWorkspace(opts.workspace, (db) => {
       const repo = opts.repo ? repoByName(db, opts.repo) : void 0;
+      if (opts.repo && !repo) {
+        process.stdout.write(renderJson([{ severity: "warning", code: "selector_repo_not_found", message: `Repository selector not found: ${opts.repo}` }]));
+        return;
+      }
       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=?) AND (? IS NULL OR c.operation_path_expr=? OR c.operation_path_expr=? OR c.payload_summary LIKE ?)"
       ).all(
@@ -885,7 +982,13 @@ function createProgram() {
                WHERE NOT EXISTS (SELECT 1 FROM search_index)
                UNION ALL
                SELECT 'error','foreign_key_violation','SQLite foreign_key_check reported integrity failures',NULL,NULL
-               WHERE EXISTS (SELECT 1 FROM pragma_foreign_key_check)`
+               WHERE EXISTS (SELECT 1 FROM pragma_foreign_key_check)
+               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','An index run is still marked running',NULL,NULL
+               WHERE EXISTS (SELECT 1 FROM index_runs WHERE status='running')`
       ).all(Boolean(opts.strict), Boolean(opts.strict));
       const allDiagnostics = [...diagnostics, ...health];
       process.stdout.write(
@@ -897,20 +1000,20 @@ function createProgram() {
   program.command("clean").option("--workspace <path>").option("--db-only").action(
     (opts) => void (async () => {
       const config = await loadWorkspaceConfig(opts.workspace);
-      const dbDir = path6.resolve(path6.dirname(config.dbPath));
-      const workspaceRoot = path6.resolve(config.rootPath);
-      await fs6.rm(config.dbPath, { force: true });
+      const dbDir = path5.resolve(path5.dirname(config.dbPath));
+      const workspaceRoot = path5.resolve(config.rootPath);
+      await fs5.rm(config.dbPath, { force: true });
       if (!opts.dbOnly) {
-        const marker = path6.join(dbDir, ".service-flow-state");
+        const marker = path5.join(dbDir, ".service-flow-state");
         const dangerous = /* @__PURE__ */ new Set([
-          path6.parse(dbDir).root,
+          path5.parse(dbDir).root,
           "/tmp",
-          process.env.HOME ? path6.resolve(process.env.HOME) : "",
+          process.env.HOME ? path5.resolve(process.env.HOME) : "",
           workspaceRoot
         ]);
         let ownsState;
         try {
-          ownsState = (await fs6.stat(marker)).isFile();
+          ownsState = (await fs5.stat(marker)).isFile();
         } catch {
           ownsState = false;
         }
@@ -918,7 +1021,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 fs6.rm(dbDir, { recursive: true, force: true });
+        await fs5.rm(dbDir, { recursive: true, force: true });
       }
       process.stdout.write("Cleaned service-flow state\n");
     })().catch(fail)