@saptools/service-flow 0.1.37 → 0.1.38

package/src/config/defaults.ts

@@ -0,0 +1,14 @@
+export const DEFAULT_IGNORES = [
+  'node_modules',
+  'gen',
+  'dist',
+  'coverage',
+  '.git',
+  '.turbo',
+  '.next',
+  '.cache',
+  '.service-flow'
+] as const;
+export const CONFIG_DIR = '.service-flow';
+export const CONFIG_FILE = 'config.json';
+export const DEFAULT_DB_FILE = 'service-flow.db';

package/src/config/workspace-config.ts

@@ -0,0 +1,61 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  DEFAULT_DB_FILE,
+  DEFAULT_IGNORES,
+} from './defaults.js';
+const schema = z.object({
+  rootPath: z.string(),
+  dbPath: z.string(),
+  ignore: z.array(z.string()),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+export type WorkspaceConfig = z.infer<typeof schema>;
+export function configPath(rootPath: string): string {
+  return path.join(rootPath, CONFIG_DIR, CONFIG_FILE);
+}
+export function defaultDbPath(rootPath: string): string {
+  return path.join(rootPath, CONFIG_DIR, DEFAULT_DB_FILE);
+}
+export async function saveWorkspaceConfig(
+  config: WorkspaceConfig,
+): Promise<void> {
+  await fs.mkdir(path.dirname(configPath(config.rootPath)), {
+    recursive: true,
+  });
+  await fs.writeFile(
+    configPath(config.rootPath),
+    `${JSON.stringify(config, null, 2)}\n`,
+  );
+  if (path.dirname(config.dbPath) === path.dirname(configPath(config.rootPath)))
+    await fs.writeFile(
+      path.join(path.dirname(config.dbPath), '.service-flow-state'),
+      'service-flow\n',
+    );
+}
+export async function loadWorkspaceConfig(
+  workspace?: string,
+): Promise<WorkspaceConfig> {
+  const root = path.resolve(workspace ?? process.cwd());
+  const data = await fs.readFile(configPath(root), 'utf8');
+  return schema.parse(JSON.parse(data) as unknown);
+}
+export function createWorkspaceConfig(
+  rootPath: string,
+  dbPath?: string,
+  ignore: string[] = [...DEFAULT_IGNORES],
+): WorkspaceConfig {
+  const now = new Date().toISOString();
+  const root = path.resolve(rootPath);
+  return {
+    rootPath: root,
+    dbPath: path.resolve(dbPath ?? defaultDbPath(root)),
+    ignore,
+    createdAt: now,
+    updatedAt: now,
+  };
+}

package/src/db/connection.ts

@@ -0,0 +1,131 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { migrate } from './migrations.js';
+import { VERSION } from '../version.js';
+
+type SqlValue = string | number | bigint | Buffer | null | undefined;
+interface NativeStatement {
+  run: (...params: SqlValue[]) => { changes: number };
+  get: (...params: SqlValue[]) => Record<string, unknown> | undefined;
+  all: (...params: SqlValue[]) => Array<Record<string, unknown>>;
+}
+interface NativeDatabase {
+  exec: (sql: string) => void;
+  prepare: (sql: string) => NativeStatement;
+  close: () => void;
+}
+interface NodeSqliteModule {
+  DatabaseSync: new (location: string, options?: { open?: boolean; readOnly?: boolean }) => NativeDatabase;
+}
+
+let sqliteWarningFilterInstalled = false;
+function installSqliteWarningFilter(): void {
+  if (sqliteWarningFilterInstalled) return;
+  sqliteWarningFilterInstalled = true;
+  const original = process.emitWarning.bind(process);
+  process.emitWarning = ((warning: string | Error, ...args: unknown[]): void => {
+    const text = warning instanceof Error ? warning.message : String(warning);
+    if (text.includes('SQLite is an experimental feature')) return;
+    Reflect.apply(original, process, [warning, ...args]);
+  }) as typeof process.emitWarning;
+}
+export interface Statement {
+  run: (...params: unknown[]) => { changes: number };
+  get: (...params: unknown[]) => Record<string, unknown> | undefined;
+  all: (...params: unknown[]) => Array<Record<string, unknown>>;
+}
+export interface Db {
+  path: string;
+  readonly: boolean;
+  exec: (sql: string) => void;
+  prepare: (sql: string) => Statement;
+  pragma: (sql: string) => Array<Record<string, unknown>>;
+  transaction: <T>(fn: () => T) => T;
+  close: () => void;
+}
+export interface OpenDatabaseOptions {
+  readonly?: boolean;
+  migrate?: boolean;
+}
+function loadSqlite(): NodeSqliteModule {
+  try {
+    installSqliteWarningFilter();
+    const moduleValue = process.getBuiltinModule('node:sqlite') as unknown;
+    if (!moduleValue || typeof moduleValue !== 'object' || !('DatabaseSync' in moduleValue))
+      throw new Error('node:sqlite DatabaseSync is unavailable');
+    const sqlite = moduleValue as NodeSqliteModule;
+    if (typeof sqlite.DatabaseSync !== 'function')
+      throw new Error('node:sqlite DatabaseSync is not a constructor');
+    return sqlite;
+  } catch (error) {
+    throw new Error(
+      `service-flow ${VERSION} 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 },
+    );
+  }
+}
+function bindParams(params: unknown[]): SqlValue[] {
+  return params.map((param) => {
+    if (param === undefined || param === null) return null;
+    if (typeof param === 'string' || typeof param === 'number' || typeof param === 'bigint' || Buffer.isBuffer(param)) return param;
+    if (typeof param === 'boolean') return param ? 1 : 0;
+    return JSON.stringify(param);
+  });
+}
+export function openDatabase(dbPath: string, options: OpenDatabaseOptions = {}): Db {
+  fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+  const sqlite = loadSqlite();
+  const native = new sqlite.DatabaseSync(dbPath, { readOnly: Boolean(options.readonly) });
+  let inTransaction = false;
+  const db: Db = {
+    path: dbPath,
+    readonly: Boolean(options.readonly),
+    exec(sql: string): void {
+      native.exec(sql);
+    },
+    prepare(sql: string): Statement {
+      const statement = native.prepare(sql);
+      return {
+        run: (...params: unknown[]) => statement.run(...bindParams(params)),
+        get: (...params: unknown[]) => statement.get(...bindParams(params)),
+        all: (...params: unknown[]) => statement.all(...bindParams(params)),
+      };
+    },
+    pragma(sql: string): Array<Record<string, unknown>> {
+      const normalized = sql.trim().replace(/;$/, '');
+      if (/=/.test(normalized)) {
+        native.exec(`PRAGMA ${normalized}`);
+        return [];
+      }
+      return native.prepare(`PRAGMA ${normalized}`).all();
+    },
+    transaction<T>(fn: () => T): T {
+      if (inTransaction) return fn();
+      inTransaction = true;
+      native.exec('BEGIN IMMEDIATE');
+      try {
+        const result = fn();
+        native.exec('COMMIT');
+        return result;
+      } catch (error) {
+        native.exec('ROLLBACK');
+        throw error;
+      } finally {
+        inTransaction = false;
+      }
+    },
+    close(): void {
+      native.close();
+    },
+  };
+  db.pragma('busy_timeout = 10000');
+  db.pragma('foreign_keys = ON');
+  if (!options.readonly) {
+    db.pragma('journal_mode = WAL');
+    if (options.migrate !== false) migrate(db);
+  }
+  return db;
+}
+export function openReadOnlyDatabase(dbPath: string): Db {
+  return openDatabase(dbPath, { readonly: true, migrate: false });
+}

package/src/db/migrations.ts

@@ -0,0 +1,81 @@
+import type { Db } from './connection.js';
+import { schemaSql } from './schema.js';
+const CURRENT_SCHEMA_VERSION = 8;
+const columns: Record<string, Array<{ name: string; ddl: string }>> = {
+  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' },
+    { name: 'fact_analyzer_version', ddl: "ALTER TABLE repositories ADD COLUMN fact_analyzer_version TEXT DEFAULT 'legacy'" },
+  ],
+  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' },
+  ],
+  symbols: [
+    { name: 'start_offset', ddl: 'ALTER TABLE symbols ADD COLUMN start_offset INTEGER' },
+    { name: 'end_offset', ddl: 'ALTER TABLE symbols ADD COLUMN end_offset INTEGER' },
+    { name: 'source_file', ddl: 'ALTER TABLE symbols ADD COLUMN source_file TEXT' },
+    { name: 'exported_name', ddl: 'ALTER TABLE symbols ADD COLUMN exported_name TEXT' },
+    { name: 'evidence_json', ddl: 'ALTER TABLE symbols ADD COLUMN evidence_json TEXT' },
+  ],
+  outbound_calls: [
+    { name: 'local_service_name', ddl: 'ALTER TABLE outbound_calls ADD COLUMN local_service_name TEXT' },
+    { name: 'local_service_lookup', ddl: 'ALTER TABLE outbound_calls ADD COLUMN local_service_lookup TEXT' },
+    { name: 'alias_chain_json', ddl: 'ALTER TABLE outbound_calls ADD COLUMN alias_chain_json TEXT' },
+    { name: 'evidence_json', ddl: 'ALTER TABLE outbound_calls ADD COLUMN evidence_json TEXT' },
+    { name: 'external_target_kind', ddl: 'ALTER TABLE outbound_calls ADD COLUMN external_target_kind TEXT' },
+    { name: 'external_target_id', ddl: 'ALTER TABLE outbound_calls ADD COLUMN external_target_id TEXT' },
+    { name: 'external_target_label', ddl: 'ALTER TABLE outbound_calls ADD COLUMN external_target_label TEXT' },
+    { name: 'external_target_dynamic', ddl: 'ALTER TABLE outbound_calls ADD COLUMN external_target_dynamic INTEGER NOT NULL DEFAULT 0' },
+  ],
+  index_runs: [
+    { name: 'error_message', ddl: 'ALTER TABLE index_runs ADD COLUMN error_message TEXT' },
+  ],
+};
+function hasColumn(db: Db, table: string, column: string): boolean {
+  return (db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name?: string }>).some((row) => row.name === column);
+}
+function userVersion(db: Db): number {
+  const row = db.pragma('user_version')[0] as { user_version?: number } | undefined;
+  return Number(row?.user_version ?? 0);
+}
+function addMissingColumns(db: Db): void {
+  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): void {
+  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();
+}
+export function migrate(db: Db): void {
+  db.transaction(() => {
+    const version = userVersion(db);
+    if (version > CURRENT_SCHEMA_VERSION) throw new Error(`Unsupported future service-flow schema version ${version}`);
+    db.exec(schemaSql);
+    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}`);
+  });
+}
+export function schemaVersion(db: Db): number {
+  return userVersion(db);
+}
+export function foreignKeyViolations(db: Db): Array<Record<string, unknown>> {
+  return db.pragma('foreign_key_check');
+}

package/src/db/repositories.ts

@@ -0,0 +1,353 @@
+import type { Db } from './connection.js';
+import type {
+  CdsRequire,
+  CdsServiceFact,
+  HandlerClassFact,
+  HandlerRegistrationFact,
+  OutboundCallFact,
+  ServiceBindingFact,
+  ExecutableSymbolFact,
+  SymbolCallFact,
+} from '../types.js';
+export interface RepoRow {
+  id: number;
+  name: string;
+  absolute_path: string;
+  relative_path: string;
+  package_name: string | null;
+  package_version: string | null;
+  dependencies_json: string;
+  kind: string;
+  fingerprint?: string | null;
+  fact_generation?: number;
+  graph_generation?: number;
+  graph_stale_reason?: string | null;
+  fact_analyzer_version?: string | null;
+}
+export interface WorkspaceRow {
+  id: number;
+  root_path: string;
+  db_path: string;
+}
+export function upsertWorkspace(
+  db: Db,
+  rootPath: string,
+  dbPath: string,
+): number {
+  const now = 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,
+  );
+}
+export function getWorkspace(
+  db: Db,
+  rootPath: string,
+): WorkspaceRow | undefined {
+  return db
+    .prepare('SELECT * FROM workspaces WHERE root_path=?')
+    .get(rootPath) as WorkspaceRow | undefined;
+}
+export function upsertRepository(
+  db: Db,
+  workspaceId: number,
+  r: {
+    name: string;
+    absolutePath: string;
+    relativePath: string;
+    isGitRepo: boolean;
+    packageName?: string;
+    packageVersion?: string;
+    dependencies?: Record<string, string>;
+    kind?: string;
+  },
+): number {
+  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,
+  );
+}
+export function listRepositories(db: Db): RepoRow[] {
+  return db
+    .prepare('SELECT * FROM repositories ORDER BY name')
+    .all() as unknown as RepoRow[];
+}
+export function repoByName(db: Db, name: string): RepoRow | undefined {
+  return db
+    .prepare('SELECT * FROM repositories WHERE name=? OR package_name=?')
+    .get(name, name) as RepoRow | undefined;
+}
+export function clearRepoFacts(db: Db, repoId: number): void {
+  for (const t of [
+    'cds_requires',
+    'cds_services',
+    'handler_classes',
+    'outbound_calls',
+    'symbol_calls',
+    'handler_registrations',
+    'service_bindings',
+    'symbols',
+    'diagnostics',
+    'files',
+  ])
+    db.prepare(`DELETE FROM ${t} WHERE repo_id=?`).run(repoId);
+  db.prepare('DELETE FROM search_index WHERE repo=?').run(String(repoId));
+}
+export function insertRequires(
+  db: Db,
+  repoId: number,
+  rows: CdsRequire[],
+): void {
+  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,
+    );
+}
+export function insertService(
+  db: Db,
+  repoId: number,
+  s: CdsServiceFact,
+): number {
+  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(?,?,?,?,?,?,?,?)',
+  );
+  db.prepare(
+    'INSERT INTO search_index(kind,name,path,repo) VALUES(?,?,?,?)',
+  ).run('service', s.qualifiedName, s.servicePath, String(repoId));
+  for (const o of s.operations)
+    stmt.run(
+      id,
+      o.operationType,
+      o.operationName,
+      o.operationPath,
+      o.paramsJson,
+      o.returnType,
+      o.sourceFile,
+      o.sourceLine,
+    );
+  const search = db.prepare(
+    'INSERT INTO search_index(kind,name,path,repo) VALUES(?,?,?,?)',
+  );
+  for (const o of s.operations)
+    search.run('operation', o.operationName, o.operationPath, String(repoId));
+  return id;
+}
+export function insertHandler(
+  db: Db,
+  repoId: number,
+  h: HandlerClassFact,
+): number {
+  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;
+}
+export function insertRegistrations(
+  db: Db,
+  repoId: number,
+  rows: HandlerRegistrationFact[],
+): void {
+  const stmt = db.prepare(
+    '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) {
+    const handlerClass = r.className
+      ? (db
+          .prepare(
+            'SELECT id FROM handler_classes WHERE repo_id=? AND class_name=? ORDER BY id',
+          )
+          .all(repoId, r.className) as Array<{ id: number }>)
+      : [];
+    stmt.run(
+      repoId,
+      handlerClass.length === 1 ? handlerClass[0]?.id : null,
+      r.className,
+      r.importSource,
+      r.registrationFile,
+      r.registrationLine,
+      r.registrationKind,
+      r.confidence,
+    );
+  }
+}
+export function insertBindings(
+  db: Db,
+  repoId: number,
+  rows: ServiceBindingFact[],
+): void {
+  const stmt = db.prepare(
+    'INSERT INTO service_bindings(repo_id,variable_name,alias,alias_expr,destination_expr,service_path_expr,is_dynamic,placeholders_json,source_file,source_line,helper_chain_json) VALUES(?,?,?,?,?,?,?,?,?,?,?)',
+  );
+  for (const r of rows)
+    stmt.run(
+      repoId,
+      r.variableName,
+      r.alias,
+      r.aliasExpr,
+      r.destinationExpr,
+      r.servicePathExpr,
+      r.isDynamic ? 1 : 0,
+      JSON.stringify(r.placeholders),
+      r.sourceFile,
+      r.sourceLine,
+      r.helperChain ? JSON.stringify(r.helperChain) : null,
+    );
+}
+export function insertExecutableSymbols(db: Db, repoId: number, rows: ExecutableSymbolFact[]): void {
+  const stmt = db.prepare('INSERT INTO symbols(repo_id,file_id,kind,name,qualified_name,exported,start_line,end_line,start_offset,end_offset,source_file,exported_name,evidence_json) VALUES(?,(SELECT id FROM files WHERE repo_id=? AND relative_path=?),?,?,?,?,?,?,?,?,?,?,?)');
+  for (const r of rows) stmt.run(repoId, repoId, r.sourceFile, r.kind, r.localName, r.qualifiedName, r.exported ? 1 : 0, r.startLine, r.endLine, r.startOffset, r.endOffset, r.sourceFile, r.exportedName, r.importExportEvidence ? JSON.stringify(r.importExportEvidence) : null);
+}
+export function insertSymbolCalls(db: Db, repoId: number, rows: SymbolCallFact[]): void {
+  const callerStmt = db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1');
+  const insertStmt = db.prepare('INSERT INTO symbol_calls(repo_id,caller_symbol_id,callee_symbol_id,callee_expression,import_source,source_file,source_line,status,confidence,evidence_json,unresolved_reason) VALUES(?,?,?,?,?,?,?,?,?,?,?)');
+  for (const r of rows) {
+    const caller = callerStmt.get(repoId, r.sourceFile, r.callerQualifiedName) as { id?: number } | undefined;
+    const target = resolveSymbolCallTarget(db, repoId, r);
+    insertStmt.run(repoId, caller?.id, target.id, r.calleeExpression, r.importSource, r.sourceFile, r.sourceLine, target.status, 0.8, JSON.stringify({ ...r.evidence, candidateStrategy: target.strategy, candidateCount: target.candidateCount }), target.reason);
+  }
+}
+function isRelativeImportedSymbolCall(r: SymbolCallFact): boolean {
+  return Boolean(r.importSource?.startsWith('.'));
+}
+function resolveSymbolCallTarget(db: Db, repoId: number, r: SymbolCallFact): { id: number | null; status: string; reason: string | null; strategy: string; candidateCount: number } {
+  const evidence = r.evidence as { relation?: unknown };
+  const localRows = db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND (name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName) as Array<{ id: number }>;
+  if (localRows.length === 1) return { id: localRows[0]?.id ?? null, status: 'resolved', reason: null, strategy: 'same_file_exact', candidateCount: 1 };
+  if (localRows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple same-file symbol targets matched exactly', strategy: 'same_file_exact', candidateCount: localRows.length };
+  if (evidence.relation === 'class_instance_method' && isRelativeImportedSymbolCall(r)) {
+    const classRows = db.prepare('SELECT id FROM symbols WHERE repo_id=? AND source_file<>? AND qualified_name=? ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName) as Array<{ id: number }>;
+    if (classRows.length === 1) return { id: classRows[0]?.id ?? null, status: 'resolved', reason: null, strategy: 'relative_import_class_instance_method', candidateCount: 1 };
+    if (classRows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple relative class instance method targets matched exactly', strategy: 'relative_import_class_instance_method', candidateCount: classRows.length };
+  }
+  const rows = db.prepare('SELECT id,kind,evidence_json evidenceJson FROM symbols WHERE repo_id=? AND source_file<>? AND exported=1 AND (exported_name=? OR name=? OR qualified_name=?) ORDER BY id').all(repoId, r.sourceFile, r.calleeLocalName, r.calleeLocalName, r.calleeLocalName) as Array<{ id: number; kind?: string; evidenceJson?: string | null }>;
+  if (evidence.relation === 'relative_import_proxy_member' && rows.length > 1) {
+    const objectMapRows = rows.filter((row) => String(row.evidenceJson ?? '').includes('exported_object_shorthand') || String(row.evidenceJson ?? '').includes('exported_object_literal'));
+    if (objectMapRows.length > 0) {
+      const concrete = rows.find((row) => row.kind !== 'object_alias') ?? objectMapRows[0];
+      return { id: concrete?.id ?? null, status: 'resolved', reason: null, strategy: 'proxy_member_exported_object_map', candidateCount: rows.length };
+    }
+    return { id: null, status: 'ambiguous', reason: 'Proxy member target requires explicit factory/module/type evidence; global member name is ambiguous', strategy: 'proxy_member_no_global_name_fallback', candidateCount: rows.length };
+  }
+  if (rows.length === 1) return { id: rows[0]?.id ?? null, status: 'resolved', reason: null, strategy: evidence.relation === 'relative_import_proxy_member' ? 'proxy_member_unique_exported_candidate' : 'relative_import_exported_exact', candidateCount: 1 };
+  if (rows.length > 1) return { id: null, status: 'ambiguous', reason: 'Multiple exported symbol targets matched exactly', strategy: 'exported_exact', candidateCount: rows.length };
+  return { id: null, status: 'unresolved', reason: 'No local symbol target matched exactly', strategy: evidence.relation === 'relative_import_proxy_member' ? 'proxy_member_no_global_name_fallback' : 'exact_symbol_match', candidateCount: 0 };
+}
+export function insertCalls(
+  db: Db,
+  repoId: number,
+  rows: OutboundCallFact[],
+): void {
+  const stmt = db.prepare(
+    'INSERT INTO outbound_calls(repo_id,source_symbol_id,call_type,method,operation_path_expr,query_entity,event_name_expr,payload_summary,source_file,source_line,confidence,unresolved_reason,local_service_name,local_service_lookup,alias_chain_json,evidence_json,external_target_kind,external_target_id,external_target_label,external_target_dynamic,service_binding_id) VALUES(?,COALESCE((SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND qualified_name=? ORDER BY id LIMIT 1),(SELECT id FROM symbols WHERE repo_id=? AND source_file=? AND start_line<=? AND end_line>=? ORDER BY (end_line-start_line),id LIMIT 1)),?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,(SELECT id FROM service_bindings WHERE repo_id=? AND variable_name=? AND source_file=? ORDER BY CASE WHEN source_line<=? THEN 0 ELSE 1 END, ABS(source_line-?) ASC, id DESC LIMIT 1))',
+  );
+  for (const r of rows)
+    stmt.run(
+      repoId,
+      repoId,
+      r.sourceFile,
+      r.sourceSymbolQualifiedName,
+      repoId,
+      r.sourceFile,
+      r.sourceLine,
+      r.sourceLine,
+      r.callType,
+      r.method,
+      r.operationPathExpr,
+      r.queryEntity,
+      r.eventNameExpr,
+      r.payloadSummary,
+      r.sourceFile,
+      r.sourceLine,
+      r.confidence,
+      r.unresolvedReason,
+      r.localServiceName,
+      r.localServiceLookup,
+      r.aliasChain ? JSON.stringify(r.aliasChain) : null,
+      r.evidence ? JSON.stringify(r.evidence) : null,
+      r.externalTarget?.kind ?? null,
+      r.externalTarget?.stableId ?? null,
+      r.externalTarget?.label ?? null,
+      r.externalTarget?.dynamic ? 1 : 0,
+      repoId,
+      r.serviceVariableName,
+      r.sourceFile,
+      r.sourceLine,
+      r.sourceLine,
+    );
+}

package/src/db/schema.ts

@@ -0,0 +1,24 @@
+export const 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, fact_generation INTEGER NOT NULL DEFAULT 0, graph_generation INTEGER NOT NULL DEFAULT 0, graph_stale_reason TEXT, graph_stale_at TEXT, fact_analyzer_version 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);
+CREATE TABLE IF NOT EXISTS cds_operations (id INTEGER PRIMARY KEY, service_id INTEGER NOT NULL, operation_type TEXT NOT NULL, operation_name TEXT NOT NULL, operation_path TEXT NOT NULL, params_json TEXT NOT NULL, return_type TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(service_id) REFERENCES cds_services(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS symbols (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, file_id INTEGER, kind TEXT NOT NULL, name TEXT NOT NULL, qualified_name TEXT NOT NULL, exported INTEGER NOT NULL, start_line INTEGER NOT NULL, end_line INTEGER NOT NULL, start_offset INTEGER, end_offset INTEGER, source_file TEXT, exported_name TEXT, evidence_json TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS handler_classes (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, symbol_id INTEGER, class_name TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS handler_methods (id INTEGER PRIMARY KEY, handler_class_id INTEGER NOT NULL, method_name TEXT NOT NULL, decorator_kind TEXT NOT NULL, decorator_value TEXT, decorator_raw_expression TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, FOREIGN KEY(handler_class_id) REFERENCES handler_classes(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS handler_registrations (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, handler_class_id INTEGER, class_name TEXT, import_source TEXT, registration_file TEXT NOT NULL, registration_line INTEGER NOT NULL, registration_kind TEXT NOT NULL, confidence REAL NOT NULL, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(handler_class_id) REFERENCES handler_classes(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS service_bindings (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, symbol_id INTEGER, variable_name TEXT NOT NULL, alias TEXT, alias_expr TEXT, destination_expr TEXT, service_path_expr TEXT, is_dynamic INTEGER NOT NULL, placeholders_json TEXT NOT NULL, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, helper_chain_json TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS outbound_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, source_symbol_id INTEGER, call_type TEXT NOT NULL, service_binding_id INTEGER, method TEXT, operation_path_expr TEXT, query_entity TEXT, event_name_expr TEXT, payload_summary TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, confidence REAL NOT NULL, unresolved_reason TEXT, local_service_name TEXT, local_service_lookup TEXT, alias_chain_json TEXT, evidence_json TEXT, external_target_kind TEXT, external_target_id TEXT, external_target_label TEXT, external_target_dynamic INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(source_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL, FOREIGN KEY(service_binding_id) REFERENCES service_bindings(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS symbol_calls (id INTEGER PRIMARY KEY, repo_id INTEGER NOT NULL, caller_symbol_id INTEGER NOT NULL, callee_symbol_id INTEGER, callee_expression TEXT NOT NULL, import_source TEXT, source_file TEXT NOT NULL, source_line INTEGER NOT NULL, status TEXT NOT NULL, confidence REAL NOT NULL, evidence_json TEXT NOT NULL, unresolved_reason TEXT, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(caller_symbol_id) REFERENCES symbols(id) ON DELETE CASCADE, FOREIGN KEY(callee_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL);
+CREATE TABLE IF NOT EXISTS graph_edges (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, edge_type TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'unresolved', from_kind TEXT NOT NULL, from_id TEXT NOT NULL, to_kind TEXT NOT NULL, to_id TEXT NOT NULL, confidence REAL NOT NULL, evidence_json TEXT NOT NULL, is_dynamic INTEGER NOT NULL, unresolved_reason TEXT, generation INTEGER NOT NULL DEFAULT 0, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS index_runs (id INTEGER PRIMARY KEY, workspace_id INTEGER NOT NULL, started_at TEXT NOT NULL, finished_at TEXT, status TEXT NOT NULL, repo_count INTEGER NOT NULL, file_count INTEGER NOT NULL, diagnostic_count INTEGER NOT NULL, error_message TEXT, FOREIGN KEY(workspace_id) REFERENCES workspaces(id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS diagnostics (id INTEGER PRIMARY KEY, repo_id INTEGER, file_id INTEGER, severity TEXT NOT NULL, code TEXT NOT NULL, message TEXT NOT NULL, source_file TEXT, source_line INTEGER, FOREIGN KEY(repo_id) REFERENCES repositories(id) ON DELETE CASCADE, FOREIGN KEY(file_id) REFERENCES files(id) ON DELETE SET NULL);
+CREATE INDEX IF NOT EXISTS idx_repo_name ON repositories(name);
+CREATE INDEX IF NOT EXISTS idx_service_path ON cds_services(service_path);
+CREATE INDEX IF NOT EXISTS idx_operation_name ON cds_operations(operation_name, operation_path);
+CREATE INDEX IF NOT EXISTS idx_calls_repo ON outbound_calls(repo_id, call_type);
+CREATE INDEX IF NOT EXISTS idx_symbol_calls_caller ON symbol_calls(repo_id, caller_symbol_id);
+CREATE VIRTUAL TABLE IF NOT EXISTS search_index USING fts5(kind, name, path, repo);
+`;