@saptools/service-flow 0.1.52 → 0.1.53

package/dist/cli.js

@@ -29,12 +29,14 @@ import {
   parsePackageJson,
   parseServiceBindings,
   parseVars,
+  projectBounded,
   reposByName,
   selectorRepoAmbiguousDiagnostic,
+  stableProjectionValue,
   trace,
   upsertRepository,
   upsertWorkspace
-} from "./chunk-PTLDSHRC.js";
+} from "./chunk-LFH7C46B.js";
 
 // src/cli.ts
 import { Command } from "commander";
@@ -236,7 +238,7 @@ function migrate(db) {
 // package.json
 var package_default = {
   name: "@saptools/service-flow",
-  version: "0.1.52",
+  version: "0.1.53",
   description: "Trace SAP CAP service-to-service flows across multi-repository workspaces with runtime-aware graph resolution",
   type: "module",
   publishConfig: {
@@ -1130,13 +1132,131 @@ async function indexWorkspace(db, workspaceId, options) {
   }
 }
 
+// src/cli/001-doctor-projection.ts
+var boundedDoctorArrayKeys = /* @__PURE__ */ 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"
+]);
+function boundDoctorDiagnostics(diagnostics) {
+  return diagnostics.map(boundDoctorDiagnostic);
+}
+function boundDoctorDiagnostic(diagnostic) {
+  const bounded = boundDoctorValue(diagnostic);
+  return isDiagnostic(bounded) ? bounded : {};
+}
+function boundDoctorValue(value) {
+  if (Array.isArray(value)) return value.map(boundDoctorValue);
+  if (!isDiagnostic(value)) return value;
+  const input = value;
+  const output = {};
+  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) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function addProjectionMetadata(output, input, key, projection) {
+  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, key) {
+  if (key !== "examples" || !Array.isArray(input.expandedExamples)) return 0;
+  return input.expandedExamples.length;
+}
+function projectionNames(key) {
+  const stem = projectionStem(key);
+  return {
+    total: `${stem}Count`,
+    shown: `shown${upperFirst(stem)}Count`,
+    omitted: `omitted${upperFirst(stem)}Count`
+  };
+}
+function projectionStem(key) {
+  const stems = {
+    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, right) {
+  return stableProjectionValue(left).localeCompare(stableProjectionValue(right));
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function upperFirst(value) {
+  return value ? `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}` : value;
+}
+
 // src/cli/doctor.ts
 function linkUpgradeWarnings(db) {
   return [...schemaDriftDiagnostics(db, true), ...analyzerVersionDiagnostics(db, true)].filter((item) => ["schema_legacy_columns_present", "external_target_columns_missing_data", "reindex_required_after_upgrade", "reindex_required_after_analyzer_upgrade"].includes(String(item.code)));
 }
 function doctorDiagnostics(db, strict, options = {}) {
   const diagnostics = db.prepare("SELECT severity,code,message,source_file sourceFile,source_line sourceLine FROM diagnostics ORDER BY id").all();
-  return [
+  return boundDoctorDiagnostics([
     ...diagnostics,
     ...healthDiagnostics(db, strict),
     ...remoteTargetWithoutImplementationDiagnostics(db, strict, Boolean(options.detail)),
@@ -1144,7 +1264,7 @@ function doctorDiagnostics(db, strict, options = {}) {
     ...schemaDriftDiagnostics(db, strict),
     ...analyzerVersionDiagnostics(db, strict),
     ...parserQualityDiagnostics(db, strict, options)
-  ];
+  ]);
 }
 function healthDiagnostics(db, strict) {
   return db.prepare(
@@ -1356,6 +1476,10 @@ function addImplementationCategory(grouped, row) {
   const current = grouped.get(key) ?? { category, baseOperation, reason, candidateFamily: family, count: 0, servicePaths: [], examples: [] };
   const hintSuggestions = implementationSuggestions(evidence);
   const candidates = asRecords(evidence.candidates);
+  const candidateCount2 = Math.max(
+    numericValue2(evidence.candidateCount),
+    candidates.length
+  );
   current.count += 1;
   current.servicePaths.push(String(row.servicePath ?? evidence.servicePath ?? ""));
   current.examples.push({
@@ -1363,7 +1487,15 @@ function addImplementationCategory(grouped, row) {
     operation: row.operationName,
     status: row.status,
     reason: row.unresolvedReason,
-    candidateCount: candidates.length,
+    candidateCount: candidateCount2,
+    shownCandidateCount: Math.min(
+      candidateCount2,
+      numericValue2(evidence.shownCandidateCount) || candidates.length
+    ),
+    omittedCandidateCount: Math.max(
+      0,
+      candidateCount2 - (numericValue2(evidence.shownCandidateCount) || candidates.length)
+    ),
     candidateEvidence: candidates.slice(0, 3),
     implementationHintSuggestions: hintSuggestions
   });
@@ -1701,6 +1833,9 @@ function remoteActionNoBindingQuality(db) {
 function candidateCount(value) {
   return Number(parseObject(value).candidateCount ?? 0);
 }
+function numericValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 function parseObject(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) return value;
   try {
@@ -1766,8 +1901,10 @@ function hintLines(evidence) {
   const hints = suggestions.flatMap((item) => isRecord(item) && typeof item.cli === "string" ? [item.cli] : []);
   const unique = [...new Set(hints)];
   const shown = unique.slice(0, 3).map((hint) => `try ${hint}`);
-  if (unique.length > shown.length)
-    shown.push(`... ${unique.length - shown.length} more hint(s) available in JSON`);
+  const omitted = numberValue(evidence.omittedImplementationHintSuggestionCount);
+  const remaining = Math.max(0, unique.length - shown.length) + omitted;
+  if (remaining > 0)
+    shown.push(`... ${remaining} additional hint(s) omitted; use a scoped --implementation-hint`);
   return [...dynamicLines, ...shown];
 }
 function dynamicHintLines(evidence) {
@@ -1857,8 +1994,12 @@ function compactMessage(diagnostic) {
 }
 function suggestedHintLines(diagnostic) {
   const direct = cliHints(diagnostic.suggestedHints);
-  if (direct.length > 0) return cappedHints(direct);
-  return cappedHints(cliHintsFromSuggestions(diagnostic.implementationHintSuggestions));
+  const omitted = numericValue3(diagnostic.omittedImplementationHintSuggestionCount);
+  if (direct.length > 0) return cappedHints(direct, omitted);
+  return cappedHints(
+    cliHintsFromSuggestions(diagnostic.implementationHintSuggestions),
+    omitted
+  );
 }
 function cliHints(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
@@ -1873,12 +2014,17 @@ function cliHintsFromSuggestions(value) {
 function isRecord2(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function cappedHints(hints) {
+function cappedHints(hints, omitted) {
   const unique = [...new Set(hints)];
   const shown = unique.slice(0, 3);
-  if (unique.length > shown.length) shown.push(`... ${unique.length - shown.length} more hint(s) available in --format json`);
+  const remaining = Math.max(0, unique.length - shown.length) + omitted;
+  if (remaining > 0)
+    shown.push(`... ${remaining} additional hint(s) omitted; use a scoped --implementation-hint`);
   return shown;
 }
+function numericValue3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 function cleanDoctorMessage() {
   return `${pc.green("No diagnostics recorded")}
 `;