@saptools/service-flow 0.1.68 → 0.1.69

package/dist/cli.js

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import {
   ANALYZER_VERSION,
+  PreparedRepositorySnapshotError,
   VERSION,
   analyzePackagePublicSurface,
+  binaryCompare,
   bindingSite,
   classifyODataPathIntent,
   classifyOutboundCallsInSource,
@@ -18,6 +20,7 @@ import {
   implementationHintSuggestions,
   insertCalls,
   insertSymbolCalls,
+  isPreparedRepositorySnapshotError,
   lexicalIdentifierDeclaration,
   lexicalIdentifierDeclarations,
   lexicalScopeChain,
@@ -37,6 +40,7 @@ import {
   parseServiceBindings,
   parseVars,
   projectBoundedInOrder,
+  recordPreparedSnapshotFailure,
   redactValue,
   selectCallOwner,
   selectVisibleBinding,
@@ -44,7 +48,7 @@ import {
   stableLocalValueReference,
   symbolImportReference,
   trace
-} from "./chunk-AEM4JY22.js";
+} from "./chunk-3N3B5KHV.js";
 
 // src/cli.ts
 import { Command, Option } from "commander";
@@ -493,6 +497,15 @@ function insertBindings(db, repoId, rows) {
       r.helperChain ? JSON.stringify(r.helperChain) : null
     );
 }
+function bindingSnapshotError(failureCode, fact) {
+  return new PreparedRepositorySnapshotError(failureCode, {
+    factKind: "service_binding",
+    sourceFile: fact.sourceFile,
+    sourceLine: fact.sourceLine,
+    callSiteStartOffset: fact.bindingSiteStartOffset,
+    callSiteEndOffset: fact.bindingSiteEndOffset
+  });
+}
 function persistedOwnerCandidates(db, repoId, fact) {
   const rows = db.prepare(`SELECT id,kind,qualified_name qualifiedName,
     start_offset startOffset,end_offset endOffset FROM symbols
@@ -519,21 +532,21 @@ function bindingOwnerId(db, repoId, fact) {
   );
   if (fact.ownerResolution === "ownerless_file_scope") {
     if (selected.status !== "none")
-      throw new Error("invalid_prepared_repository_snapshot:binding_owner_mismatch");
+      throw bindingSnapshotError("binding_owner_mismatch", fact);
     return null;
   }
   if (fact.ownerResolution !== "owned_exact" || selected.status !== "resolved" || selected.owner?.qualifiedName !== fact.sourceSymbolQualifiedName)
-    throw new Error("invalid_prepared_repository_snapshot:binding_owner_mismatch");
+    throw bindingSnapshotError("binding_owner_mismatch", fact);
   const owner = selected.owner;
   if (!owner)
-    throw new Error("invalid_prepared_repository_snapshot:binding_owner_mismatch");
+    throw bindingSnapshotError("binding_owner_mismatch", fact);
   return owner.id;
 }
 function assertUniquePreparedBindingSites(rows) {
   const seen = /* @__PURE__ */ new Set();
   for (const row of rows) {
     if (row.bindingSiteStartOffset === void 0 || row.bindingSiteEndOffset === void 0)
-      throw new Error("invalid_prepared_repository_snapshot:binding_site_missing");
+      throw bindingSnapshotError("binding_site_missing", row);
     const key = [
       row.sourceFile,
       row.variableName,
@@ -541,7 +554,7 @@ function assertUniquePreparedBindingSites(rows) {
       row.bindingSiteEndOffset
     ].join("\0");
     if (seen.has(key))
-      throw new Error("invalid_prepared_repository_snapshot:duplicate_service_binding_site");
+      throw bindingSnapshotError("duplicate_service_binding_site", row);
     seen.add(key);
   }
 }
@@ -1074,13 +1087,16 @@ function rejectedReference(call, chain, reason, status = "unresolved") {
   };
 }
 function resolvedReference(call, selected, chain, scopeIndex) {
+  const helperReturn = selected.fact.helperChain?.some(
+    (step) => step.bindingOrigin === "single_hop_helper_return"
+  ) ?? false;
   return {
     status: "resolved_exact",
     variableName: call.serviceVariableName,
     bindingSourceFile: selected.fact.sourceFile,
     bindingSiteStartOffset: selected.site.startOffset,
     bindingSiteEndOffset: selected.site.endOffset,
-    resolutionStrategy: selected.site.flow === "assignment" ? "deterministic_reaching_assignment" : selected.site.aliasSource ? "lexical_alias_declaration" : "lexical_declaration",
+    resolutionStrategy: selected.site.flow === "assignment" ? "deterministic_reaching_assignment" : selected.site.aliasSource ? "lexical_alias_declaration" : helperReturn ? "single_hop_helper_return" : "lexical_declaration",
     lexicalScopeChain: chain,
     bindingScopeIndex: scopeIndex,
     scopeChainTotal: chain.length,
@@ -1829,6 +1845,11 @@ function isFunctionLike(node) {
 function exported(node) {
   return Boolean(ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Export);
 }
+function defaultExported(node) {
+  return Boolean(
+    ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Default
+  );
+}
 function isPublicClassMethod(node) {
   const flags = ts8.getCombinedModifierFlags(node);
   return (flags & ts8.ModifierFlags.Private) === 0 && (flags & ts8.ModifierFlags.Protected) === 0;
@@ -1922,6 +1943,7 @@ function symbolSourceEvidence(collection, node, options) {
   if (options.classContainerExported && ts8.isMethodDeclaration(node) && isPublicClassMethod(node)) return {
     source: "exported_class_instance_member",
     exportedClass: options.parentRoot,
+    exportedClassExportKind: options.classContainerDefaultExported ? "default" : "named",
     memberKind: "class_method"
   };
   if (options.declaredExportName) return {
@@ -1945,6 +1967,16 @@ function exportedClassMember(collection, kind, parentName, parentRoot, node) {
   if (kind !== "method" || !parentName || !collection.exportedClasses.has(parentRoot) || !ts8.isMethodDeclaration(node)) return false;
   return Boolean(ts8.getCombinedModifierFlags(node) & ts8.ModifierFlags.Static) && isPublicClassMethod(node);
 }
+function classExportState(collection, parentName, parentRoot) {
+  return {
+    classContainerExported: Boolean(
+      parentName && collection.exportedClasses.has(parentRoot)
+    ),
+    classContainerDefaultExported: Boolean(
+      parentName && collection.defaultExportedClasses.has(parentRoot)
+    )
+  };
+}
 function symbolNames(collection, kind, localName, node, parentName, exportedName) {
   const parentRoot = parentName?.split(".")[0] ?? "";
   const declaredExportName = exportedName ?? collection.exportNames.get(
@@ -1961,15 +1993,13 @@ function symbolNames(collection, kind, localName, node, parentName, exportedName
     parentRoot,
     node
   );
-  const classContainerExported = Boolean(
-    parentName && collection.exportedClasses.has(parentRoot)
-  );
+  const classState = classExportState(collection, parentName, parentRoot);
   return {
     parentRoot,
     declaredExportName,
     qualifiedName,
     objectExported,
-    classContainerExported,
+    ...classState,
     classMemberExported,
     effectiveName: classMemberExported || objectExported ? qualifiedName : declaredExportName
   };
@@ -1988,6 +2018,7 @@ function addExecutableSymbol(collection, kind, localName, node, parentName, expo
     qualifiedName: names.qualifiedName,
     declaredExportName: names.declaredExportName,
     classContainerExported: names.classContainerExported,
+    classContainerDefaultExported: names.classContainerDefaultExported,
     classMemberExported: names.classMemberExported,
     objectExported: names.objectExported,
     evidence
@@ -2135,6 +2166,8 @@ function collectClassDeclaration(collection, node) {
   collection.declaredClasses.add(node.name.text);
   if (exported(node) || collection.exportNames.has(node.name.text))
     collection.exportedClasses.add(node.name.text);
+  if (defaultExported(node))
+    collection.defaultExportedClasses.add(node.name.text);
   for (const member of node.members)
     visitDeclaredSymbol(collection, member, node.name.text);
   return true;
@@ -2231,6 +2264,7 @@ function createCollection(source, sourceFile2, classifiedCalls) {
     exportNames: exportDeclarations(source),
     objectExports: /* @__PURE__ */ new Set(),
     exportedClasses: /* @__PURE__ */ new Set(),
+    defaultExportedClasses: /* @__PURE__ */ new Set(),
     declaredClasses: /* @__PURE__ */ new Set(),
     proxies: /* @__PURE__ */ new Map(),
     instances: /* @__PURE__ */ new Map()
@@ -2451,6 +2485,12 @@ function createPackageInvalidationBatch(publishingRepoIds) {
     affectedWorkspaceIds: /* @__PURE__ */ new Set()
   };
 }
+function mergePackageInvalidationEffects(target, source) {
+  for (const repoId of source.affectedCallerRepoIds)
+    target.affectedCallerRepoIds.add(repoId);
+  for (const workspaceId of source.affectedWorkspaceIds)
+    target.affectedWorkspaceIds.add(workspaceId);
+}
 function finalizePackageTargetInvalidations(db, batch) {
   const increment = db.prepare(`UPDATE repositories
     SET fact_generation=fact_generation+1 WHERE id=?`);
@@ -2540,10 +2580,43 @@ function publishPreparedRepositoryIndex(db, prepared, invalidations) {
   insertCalls(db, repoId, prepared.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=?, fact_analyzer_version=? WHERE id=?").run(now, prepared.fingerprint, now, ANALYZER_VERSION, repoId);
 }
+function publishOneRepository(db, prepared, invalidations) {
+  try {
+    db.transaction(() => withPublicationSavepoint(
+      db,
+      prepared.repo.id,
+      () => publishPreparedRepositoryIndex(db, prepared, invalidations)
+    ));
+    return { ok: true };
+  } catch (error) {
+    recordIndexFailure(db, prepared.repo.id, error);
+    return { ok: false, error };
+  }
+}
+function withPublicationSavepoint(db, repoId, publish) {
+  const name = `service_flow_repository_${repoId}`;
+  db.exec(`SAVEPOINT ${name}`);
+  try {
+    const result = publish();
+    db.exec(`RELEASE SAVEPOINT ${name}`);
+    return result;
+  } catch (error) {
+    db.exec(`ROLLBACK TO SAVEPOINT ${name}`);
+    db.exec(`RELEASE SAVEPOINT ${name}`);
+    throw error;
+  }
+}
 function recordIndexFailure(db, repoId, error) {
+  if (isPreparedRepositorySnapshotError(error)) {
+    recordPreparedSnapshotFailure(db, repoId, error);
+    return;
+  }
   const message = errorMessage(error);
   db.prepare("UPDATE repositories SET index_status='failed', error_count=1 WHERE id=?").run(repoId);
-  db.prepare("DELETE FROM diagnostics WHERE repo_id=? AND code IN ('index_failed_snapshot_preserved','source_read_failed')").run(repoId);
+  db.prepare(`DELETE FROM diagnostics WHERE repo_id=? AND (
+    code IN ('index_failed_snapshot_preserved','source_read_failed')
+    OR code GLOB 'invalid_prepared_repository_snapshot:*'
+  )`).run(repoId);
   db.prepare("INSERT INTO diagnostics(repo_id,severity,code,message) VALUES(?,?,?,?)").run(repoId, "error", "source_read_failed", `Index failed before publication; previous facts and fingerprint were preserved. ${message}`);
 }
 async function parseAllSourceFacts(root, sources) {
@@ -2624,9 +2697,8 @@ function repositoryFingerprint(sources, facts, packageJsonText) {
 }
 
 // src/indexer/cds-extension-resolver.ts
-function materializeCdsExtensionOperations(db, workspaceId) {
-  const extensions = db.prepare(`SELECT s.id,r.id repoId,s.service_name serviceName,s.qualified_name qualifiedName,s.source_file sourceFile,s.extension_module_specifier moduleSpecifier,s.extension_imported_symbol importedSymbol,s.extension_import_kind importKind
-    FROM cds_services s JOIN repositories r ON r.id=s.repo_id WHERE r.workspace_id=? AND s.is_extend=1`).all(workspaceId);
+function materializeCdsExtensionOperations(db, workspaceId, excludedRepoIds = /* @__PURE__ */ new Set()) {
+  const extensions = extensionRows(db, workspaceId, excludedRepoIds);
   db.transaction(() => {
     const changedRepos = /* @__PURE__ */ new Set();
     for (const extension of extensions) {
@@ -2635,6 +2707,21 @@ function materializeCdsExtensionOperations(db, workspaceId) {
     for (const repoId of changedRepos) markRepositoryDerivedFactsChanged(db, repoId);
   });
 }
+function extensionRows(db, workspaceId, excludedRepoIds) {
+  const excluded = [...excludedRepoIds].sort((left, right) => left - right);
+  const exclusion = excluded.length > 0 ? ` AND r.id NOT IN (${excluded.map(() => "?").join(",")})` : "";
+  return db.prepare(`SELECT s.id,r.id repoId,s.service_name serviceName,
+    s.qualified_name qualifiedName,s.source_file sourceFile,
+    s.extension_module_specifier moduleSpecifier,
+    s.extension_imported_symbol importedSymbol,
+    s.extension_import_kind importKind
+    FROM cds_services s JOIN repositories r ON r.id=s.repo_id
+    WHERE r.workspace_id=? AND s.is_extend=1${exclusion}
+    ORDER BY r.id,s.id`).all(
+    workspaceId,
+    ...excluded
+  );
+}
 function reconcileExtension(db, workspaceId, extension) {
   const bases = resolveBase(db, workspaceId, extension);
   const status = bases.length === 1 ? "resolved" : bases.length > 1 ? "ambiguous" : "unresolved";
@@ -2788,8 +2875,13 @@ async function indexWorkspace(db, workspaceId, options) {
   };
   try {
     await prepareRepositories(repos, options.force, state);
-    publishPreparedRows(db, workspaceId, options, runId, state);
-    return indexSummary(repos.length, state);
+    return publishPreparedWorkspaceRows(
+      db,
+      workspaceId,
+      runId,
+      state.rows,
+      options
+    );
   } catch (error) {
     finishFailedRun(db, runId, state, error);
     if (state.activeRepoId && state.rows.length < repos.length)
@@ -2819,31 +2911,90 @@ async function prepareRepositories(repos, force, state) {
     state.skippedCount += result.skipped ? 1 : 0;
   }
 }
-function publishPreparedRows(db, workspaceId, options, runId, state) {
+function publishPreparedWorkspaceRows(db, workspaceId, runId, rows, options = {}) {
+  const state = publicationState(rows);
   db.transaction(() => {
-    const invalidations = createPackageInvalidationBatch(
-      state.rows.filter((row) => !row.skipped).map((row) => row.repo.id)
-    );
+    const effects = createPackageInvalidationBatch([]);
+    const publishedRepoIds = [];
     for (const row of state.rows) {
       state.activeRepoId = row.repo.id;
-      publishPreparedRepositoryIndex(db, row, invalidations);
+      if (row.skipped) continue;
+      const result = publishPreparedRow(db, row);
+      if (result.status === "failed") {
+        recordPublicationFailure(db, state, row, result.error);
+        continue;
+      }
+      state.indexedCount += 1;
+      publishedRepoIds.push(row.repo.id);
+      mergePackageInvalidationEffects(effects, result.effects);
     }
     if (options.injectDerivedMaterializationFailure)
       throw new Error("Injected derived materialization failure");
-    materializeCdsExtensionOperations(db, workspaceId);
+    materializeCdsExtensionOperations(
+      db,
+      workspaceId,
+      state.failedRepoIds
+    );
+    const invalidations = createPackageInvalidationBatch(publishedRepoIds);
+    mergePackageInvalidationEffects(invalidations, effects);
     finalizePackageTargetInvalidations(db, invalidations);
-    finishSuccessfulRun(db, runId, state);
+    finishCompletedRun(db, runId, state);
+  });
+  return indexSummary(rows.length, state);
+}
+function publicationState(rows) {
+  return {
+    rows,
+    fileCount: rows.reduce((total, row) => total + row.fileCount, 0),
+    diagnosticCount: rows.reduce(
+      (total, row) => total + row.diagnosticCount,
+      0
+    ),
+    skippedCount: rows.filter((row) => row.skipped).length,
+    indexedCount: 0,
+    publicationFailureCount: 0,
+    failedRepoIds: /* @__PURE__ */ new Set(),
+    failedRepos: []
+  };
+}
+function publishPreparedRow(db, row) {
+  const effects = createPackageInvalidationBatch([row.repo.id]);
+  const outcome = publishOneRepository(db, row, effects);
+  if (!outcome.ok && !isPreparedRepositorySnapshotError(outcome.error))
+    throw outcome.error;
+  return outcome.ok ? { status: "published", effects } : { status: "failed", error: outcome.error };
+}
+function recordPublicationFailure(db, state, row, error) {
+  state.failedRepoIds.add(row.repo.id);
+  state.failedRepos.push({
+    name: row.repo.name,
+    code: isPreparedRepositorySnapshotError(error) ? error.message : "source_read_failed"
   });
+  state.publicationFailureCount += 1;
 }
-function finishSuccessfulRun(db, runId, state) {
-  db.prepare(`UPDATE index_runs SET finished_at=?,status='success',
-    file_count=?,diagnostic_count=? WHERE id=?`).run(
+function finishCompletedRun(db, runId, state) {
+  const status = completedRunStatus(
+    state.rows.length,
+    state.publicationFailureCount
+  );
+  const error = status === "success" ? null : `${state.publicationFailureCount} repositories failed index publication.`;
+  db.prepare(`UPDATE index_runs SET finished_at=?,status=?,
+    file_count=?,diagnostic_count=?,error_message=? WHERE id=?`).run(
     (/* @__PURE__ */ new Date()).toISOString(),
+    status,
     state.fileCount,
-    state.diagnosticCount,
+    completedDiagnosticCount(state),
+    error,
     runId
   );
 }
+function completedRunStatus(repoCount, failedCount) {
+  if (failedCount === 0) return "success";
+  return failedCount === repoCount ? "failed" : "partial_failure";
+}
+function completedDiagnosticCount(state) {
+  return state.diagnosticCount + state.publicationFailureCount;
+}
 function finishFailedRun(db, runId, state, error) {
   db.prepare(`UPDATE index_runs SET finished_at=?,status='failed',
     file_count=?,diagnostic_count=?,error_message=? WHERE id=?`).run(
@@ -2857,10 +3008,12 @@ function finishFailedRun(db, runId, state, error) {
 function indexSummary(repoCount, state) {
   return {
     repoCount,
-    indexedCount: repoCount - state.skippedCount,
+    indexedCount: state.indexedCount,
     skippedCount: state.skippedCount,
+    failedCount: state.publicationFailureCount,
+    failedRepos: [...state.failedRepos].sort((left, right) => binaryCompare(left.name, right.name) || binaryCompare(left.code, right.code)),
     fileCount: state.fileCount,
-    diagnosticCount: state.diagnosticCount
+    diagnosticCount: completedDiagnosticCount(state)
   };
 }
 
@@ -4008,6 +4161,16 @@ async function markCleanClaimFailed(dbPath, runId, error) {
   }
 }
 
+// src/cli/001-index-summary.ts
+function indexCommandOutcome(summary) {
+  const failed = summary.failedCount > 0 ? `, failed ${summary.failedCount} (${summary.failedRepos.map(({ name, code }) => `${name}: ${code}`).join(", ")})` : "";
+  return {
+    stdout: `Indexed ${summary.indexedCount} repositories, skipped ${summary.skippedCount}${failed}, ${summary.fileCount} files, ${summary.diagnosticCount} diagnostics
+`,
+    exitCode: summary.failedCount > 0 ? 1 : 0
+  };
+}
+
 // src/cli.ts
 var stdout = createStdoutWriter(process.stdout, fail);
 var TRACE_FORMATS = ["table", "json", "mermaid", "compact-json"];
@@ -4155,26 +4318,30 @@ function runGraphCommand(opts) {
     writeTraceOutput(db, start, options, opts.format);
   });
 }
-function createProgram() {
-  const program = new Command();
-  program.name("service-flow").description(
+function configuredProgram() {
+  return new Command().name("service-flow").description(
     "Trace SAP CAP service-to-service flows across multi-repository workspaces"
   ).version(VERSION);
+}
+function registerInitCommand(program) {
   program.command("init").argument("<workspace>").option("--db <path>").option("--ignore <pattern...>").action(
     (workspace, opts) => void init(workspace, opts).catch(fail)
   );
+}
+function registerIndexCommand(program) {
   program.command("index").option("--workspace <path>").option("--repo <name>").option("--force").action(
     (opts) => void withWorkspace(opts.workspace, async (db, workspaceId) => {
       const r = await indexWorkspace(db, workspaceId, {
         repo: opts.repo,
         force: Boolean(opts.force)
       });
-      writeStdout(
-        `Indexed ${r.indexedCount} repositories, skipped ${r.skippedCount}, ${r.fileCount} files, ${r.diagnosticCount} diagnostics
-`
-      );
+      const outcome = indexCommandOutcome(r);
+      writeStdout(outcome.stdout);
+      if (outcome.exitCode !== 0) process.exitCode = outcome.exitCode;
     }).catch(fail)
   );
+}
+function registerLinkCommand(program) {
   program.command("link").option("--workspace <path>").option("--force").action(
     (opts) => void withWorkspace(opts.workspace, (db, workspaceId) => {
       const r = linkWorkspace(db, workspaceId);
@@ -4186,90 +4353,121 @@ function createProgram() {
       );
     }).catch(fail)
   );
+}
+function registerTraceCommand(program) {
   program.command("trace").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").option("--handler <name>").option("--depth <n>", "trace depth", "25").addOption(traceFormatOption()).option("--include-external").option("--include-db").option("--include-async").option("--implementation-repo <name>").option("--implementation-hint <scope>", "scoped implementation hint", collect, []).option("--var <key=value>", "dynamic variable", collect, []).option("--dynamic-mode <mode>", "strict|candidates|infer", "strict").option("--max-dynamic-candidates <n>", "maximum dynamic candidates to show", "5").action((opts) => void runTraceCommand(opts).catch(fail));
+}
+function listRepositoriesCommand(opts) {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => writeStdout(
+    renderJson(
+      listRepositories(db, workspaceId).map((repo) => ({
+        name: repo.name,
+        kind: repo.kind,
+        packageName: repo.package_name
+      }))
+    )
+  ));
+}
+function listServicesCommand(opts) {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
+    if (selection.diagnostic) {
+      writeStdout(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 r.workspace_id=? AND (? IS NULL OR s.repo_id=?) ORDER BY r.name,s.service_path"
+    ).all(workspaceId, repo?.id, repo?.id);
+    writeStdout(renderJson(rows));
+  });
+}
+function listOperationsCommand(opts) {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
+    if (selection.diagnostic) {
+      writeStdout(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 r.workspace_id=? AND (? IS NULL OR s.repo_id=?) AND (? IS NULL OR s.service_path=?)"
+    ).all(
+      workspaceId,
+      repo?.id,
+      repo?.id,
+      opts.service,
+      opts.service
+    );
+    writeStdout(renderJson(rows));
+  });
+}
+function listCallsCommand(opts) {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
+    if (selection.diagnostic) {
+      writeStdout(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 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,
+      opts.operation,
+      opts.operation ? `/${opts.operation}` : void 0,
+      opts.operation ? `%${opts.operation}%` : void 0
+    );
+    writeStdout(renderJson(rows));
+  });
+}
+function registerListCommands(program) {
   const list = program.command("list");
   list.command("repos").option("--workspace <path>").action(
-    (opts) => void withReadOnlyWorkspace(
-      opts.workspace,
-      (db, workspaceId) => writeStdout(
-        renderJson(
-          listRepositories(db, workspaceId).map((r) => ({
-            name: r.name,
-            kind: r.kind,
-            packageName: r.package_name
-          }))
-        )
-      )
-    ).catch(fail)
+    (opts) => void listRepositoriesCommand(opts).catch(fail)
   );
   list.command("services").option("--workspace <path>").option("--repo <name>").action(
-    (opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-      const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
-      if (selection.diagnostic) {
-        writeStdout(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 r.workspace_id=? AND (? IS NULL OR s.repo_id=?) ORDER BY r.name,s.service_path"
-      ).all(workspaceId, repo?.id, repo?.id);
-      writeStdout(renderJson(rows));
-    }).catch(fail)
+    (opts) => void listServicesCommand(opts).catch(fail)
   );
   list.command("operations").option("--workspace <path>").option("--repo <name>").option("--service <path>").action(
-    (opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-      const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
-      if (selection.diagnostic) {
-        writeStdout(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 r.workspace_id=? AND (? IS NULL OR s.repo_id=?) AND (? IS NULL OR s.service_path=?)"
-      ).all(workspaceId, repo?.id, repo?.id, opts.service, opts.service);
-      writeStdout(renderJson(rows));
-    }).catch(fail)
+    (opts) => void listOperationsCommand(opts).catch(fail)
   );
   list.command("calls").option("--workspace <path>").option("--repo <name>").option("--operation <name>").action(
-    (opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-      const selection = opts.repo ? selectRepository(db, opts.repo, workspaceId) : {};
-      if (selection.diagnostic) {
-        writeStdout(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 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,
-        opts.operation,
-        opts.operation ? `/${opts.operation}` : void 0,
-        opts.operation ? `%${opts.operation}%` : void 0
-      );
-      writeStdout(renderJson(rows));
-    }).catch(fail)
+    (opts) => void listCallsCommand(opts).catch(fail)
   );
+}
+function registerGraphCommand(program) {
   program.command("graph").option("--workspace <path>").option("--repo <name>").option("--operation <name>").option("--service <path>").option("--path <operationPath>").addOption(graphFormatOption()).option("--implementation-repo <name>").option("--implementation-hint <scope>", "scoped implementation hint", collect, []).option("--var <key=value>", "dynamic variable", collect, []).option("--dynamic-mode <mode>", "strict|candidates|infer", "strict").option("--max-dynamic-candidates <n>", "maximum dynamic candidates to show", "5").action((opts) => void runGraphCommand(opts).catch(fail));
+}
+function inspectRepositoryCommand(name, opts) {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const selection = selectRepository(db, name, workspaceId);
+    writeStdout(renderJson(
+      selection.repo ?? selection.diagnostic ?? { error: "repo not found" }
+    ));
+  });
+}
+function inspectOperationCommand(selector, opts) {
+  return withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
+    const rows = db.prepare(
+      "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(workspaceId, selector, selector);
+    writeStdout(renderJson(rows));
+  });
+}
+function registerInspectCommands(program) {
   const inspect = program.command("inspect");
   inspect.command("repo").argument("<name>").option("--workspace <path>").action(
-    (name, opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-      const selection = selectRepository(db, name, workspaceId);
-      writeStdout(renderJson(
-        selection.repo ?? selection.diagnostic ?? { error: "repo not found" }
-      ));
-    }).catch(fail)
+    (name, opts) => void inspectRepositoryCommand(name, opts).catch(fail)
   );
   inspect.command("operation").argument("<selector>").option("--workspace <path>").action(
-    (selector, opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-      const rows = db.prepare(
-        "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(workspaceId, selector, selector);
-      writeStdout(renderJson(rows));
-    }).catch(fail)
+    (selector, opts) => void inspectOperationCommand(selector, opts).catch(fail)
   );
+}
+function registerDoctorCommand(program) {
   program.command("doctor").option("--workspace <path>").option("--strict").option("--detail").option("--format <format>", "json|table").action(
     (opts) => void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
       const allDiagnostics = doctorDiagnostics(db, Boolean(opts.strict), {
@@ -4279,6 +4477,8 @@ function createProgram() {
       writeStdout(renderDoctorDiagnostics(allDiagnostics, opts.format));
     }).catch(fail)
   );
+}
+function registerCleanCommand(program) {
   program.command("clean").option("--workspace <path>").option("--db-only").action(
     (opts) => void (async () => {
       const config = await loadWorkspaceConfig(opts.workspace);
@@ -4286,6 +4486,18 @@ function createProgram() {
       writeStdout("Cleaned service-flow state\n");
     })().catch(fail)
   );
+}
+function createProgram() {
+  const program = configuredProgram();
+  registerInitCommand(program);
+  registerIndexCommand(program);
+  registerLinkCommand(program);
+  registerTraceCommand(program);
+  registerListCommands(program);
+  registerGraphCommand(program);
+  registerInspectCommands(program);
+  registerDoctorCommand(program);
+  registerCleanCommand(program);
   return program;
 }
 function collect(value, previous) {