@saptools/service-flow 0.1.68 → 0.1.70

package/dist/index.d.ts

@@ -130,7 +130,7 @@ interface ServiceBindingReference {
     bindingSourceFile?: string;
     bindingSiteStartOffset?: number;
     bindingSiteEndOffset?: number;
-    resolutionStrategy?: 'lexical_declaration' | 'lexical_alias_declaration' | 'deterministic_reaching_assignment';
+    resolutionStrategy?: 'lexical_declaration' | 'lexical_alias_declaration' | 'deterministic_reaching_assignment' | 'single_hop_helper_return';
     lexicalScopeChain?: LexicalScopeFact[];
     bindingScopeIndex?: number;
     scopeChainTotal: number;
@@ -274,6 +274,7 @@ interface ClassifiedOutboundCall {
     fact: OutboundCallFact;
     node: ts.CallExpression;
 }
+
 declare function parseOutboundCalls(repoPath: string, filePath: string, context?: RepositorySourceContext, classified?: readonly ClassifiedOutboundCall[], preparedBindings?: readonly ServiceBindingFact[]): Promise<OutboundCallFact[]>;
 
 declare function parseGeneratedConstants(repoPath: string, filePath: string): Promise<GeneratedConstantFact[]>;
@@ -393,6 +394,7 @@ interface CompactDecisionV1 {
     implementationStrategy?: string;
     implementationGuided?: boolean;
     implementationContextual?: boolean;
+    tiedCandidateRepos?: CompactReferenceGroupV1;
     eventMatchStrategy?: string;
     dispatchCertainty?: string;
     eventSubscriptionCount?: number;
@@ -413,6 +415,10 @@ interface CompactEdgeDetailsV1 {
 }
 interface CompactDiagnosticDetailsV1 {
     reasonCode?: string;
+    tiedCandidateRepos?: CompactReferenceGroupV1;
+    selectorKind?: string;
+    selectorSuggestions?: CompactReferenceGroupV1;
+    invalidFactCategories?: CompactReferenceGroupV1;
     missingVariableNames?: string[];
     missingVariableCount?: number;
     shownMissingVariableCount?: number;

package/dist/index.js

@@ -19,7 +19,7 @@ import {
   substituteVariables,
   trace,
   traceAndCompact
-} from "./chunk-AEM4JY22.js";
+} from "./chunk-GSLFY6J2.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.68",
+  "version": "0.1.70",
   "description": "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   "type": "module",
   "publishConfig": {

package/src/cli/{002-doctor-lifecycle.ts → doctor-lifecycle.ts}

@@ -1,5 +1,5 @@
 import type { Db } from '../db/connection.js';
-import { factLifecycleDiagnostic } from '../db/001-fact-lifecycle.js';
+import { factLifecycleDiagnostic } from '../db/fact-lifecycle.js';
 import { ANALYZER_VERSION } from '../version.js';
 
 type Diagnostic = Record<string, unknown>;

package/src/cli/{001-doctor-projection.ts → doctor-projection.ts}

@@ -1,7 +1,7 @@
 import {
   projectBoundedInOrder,
   type BoundedProjection,
-} from '../utils/000-bounded-projection.js';
+} from '../utils/bounded-projection.js';
 
 type Diagnostic = Record<string, unknown>;
 

package/src/cli/doctor.ts

@@ -1,17 +1,17 @@
 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 { factLifecycleDiagnostic } from '../db/001-fact-lifecycle.js';
+import { boundDoctorDiagnostics } from './doctor-projection.js';
+import { factLifecycleDiagnostic } from '../db/fact-lifecycle.js';
 import {
   analyzerVersionDiagnostics,
   schemaDriftDiagnostics,
-} from './002-doctor-lifecycle.js';
+} from './doctor-lifecycle.js';
 import {
   packagePendingDiagnostics,
   symbolCallQuality,
-} from './003-doctor-package-resolution.js';
-export { linkUpgradeWarnings } from './002-doctor-lifecycle.js';
+} from './doctor-package-resolution.js';
+export { linkUpgradeWarnings } from './doctor-lifecycle.js';
 
 type Diagnostic = Record<string, unknown>;
 interface DoctorOptions {

package/src/cli/index-summary.ts

@@ -0,0 +1,22 @@
+import type {
+  IndexWorkspaceSummary,
+} from '../indexer/workspace-indexer.js';
+
+export interface IndexCommandOutcome {
+  stdout: string;
+  exitCode: 0 | 1;
+}
+
+export function indexCommandOutcome(
+  summary: IndexWorkspaceSummary,
+): IndexCommandOutcome {
+  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\n`,
+    exitCode: summary.failedCount > 0 ? 1 : 0,
+  };
+}

package/src/cli.ts

@@ -21,7 +21,7 @@ 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 { compactTrace } from './trace/018-compact-trace.js';
+import { compactTrace } from './trace/compact-trace.js';
 import {
   parseVars,
   selectorRepoAmbiguousDiagnostic,
@@ -31,8 +31,8 @@ import { renderTraceTable } from './output/table-output.js';
 import { renderTraceJson, renderJson } from './output/json-output.js';
 import { renderDoctorDiagnostics } from './output/doctor-output.js';
 import { renderMermaid } from './output/mermaid-output.js';
-import { createStdoutWriter } from './output/000-stdout-policy.js';
-import { renderCompactJson } from './output/001-compact-json-output.js';
+import { createStdoutWriter } from './output/stdout-policy.js';
+import { renderCompactJson } from './output/compact-json-output.js';
 import { VERSION } from './version.js';
 import type {
   DynamicMode,
@@ -40,7 +40,8 @@ import type {
   TraceResult,
   TraceStart,
 } from './types.js';
-import { cleanWorkspaceState } from './cli/000-clean.js';
+import { cleanWorkspaceState } from './cli/clean.js';
+import { indexCommandOutcome } from './cli/index-summary.js';
 
 const stdout = createStdoutWriter(process.stdout, fail);
 const TRACE_FORMATS = ['table', 'json', 'mermaid', 'compact-json'] as const;
@@ -245,14 +246,16 @@ function runGraphCommand(opts: GraphCommandOptions): Promise<void> {
   });
 }
 
-export function createProgram(): Command {
-  const program = new Command();
-  program
+function configuredProgram(): Command {
+  return new Command()
     .name('service-flow')
     .description(
       'Trace SAP CAP service-to-service flows across multi-repository workspaces',
     )
     .version(VERSION);
+}
+
+function registerInitCommand(program: Command): void {
   program
     .command('init')
     .argument('<workspace>')
@@ -262,6 +265,9 @@ export function createProgram(): Command {
       (workspace: string, opts: { db?: string; ignore?: string[] }) =>
         void init(workspace, opts).catch(fail),
     );
+}
+
+function registerIndexCommand(program: Command): void {
   program
     .command('index')
     .option('--workspace <path>')
@@ -274,11 +280,14 @@ export function createProgram(): Command {
             repo: opts.repo,
             force: Boolean(opts.force),
           });
-          writeStdout(
-            `Indexed ${r.indexedCount} repositories, skipped ${r.skippedCount}, ${r.fileCount} files, ${r.diagnosticCount} diagnostics\n`,
-          );
+          const outcome = indexCommandOutcome(r);
+          writeStdout(outcome.stdout);
+          if (outcome.exitCode !== 0) process.exitCode = outcome.exitCode;
         }).catch(fail),
     );
+}
+
+function registerLinkCommand(program: Command): void {
   program
     .command('link')
     .option('--workspace <path>')
@@ -293,6 +302,9 @@ export function createProgram(): Command {
           );
         }).catch(fail),
     );
+}
+
+function registerTraceCommand(program: Command): void {
   program
     .command('trace')
     .option('--workspace <path>')
@@ -312,23 +324,91 @@ export function createProgram(): Command {
     .option('--dynamic-mode <mode>', 'strict|candidates|infer', 'strict')
     .option('--max-dynamic-candidates <n>', 'maximum dynamic candidates to show', '5')
     .action((opts: TraceCommandOptions) => void runTraceCommand(opts).catch(fail));
+}
+
+function listRepositoriesCommand(
+  opts: { workspace?: string },
+): Promise<void> {
+  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: { workspace?: string; repo?: string },
+): Promise<void> {
+  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: { workspace?: string; repo?: string; service?: string },
+): Promise<void> {
+  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: { workspace?: string; repo?: string; operation?: string },
+): Promise<void> {
+  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}` : undefined,
+      opts.operation ? `%${opts.operation}%` : undefined,
+    );
+    writeStdout(renderJson(rows));
+  });
+}
+
+function registerListCommands(program: Command): void {
   const list = program.command('list');
   list
     .command('repos')
     .option('--workspace <path>')
     .action(
       (opts: { workspace?: string }) =>
-        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),
+        void listRepositoriesCommand(opts).catch(fail),
     );
   list
     .command('services')
