@saptools/service-flow 0.1.51 → 0.1.53

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import ts from 'typescript';
+
 type CallType = 'remote_action' | 'remote_query' | 'remote_entity_read' | 'remote_entity_mutation' | 'remote_entity_delete' | 'remote_entity_media' | 'remote_entity_candidate' | 'local_db_query' | 'external_http' | 'async_emit' | 'async_subscribe' | 'local_service_call' | 'unknown';
 interface DiscoveredRepository {
     name: string;
@@ -55,17 +57,36 @@ interface HandlerClassFact {
     sourceFile: string;
     sourceLine: number;
     methods: HandlerMethodFact[];
+    hasHandlerDecorator?: boolean;
+    classDecoratorNames?: string[];
+    observedDecoratorNames?: string[];
+    unsupportedDecoratorNames?: string[];
 }
+type HandlerMethodKind = 'operation' | 'entity_lifecycle' | 'event' | 'unsupported_lifecycle' | 'unsupported_decorator';
+type HandlerLifecyclePhase = 'on' | 'before' | 'after';
+type HandlerLifecycleEvent = 'CREATE' | 'READ' | 'UPDATE' | 'DELETE';
 interface HandlerMethodFact {
     methodName: string;
     decoratorKind: string;
     decoratorValue?: string;
     decoratorRawExpression: string;
+    handlerKind?: HandlerMethodKind;
+    executable?: boolean;
+    lifecyclePhase?: HandlerLifecyclePhase;
+    lifecycleEvent?: HandlerLifecycleEvent;
     decoratorResolution: {
         rawExpression: string;
+        decoratorExpression?: string;
+        argumentExpression?: string;
+        resolvedDecoratorKind?: string;
+        decoratorImportSource?: string;
         resolvedValue?: string;
-        resolutionKind: 'literal' | 'const_identifier' | 'enum_member' | 'const_object_property' | 'generated_constant_name' | 'unresolved';
+        resolutionKind: 'literal' | 'const_identifier' | 'enum_member' | 'const_object_property' | 'generated_constant_name' | 'lifecycle_implicit' | 'unresolved';
         unresolvedReason?: string;
+        handlerKind?: HandlerMethodKind;
+        executable?: boolean;
+        lifecyclePhase?: HandlerLifecyclePhase;
+        lifecycleEvent?: HandlerLifecycleEvent;
     };
     sourceFile: string;
     sourceLine: number;
@@ -138,6 +159,7 @@ interface ImplementationHint {
 type DynamicMode = 'strict' | 'candidates' | 'infer';
 interface TraceOptions {
     depth: number;
+    workspaceId?: number;
     vars?: Record<string, string>;
     includeExternal?: boolean;
     includeDb?: boolean;
@@ -165,17 +187,33 @@ interface TraceResult {
 
 declare function discoverRepositories(rootPath: string, ignore: readonly string[]): Promise<DiscoveredRepository[]>;
 
-declare function parsePackageJson(repoPath: string): Promise<PackageFacts>;
+interface ParsePackageJsonOptions {
+    strict?: boolean;
+    allowMissing?: boolean;
+}
+declare function parsePackageJson(repoPath: string, options?: ParsePackageJsonOptions): Promise<PackageFacts>;
+
+interface SourceFileSnapshot {
+    repoPath: string;
+    filePath: string;
+    text: string;
+    sizeBytes: number;
+    sourceFile: () => ts.SourceFile;
+}
+interface RepositorySourceContext {
+    get: (filePath: string) => SourceFileSnapshot | undefined;
+    entries: () => SourceFileSnapshot[];
+}
 
-declare function parseCdsFile(repoPath: string, filePath: string): Promise<CdsServiceFact[]>;
+declare function parseCdsFile(repoPath: string, filePath: string, context?: RepositorySourceContext): Promise<CdsServiceFact[]>;
 
-declare function parseDecorators(repoPath: string, filePath: string): Promise<HandlerClassFact[]>;
+declare function parseDecorators(repoPath: string, filePath: string, context?: RepositorySourceContext): Promise<HandlerClassFact[]>;
 
-declare function parseHandlerRegistrations(repoPath: string, filePath: string): Promise<HandlerRegistrationFact[]>;
+declare function parseHandlerRegistrations(repoPath: string, filePath: string, context?: RepositorySourceContext): Promise<HandlerRegistrationFact[]>;
 
-declare function parseServiceBindings(repoPath: string, filePath: string): Promise<ServiceBindingFact[]>;
+declare function parseServiceBindings(repoPath: string, filePath: string, context?: RepositorySourceContext): Promise<ServiceBindingFact[]>;
 
-declare function parseOutboundCalls(repoPath: string, filePath: string): Promise<OutboundCallFact[]>;
+declare function parseOutboundCalls(repoPath: string, filePath: string, context?: RepositorySourceContext): Promise<OutboundCallFact[]>;
 
 declare function parseGeneratedConstants(repoPath: string, filePath: string): Promise<GeneratedConstantFact[]>;
 

package/dist/index.js

@@ -17,7 +17,7 @@ import {
   stripQuotes,
   substituteVariables,
   trace
-} from "./chunk-YZJKE5UX.js";
+} from "./chunk-LFH7C46B.js";
 
 // src/parsers/generated-constants-parser.ts
 import fs from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saptools/service-flow",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/cli/000-clean.ts

@@ -0,0 +1,82 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { WorkspaceConfig } from '../config/workspace-config.js';
+import { openDatabase } from '../db/connection.js';
+import { getWorkspace, upsertWorkspace } from '../db/repositories.js';
+import { claimIndexRun } from '../indexer/workspace-indexer.js';
+import { errorMessage } from '../utils/diagnostics.js';
+
+type CleanConfig = Pick<WorkspaceConfig, 'dbPath' | 'rootPath'>;
+
+export async function cleanWorkspaceState(
+  config: CleanConfig,
+  dbOnly: boolean,
+): Promise<void> {
+  const dbDir = path.resolve(path.dirname(config.dbPath));
+  if (!dbOnly) await assertOwnedStateDirectory(dbDir, config.rootPath);
+  const runId = claimCleanWriter(config);
+  try {
+    if (dbOnly) await removeDatabaseFiles(config.dbPath);
+    else await fs.rm(dbDir, { recursive: true, force: true });
+  } catch (error) {
+    await markCleanClaimFailed(config.dbPath, runId, error);
+    throw error;
+  }
+}
+
+function claimCleanWriter(config: CleanConfig): number {
+  const db = openDatabase(config.dbPath);
+  try {
+    const workspaceId = getWorkspace(db, config.rootPath)?.id
+      ?? upsertWorkspace(db, config.rootPath, config.dbPath);
+    return claimIndexRun(db, workspaceId, 0);
+  } finally {
+    db.close();
+  }
+}
+
+async function assertOwnedStateDirectory(
+  dbDir: string,
+  rootPath: string,
+): Promise<void> {
+  const marker = path.join(dbDir, '.service-flow-state');
+  const dangerous = new Set([
+    path.parse(dbDir).root,
+    '/tmp',
+    process.env.HOME ? path.resolve(process.env.HOME) : '',
+    path.resolve(rootPath),
+  ]);
+  const ownsState = await fs.stat(marker)
+    .then((stat) => stat.isFile())
+    .catch(() => false);
+  if (!ownsState || dangerous.has(dbDir))
+    throw new Error(
+      `Refusing to recursively delete unowned or dangerous state directory: ${dbDir}. Use --db-only to remove only the database file.`,
+    );
+}
+
+async function removeDatabaseFiles(dbPath: string): Promise<void> {
+  for (const suffix of ['-wal', '-shm', '-journal'])
+    await fs.rm(`${dbPath}${suffix}`, { force: true });
+  await fs.rm(dbPath, { force: true });
+}
+
+async function markCleanClaimFailed(
+  dbPath: string,
+  runId: number,
+  error: unknown,
+): Promise<void> {
+  const exists = await fs.stat(dbPath).then(() => true).catch(() => false);
+  if (!exists) return;
+  const db = openDatabase(dbPath);
+  try {
+    db.prepare(`UPDATE index_runs SET finished_at=?,status='failed',
+      error_message=? WHERE id=? AND status='running'`).run(
+      new Date().toISOString(),
+      `Clean failed after writer claim: ${errorMessage(error)}`,
+      runId,
+    );
+  } finally {
+    db.close();
+  }
+}

package/src/cli/001-doctor-projection.ts

@@ -0,0 +1,140 @@
+import {
+  projectBounded,
+  stableProjectionValue,
+  type BoundedProjection,
+} from '../utils/000-bounded-projection.js';
+
+type Diagnostic = Record<string, unknown>;
+
+const boundedDoctorArrayKeys = new Set([
+  'candidates',
+  'candidateScores',
+  'candidateFamilies',
+  'candidateEvidence',
+  'candidatePaths',
+  'candidateRawPaths',
+  'candidateNormalizedOperationPaths',
+  'normalizedCandidateOperations',
+  'candidateLiterals',
+  'bindingCandidates',
+  'bindingAlternatives',
+  'registrations',
+  'implementationHintSuggestions',
+  'selectableImplementationRepositories',
+  'matchedHints',
+  'candidateSuggestions',
+  'dynamicTargetCandidates',
+  'dynamicTargetCandidateSuggestions',
+  'rejectedCandidates',
+  'suggestedVarSets',
+  'copyableExamples',
+  'examples',
+  'expandedExamples',
+  'selectorSuggestions',
+  'serviceSuggestions',
+  'repositories',
+]);
+
+export function boundDoctorDiagnostics(diagnostics: Diagnostic[]): Diagnostic[] {
+  return diagnostics.map(boundDoctorDiagnostic);
+}
+
+function boundDoctorDiagnostic(diagnostic: Diagnostic): Diagnostic {
+  const bounded = boundDoctorValue(diagnostic);
+  return isDiagnostic(bounded) ? bounded : {};
+}
+
+function boundDoctorValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(boundDoctorValue);
+  if (!isDiagnostic(value)) return value;
+  const input = value;
+  const output: Diagnostic = {};
+  for (const [key, child] of Object.entries(input)) {
+    if (!Array.isArray(child) || !boundedDoctorArrayKeys.has(key)) {
+      output[key] = boundDoctorValue(child);
+      continue;
+    }
+    const projection = projectBounded(child.map(boundDoctorValue), compareDiagnostic);
+    output[key] = projection.items;
+    addProjectionMetadata(output, input, key, projection);
+  }
+  return output;
+}
+
+function isDiagnostic(value: unknown): value is Diagnostic {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function addProjectionMetadata(
+  output: Diagnostic,
+  input: Diagnostic,
+  key: string,
+  projection: BoundedProjection<unknown>,
+): void {
+  const names = projectionNames(key);
+  const total = Math.max(
+    numericValue(input[names.total]),
+    projection.totalCount,
+    siblingCollectionCount(input, key),
+  );
+  output[names.total] = total;
+  output[names.shown] = projection.shownCount;
+  output[names.omitted] = Math.max(0, total - projection.shownCount);
+}
+
+function siblingCollectionCount(input: Diagnostic, key: string): number {
+  if (key !== 'examples' || !Array.isArray(input.expandedExamples)) return 0;
+  return input.expandedExamples.length;
+}
+
+function projectionNames(key: string): { total: string; shown: string; omitted: string } {
+  const stem = projectionStem(key);
+  return {
+    total: `${stem}Count`,
+    shown: `shown${upperFirst(stem)}Count`,
+    omitted: `omitted${upperFirst(stem)}Count`,
+  };
+}
+
+function projectionStem(key: string): string {
+  const stems: Record<string, string> = {
+    candidates: 'candidate',
+    candidateScores: 'candidateScore',
+    candidateFamilies: 'candidateFamily',
+    candidateEvidence: 'candidateEvidence',
+    candidatePaths: 'candidatePath',
+    candidateRawPaths: 'candidateRawPath',
+    candidateNormalizedOperationPaths: 'candidateNormalizedOperationPath',
+    normalizedCandidateOperations: 'normalizedCandidateOperation',
+    candidateLiterals: 'candidateLiteral',
+    bindingCandidates: 'bindingCandidate',
+    bindingAlternatives: 'bindingAlternative',
+    registrations: 'registration',
+    implementationHintSuggestions: 'implementationHintSuggestion',
+    selectableImplementationRepositories: 'selectableImplementationRepository',
+    matchedHints: 'matchedHint',
+    candidateSuggestions: 'candidateSuggestion',
+    dynamicTargetCandidates: 'dynamicTargetCandidate',
+    dynamicTargetCandidateSuggestions: 'dynamicTargetCandidateSuggestion',
+    rejectedCandidates: 'rejectedCandidate',
+    suggestedVarSets: 'suggestedVarSet',
+    copyableExamples: 'copyableExample',
+    examples: 'example',
+    expandedExamples: 'expandedExample',
+    selectorSuggestions: 'selectorSuggestion',
+    serviceSuggestions: 'serviceSuggestion',
+  };
+  return stems[key] ?? 'repository';
+}
+
+function compareDiagnostic(left: unknown, right: unknown): number {
+  return stableProjectionValue(left).localeCompare(stableProjectionValue(right));
+}
+
+function numericValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
+function upperFirst(value: string): string {
+  return value ? `${value[0]?.toUpperCase() ?? ''}${value.slice(1)}` : value;
+}

package/src/cli/doctor.ts

@@ -1,6 +1,7 @@
 import type { Db } from '../db/connection.js';
 import { classifyODataPathIntent, normalizeODataOperationInvocationPath } from '../linker/odata-path-normalizer.js';
 import { implementationHintSuggestions } from '../trace/implementation-hints.js';
+import { boundDoctorDiagnostics } from './001-doctor-projection.js';
 import { ANALYZER_VERSION } from '../version.js';
 
 type Diagnostic = Record<string, unknown>;
@@ -15,7 +16,7 @@ export function linkUpgradeWarnings(db: Db): Diagnostic[] {
 
 export function doctorDiagnostics(db: Db, strict: boolean, options: DoctorOptions = {}): Diagnostic[] {
   const diagnostics = db.prepare('SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics ORDER BY id').all() as Diagnostic[];
-  return [
+  return boundDoctorDiagnostics([
     ...diagnostics,
     ...healthDiagnostics(db, strict),
     ...remoteTargetWithoutImplementationDiagnostics(db, strict, Boolean(options.detail)),
@@ -23,7 +24,7 @@ export function doctorDiagnostics(db: Db, strict: boolean, options: DoctorOption
     ...schemaDriftDiagnostics(db, strict),
     ...analyzerVersionDiagnostics(db, strict),
     ...parserQualityDiagnostics(db, strict, options),
-  ];
+  ]);
 }
 
 function healthDiagnostics(db: Db, strict: boolean): Diagnostic[] {
@@ -252,6 +253,10 @@ function addImplementationCategory(grouped: Map<string, Diagnostic & { count: nu
   const current = grouped.get(key) ?? { category, baseOperation, reason, candidateFamily: family, count: 0, servicePaths: [], examples: [] };
   const hintSuggestions = implementationSuggestions(evidence);
   const candidates = asRecords(evidence.candidates);
+  const candidateCount = Math.max(
+    numericValue(evidence.candidateCount),
+    candidates.length,
+  );
   current.count += 1;
   current.servicePaths.push(String(row.servicePath ?? evidence.servicePath ?? ''));
   current.examples.push({
@@ -259,7 +264,15 @@ function addImplementationCategory(grouped: Map<string, Diagnostic & { count: nu
     operation: row.operationName,
     status: row.status,
     reason: row.unresolvedReason,
-    candidateCount: candidates.length,
+    candidateCount,
+    shownCandidateCount: Math.min(
+      candidateCount,
+      numericValue(evidence.shownCandidateCount) || candidates.length,
+    ),
+    omittedCandidateCount: Math.max(
+      0,
+      candidateCount - (numericValue(evidence.shownCandidateCount) || candidates.length),
+    ),
     candidateEvidence: candidates.slice(0, 3),
     implementationHintSuggestions: hintSuggestions,
   });
@@ -655,6 +668,10 @@ function candidateCount(value: unknown): number {
   return Number(parseObject(value).candidateCount ?? 0);
 }
 
+function numericValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+
 function parseObject(value: unknown): Diagnostic {
   if (value && typeof value === 'object' && !Array.isArray(value)) return value as Diagnostic;
   try {

package/src/cli.ts

@@ -1,17 +1,16 @@
 import { Command } from 'commander';
-import path from 'node:path';
-import fs from 'node:fs/promises';
 import { DEFAULT_IGNORES } from './config/defaults.js';
 import {
   createWorkspaceConfig,
   loadWorkspaceConfig,
   saveWorkspaceConfig,
 } from './config/workspace-config.js';
-import { openDatabase, openReadOnlyDatabase } from './db/connection.js';
+import { openDatabase, openReadOnlyDatabase, type Db } from './db/connection.js';
 import {
   getWorkspace,
   listRepositories,
-  repoByName,
+  reposByName,
+  type RepoRow,
   upsertRepository,
   upsertWorkspace,
 } from './db/repositories.js';
@@ -22,7 +21,10 @@ import { indexWorkspace } from './indexer/workspace-indexer.js';
 import { linkWorkspace } from './linker/cross-repo-linker.js';
 import { doctorDiagnostics, linkUpgradeWarnings } from './cli/doctor.js';
 import { trace } from './trace/trace-engine.js';
-import { parseVars } from './trace/selectors.js';
+import {
+  parseVars,
+  selectorRepoAmbiguousDiagnostic,
+} from './trace/selectors.js';
 import { parseImplementationHint } from './trace/implementation-hints.js';
 import { renderTraceTable } from './output/table-output.js';
 import { renderTraceJson, renderJson } from './output/json-output.js';
@@ -30,6 +32,7 @@ import { renderDoctorDiagnostics } from './output/doctor-output.js';
 import { renderMermaid } from './output/mermaid-output.js';
 import { VERSION } from './version.js';
 import type { DynamicMode } from './types.js';
+import { cleanWorkspaceState } from './cli/000-clean.js';
 async function init(
   workspace: string,
   options: { db?: string; ignore?: string[] },
@@ -92,6 +95,30 @@ async function withReadOnlyWorkspace<T>(
     db.close();
   }
 }
+function selectRepository(db: Db, selector: string, workspaceId?: number): {
+  repo?: RepoRow;
+  diagnostic?: Record<string, unknown>;
+} {
+  const candidates = reposByName(db, selector, workspaceId);
+  if (candidates.length === 1) return { repo: candidates[0] };
+  if (candidates.length === 0) return {
+    diagnostic: {
+      severity: 'warning',
+      code: 'selector_repo_not_found',
+      message: `Repository selector not found: ${selector}`,
+    },
+  };
+  return {
+    diagnostic: selectorRepoAmbiguousDiagnostic(
+      selector,
+      candidates.map((repo) => ({
+        id: repo.id,
+        name: repo.name,
+        packageName: repo.package_name ?? undefined,
+      })),
+    ),
+  };
+}
 export function createProgram(): Command {
   const program = new Command();
   program
@@ -177,7 +204,7 @@ export function createProgram(): Command {
         dynamicMode: string;
         maxDynamicCandidates: string;
       }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db) => {
+        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
           const result = trace(
             db,
             {
@@ -189,6 +216,7 @@ export function createProgram(): Command {
             },
             {
               depth: Number(opts.depth),
+              workspaceId,
               vars: parseVars(opts.var),
               includeExternal: Boolean(opts.includeExternal),
               includeDb: Boolean(opts.includeDb),
@@ -214,10 +242,10 @@ export function createProgram(): Command {
     .option('--workspace <path>')
     .action(
       (opts: { workspace?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db) =>
+        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) =>
           process.stdout.write(
             renderJson(
-              listRepositories(db).map((r) => ({
+              listRepositories(db, workspaceId).map((r) => ({
                 name: r.name,
                 kind: r.kind,
                 packageName: r.package_name,
@@ -232,17 +260,20 @@ export function createProgram(): Command {
     .option('--repo <name>')
     .action(
       (opts: { workspace?: string; repo?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db) => {
-          const repo = opts.repo ? repoByName(db, opts.repo) : undefined;
-          if (opts.repo && !repo) {
-            process.stdout.write(renderJson([{ severity: 'warning', code: 'selector_repo_not_found', message: `Repository selector not found: ${opts.repo}` }]));
+        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+          const selection = opts.repo
+            ? selectRepository(db, opts.repo, workspaceId)
+            : {};
+          if (selection.diagnostic) {
+            process.stdout.write(renderJson([selection.diagnostic]));
             return;
           }
+          const repo = selection.repo;
           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',
+              '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 r.workspace_id=? AND (? IS NULL OR s.repo_id=?) ORDER BY r.name,s.service_path',
             )
-            .all(repo?.id, repo?.id);
+            .all(workspaceId, repo?.id, repo?.id);
           process.stdout.write(renderJson(rows));
         }).catch(fail),
     );
@@ -253,17 +284,20 @@ export function createProgram(): Command {
     .option('--service <path>')
     .action(
       (opts: { workspace?: string; repo?: string; service?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db) => {
-          const repo = opts.repo ? repoByName(db, opts.repo) : undefined;
-          if (opts.repo && !repo) {
-            process.stdout.write(renderJson([{ severity: 'warning', code: 'selector_repo_not_found', message: `Repository selector not found: ${opts.repo}` }]));
+        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+          const selection = opts.repo
+            ? selectRepository(db, opts.repo, workspaceId)
+            : {};
+          if (selection.diagnostic) {
+            process.stdout.write(renderJson([selection.diagnostic]));
             return;
           }
+          const repo = selection.repo;
           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=?)',
+              '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 r.workspace_id=? AND (? IS NULL OR s.repo_id=?) AND (? IS NULL OR s.service_path=?)',
             )
-            .all(repo?.id, repo?.id, opts.service, opts.service);
+            .all(workspaceId, repo?.id, repo?.id, opts.service, opts.service);
           process.stdout.write(renderJson(rows));
         }).catch(fail),
     );
@@ -274,17 +308,21 @@ export function createProgram(): Command {
     .option('--operation <name>')
     .action(
       (opts: { workspace?: string; repo?: string; operation?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db) => {
-          const repo = opts.repo ? repoByName(db, opts.repo) : undefined;
-          if (opts.repo && !repo) {
-            process.stdout.write(renderJson([{ severity: 'warning', code: 'selector_repo_not_found', message: `Repository selector not found: ${opts.repo}` }]));
+        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+          const selection = opts.repo
+            ? selectRepository(db, opts.repo, workspaceId)
+            : {};
+          if (selection.diagnostic) {
+            process.stdout.write(renderJson([selection.diagnostic]));
             return;
           }
+          const repo = selection.repo;
           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 ?)',
+              '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 r.workspace_id=? AND (? 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(
+              workspaceId,
               repo?.id,
               repo?.id,
               opts.operation,
@@ -322,7 +360,7 @@ export function createProgram(): Command {
         dynamicMode: string;
         maxDynamicCandidates: string;
       }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db) => {
+        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
           const result = trace(
             db,
             {
@@ -333,6 +371,7 @@ export function createProgram(): Command {
             },
             {
               depth: 100,
+              workspaceId,
               includeAsync: true,
               includeDb: true,
               includeExternal: true,
@@ -357,11 +396,12 @@ export function createProgram(): Command {
     .option('--workspace <path>')
     .action(
       (name: string, opts: { workspace?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db) =>
-          process.stdout.write(
-            renderJson(repoByName(db, name) ?? { error: 'repo not found' }),
-          ),
-        ).catch(fail),
+        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+          const selection = selectRepository(db, name, workspaceId);
+          process.stdout.write(renderJson(
+            selection.repo ?? selection.diagnostic ?? { error: 'repo not found' },
+          ));
+        }).catch(fail),
     );
   inspect
     .command('operation')
@@ -369,12 +409,12 @@ export function createProgram(): Command {
     .option('--workspace <path>')
     .action(
       (selector: string, opts: { workspace?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db) => {
+        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
           const rows = db
             .prepare(
-              'SELECT * FROM cds_operations WHERE operation_name=? OR operation_path=?',
+              'SELECT o.* FROM cds_operations o JOIN cds_services s ON s.id=o.service_id JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND (o.operation_name=? OR o.operation_path=?)',
             )
-            .all(selector, selector);
+            .all(workspaceId, selector, selector);
           process.stdout.write(renderJson(rows));
         }).catch(fail),
     );
@@ -399,29 +439,7 @@ export function createProgram(): Command {
       (opts: { workspace?: string; dbOnly?: boolean }) =>
         void (async () => {
           const config = await loadWorkspaceConfig(opts.workspace);
-          const dbDir = path.resolve(path.dirname(config.dbPath));
-          const workspaceRoot = path.resolve(config.rootPath);
-          await fs.rm(config.dbPath, { force: true });
-          if (!opts.dbOnly) {
-            const marker = path.join(dbDir, '.service-flow-state');
-            const dangerous = new Set([
-              path.parse(dbDir).root,
-              '/tmp',
-              process.env.HOME ? path.resolve(process.env.HOME) : '',
-              workspaceRoot,
-            ]);
-            let ownsState: boolean;
-            try {
-              ownsState = (await fs.stat(marker)).isFile();
-            } catch {
-              ownsState = false;
-            }
-            if (!ownsState || dangerous.has(dbDir))
-              throw new Error(
-                `Refusing to recursively delete unowned or dangerous state directory: ${dbDir}. Use --db-only to remove only the database file.`,
-              );
-            await fs.rm(dbDir, { recursive: true, force: true });
-          }
+          await cleanWorkspaceState(config, Boolean(opts.dbOnly));
           process.stdout.write('Cleaned service-flow state\n');
         })().catch(fail),
     );

package/src/db/connection.ts

@@ -101,8 +101,8 @@ export function openDatabase(dbPath: string, options: OpenDatabaseOptions = {}):
     },
     transaction<T>(fn: () => T): T {
       if (inTransaction) return fn();
-      inTransaction = true;
       native.exec('BEGIN IMMEDIATE');
+      inTransaction = true;
       try {
         const result = fn();
         native.exec('COMMIT');