@@ -336,22 +416,7 @@ export function createProgram(): Command {
     .option('--repo <name>')
     .action(
       (opts: { workspace?: string; repo?: string }) =>
-        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),
+        void listServicesCommand(opts).catch(fail),
     );
   list
     .command('operations')
@@ -360,22 +425,7 @@ export function createProgram(): Command {
     .option('--service <path>')
     .action(
       (opts: { workspace?: string; repo?: string; service?: string }) =>
-        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),
+        void listOperationsCommand(opts).catch(fail),
     );
   list
     .command('calls')
@@ -384,31 +434,11 @@ export function createProgram(): Command {
     .option('--operation <name>')
     .action(
       (opts: { workspace?: string; repo?: string; operation?: string }) =>
-        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}` : undefined,
-              opts.operation ? `%${opts.operation}%` : undefined,
-            );
-          writeStdout(renderJson(rows));
-        }).catch(fail),
+        void listCallsCommand(opts).catch(fail),
     );
+}
+
+function registerGraphCommand(program: Command): void {
   program
     .command('graph')
     .option('--workspace <path>')
@@ -423,6 +453,33 @@ export function createProgram(): Command {
     .option('--dynamic-mode <mode>', 'strict|candidates|infer', 'strict')
     .option('--max-dynamic-candidates <n>', 'maximum dynamic candidates to show', '5')
     .action((opts: GraphCommandOptions) => void runGraphCommand(opts).catch(fail));
+}
+
+function inspectRepositoryCommand(
+  name: string,
+  opts: { workspace?: string },
+): Promise<void> {
+  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: string,
+  opts: { workspace?: string },
+): Promise<void> {
+  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: Command): void {
   const inspect = program.command('inspect');
   inspect
     .command('repo')
@@ -430,12 +487,7 @@ export function createProgram(): Command {
     .option('--workspace <path>')
     .action(
       (name: string, opts: { workspace?: string }) =>
-        void withReadOnlyWorkspace(opts.workspace, (db, workspaceId) => {
-          const selection = selectRepository(db, name, workspaceId);
-          writeStdout(renderJson(
-            selection.repo ?? selection.diagnostic ?? { error: 'repo not found' },
-          ));
-        }).catch(fail),
+        void inspectRepositoryCommand(name, opts).catch(fail),
     );
   inspect
     .command('operation')
@@ -443,15 +495,11 @@ export function createProgram(): Command {
     .option('--workspace <path>')
     .action(
       (selector: string, opts: { workspace?: string }) =>
-        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),
+        void inspectOperationCommand(selector, opts).catch(fail),
     );
+}
+
+function registerDoctorCommand(program: Command): void {
   program
     .command('doctor')
     .option('--workspace <path>')
@@ -467,6 +515,9 @@ export function createProgram(): Command {
           writeStdout(renderDoctorDiagnostics(allDiagnostics, opts.format));
         }).catch(fail),
     );
+}
+
+function registerCleanCommand(program: Command): void {
   program
     .command('clean')
     .option('--workspace <path>')
@@ -479,6 +530,19 @@ export function createProgram(): Command {
           writeStdout('Cleaned service-flow state\n');
         })().catch(fail),
     );
+}
+
+export function createProgram(): Command {
+  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: string, previous: string[]): string[] {

package/src/db/{009-binding-fact-semantics.ts → binding-fact-semantics.ts}

@@ -8,7 +8,10 @@ import {
   resolvedBindingReferenceProofValid,
   validBindingLexicalScope,
   type BindingProofTarget,
-} from './012-binding-reference-proof.js';
+} from './binding-reference-proof.js';
+import {
+  hasSingleHopHelperReturn,
+} from './binding-helper-provenance.js';
 
 export interface BindingFactCategoryCount {
   category: string;
@@ -114,6 +117,7 @@ function bindingTargets(
     binding.binding_site_start_offset startOffset,
     binding.binding_site_end_offset endOffset,
     binding.owner_resolution ownerResolution,
+    binding.helper_chain_json helperChainJson,
     owner.start_offset ownerStartOffset,owner.end_offset ownerEndOffset
     FROM service_bindings binding
     JOIN repositories repo ON repo.id=binding.repo_id
@@ -140,6 +144,7 @@ function bindingTarget(
     ownerResolution: row.ownerResolution,
     ownerStartOffset: row.ownerStartOffset,
     ownerEndOffset: row.ownerEndOffset,
+    singleHopHelperReturn: hasSingleHopHelperReturn(row.helperChainJson),
   }];
 }
 

package/src/db/binding-helper-provenance.ts

@@ -0,0 +1,17 @@
+function record(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function parsed(value: string): unknown {
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+export function hasSingleHopHelperReturn(value: unknown): boolean {
+  const chain = typeof value === 'string' ? parsed(value) : value;
+  return Array.isArray(chain) && chain.some((step) =>
+    record(step) && step.bindingOrigin === 'single_hop_helper_return');
+}

package/src/db/{012-binding-reference-proof.ts → binding-reference-proof.ts}

@@ -23,6 +23,7 @@ export interface BindingProofTarget {
   ownerResolution: string;
   ownerStartOffset: number | null;
   ownerEndOffset: number | null;
+  singleHopHelperReturn: boolean;
 }
 
 interface ResolvedBindingProof {
@@ -45,6 +46,7 @@ const strategies = new Set([
   'lexical_declaration',
   'lexical_alias_declaration',
   'deterministic_reaching_assignment',
+  'single_hop_helper_return',
 ]);
 
 function record(value: unknown): Record<string, unknown> | undefined {
@@ -242,6 +244,8 @@ function targetMatches(
   target: BindingProofTarget | undefined,
 ): boolean {
   if (!target || call.bindingId !== target.id) return false;
+  if (reference.resolutionStrategy === 'single_hop_helper_return'
+    && !target.singleHopHelperReturn) return false;
   return all([
     target.repoId === call.repoId,
     target.sourceFile === call.sourceFile,