@resolveio/server-lib 22.3.212 → 22.3.213

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.3.212",
+  "version": "22.3.213",
   "description": "",
   "scripts": {
     "package": "./build_package.sh",

package/util/support-runner-v5.js

@@ -948,24 +948,81 @@ function normalizeReproductionStatus(value) {
     }
     return 'reproduced';
 }
-function normalizeSupportDiagnosisEvidence(values) {
+function inferSupportDiagnosisEvidenceTypeFromText(value, artifactPath) {
+    if (artifactPath === void 0) { artifactPath = ''; }
+    var text = cleanText([value, artifactPath].filter(Boolean).join(' '), 2000).toLowerCase();
+    if (/\b(ticket|customer|client|reporter|reported|support request|manual-ticket|email\.metadata)\b/i.test(text)) {
+        return 'ticket';
+    }
+    if (/\b(browser|dom|click|route|page|screenshot|screen shot|playwright|puppeteer)\b/i.test(text)) {
+        return 'browser';
+    }
+    if (/\b(mongo|database|collection|document|query|findone|aggregate)\b/i.test(text)) {
+        return 'mongo';
+    }
+    if (/\b(log|trace|stack|console|network)\b/i.test(text)) {
+        return 'log';
+    }
+    if (/\b(commit|git|branch|pr)\b/i.test(text)) {
+        return 'commit';
+    }
+    if (/\b(qa|test artifact|assertion)\b/i.test(text)) {
+        return 'qa';
+    }
+    if (/\b(component|template|publication|method|model|route|service|resolver|subscription|subscribe|render|renders|stores|persists|returns|finds?|source|repo|repository|angular|server|client|src)\b/i.test(text)) {
+        return 'code';
+    }
+    return 'other';
+}
+function supportLooseOwnerFileMatch(value, ownerFile) {
+    var normalizedOwner = normalizeOwnerFilePath(ownerFile);
+    var text = cleanText(value, 2000).replace(/[\\/.]+/g, ' ').replace(/[_-]+/g, ' ').toLowerCase();
+    var base = normalizedOwner.split('/').pop() || normalizedOwner;
+    var stem = base.replace(/\.[a-z0-9]+$/i, '');
+    var stemWithoutAngularKind = stem.replace(/\.(component|service|module|directive|pipe|model|resolver|guard|template)$/i, '');
+    var looseStem = stem.replace(/[._-]+/g, ' ').toLowerCase();
+    var looseStemWithoutKind = stemWithoutAngularKind.replace(/[._-]+/g, ' ').toLowerCase();
+    var compactStem = stem.replace(/[^a-z0-9]+/gi, '').toLowerCase();
+    var compactStemWithoutKind = stemWithoutAngularKind.replace(/[^a-z0-9]+/gi, '').toLowerCase();
+    var compactText = text.replace(/[^a-z0-9]+/g, '');
+    return !!normalizedOwner && (supportNormalizedPathMentioned(value, normalizedOwner)
+        || (!!looseStem && looseStem.length >= 5 && text.includes(looseStem))
+        || (!!looseStemWithoutKind && looseStemWithoutKind.length >= 5 && text.includes(looseStemWithoutKind))
+        || (!!compactStem && compactStem.length >= 5 && compactText.includes(compactStem))
+        || (!!compactStemWithoutKind && compactStemWithoutKind.length >= 5 && compactText.includes(compactStemWithoutKind)));
+}
+function supportLooseEvidenceOwnerFiles(value, ownerFiles) {
+    return ownerFiles
+        .map(normalizeOwnerFilePath)
+        .filter(Boolean)
+        .filter(function (ownerFile) { return supportLooseOwnerFileMatch(value, ownerFile); })
+        .slice(0, 8);
+}
+function normalizeSupportDiagnosisEvidence(values, ownerFiles) {
+    if (ownerFiles === void 0) { ownerFiles = []; }
     var allowed = new Set(['ticket', 'browser', 'mongo', 'log', 'code', 'commit', 'qa', 'other']);
     if (!Array.isArray(values)) {
         var summary = cleanText(values, 1200);
         return summary ? [{
-                id: "evidence-".concat(hashResolveIOSupportV5Evidence({ type: 'other', summary: summary }).slice(0, 12)),
-                type: 'other',
-                summary: summary
+                id: "evidence-".concat(hashResolveIOSupportV5Evidence({ type: inferSupportDiagnosisEvidenceTypeFromText(summary), summary: summary }).slice(0, 12)),
+                type: inferSupportDiagnosisEvidenceTypeFromText(summary),
+                summary: summary,
+                ownerFiles: supportLooseEvidenceOwnerFiles(summary, ownerFiles),
+                artifactPath: supportLooseEvidenceOwnerFiles(summary, ownerFiles)[0]
             }] : [];
     }
     var stringEvidence = values
         .filter(function (entry) { return typeof entry === 'string'; })
         .map(function (entry) {
         var summary = cleanText(entry, 1200);
+        var matchedOwnerFiles = supportLooseEvidenceOwnerFiles(summary, ownerFiles);
+        var type = matchedOwnerFiles.length ? 'code' : inferSupportDiagnosisEvidenceTypeFromText(summary);
         return {
-            id: "evidence-".concat(hashResolveIOSupportV5Evidence({ type: 'other', summary: summary }).slice(0, 12)),
-            type: 'other',
-            summary: summary
+            id: "evidence-".concat(hashResolveIOSupportV5Evidence({ type: type, summary: summary, ownerFiles: matchedOwnerFiles }).slice(0, 12)),
+            type: type,
+            summary: summary,
+            artifactPath: type === 'code' ? matchedOwnerFiles[0] : undefined,
+            ownerFiles: matchedOwnerFiles
         };
     });
     var objectEvidence = values
@@ -1668,6 +1725,10 @@ function supportDiagnosisNarrativeText(value, max) {
         'expectedResult',
         'observed_result',
         'observedResult',
+        'route',
+        'path_chain',
+        'pathChain',
+        'assessment',
         'path',
         'reason',
         'fact'
@@ -2188,18 +2249,31 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
     var issueClass = normalizeIssueClass(source.issue_class || source.issueClass);
     var featureRequestClassified = supportDiagnosisLooksLikeClassifiedFeatureRequest(source, issueCaseText, failingPathText, hypothesisText);
     var shouldDeriveLooseProofPlan = Array.isArray(rawProofPlan) || featureRequestClassified;
+    var looseProofSubject = cleanText(issueCaseText || failingPathText || hypothesisText, 1200);
     var proofPlanBefore = pickText(proofPlanSource, ['before', 'before_state', 'beforeState', 'precondition'], 1000);
     var proofPlanBeforeUnavailable = pickText(proofPlanSource, ['before_state_unavailable_reason', 'beforeStateUnavailableReason', 'before_unavailable_reason'], 1000)
         || (featureRequestClassified ? 'Before-state business proof is not available because this is classified as net-new feature scope; current evidence proves the requested route/workflow is not implemented yet.' : '');
-    var proofPlanAction = pickText(proofPlanSource, ['action', 'browser_action', 'browserAction', 'steps'], 1000) || proofPlanRows.action;
-    var proofPlanAfter = pickText(proofPlanSource, ['after', 'after_state', 'afterState', 'expected_after'], 1000) || proofPlanRows.after;
-    var proofPlanBusinessAssertion = pickText(proofPlanSource, ['business_assertion', 'businessAssertion', 'assertion'], 1000) || proofPlanRows.business_assertion;
-    var proofPlanDataAssertion = pickText(proofPlanSource, ['data_assertion', 'dataAssertion', 'mongo_delta', 'mongoDelta'], 1000) || proofPlanRows.data_assertion;
+    var derivedLooseBefore = shouldDeriveLooseProofPlan && looseProofSubject
+        ? "Capture the before-state business value from the reported workflow: ".concat(looseProofSubject)
+        : '';
+    var proofPlanBeforeResolved = proofPlanBefore || derivedLooseBefore;
+    var proofPlanAction = pickText(proofPlanSource, ['action', 'browser_action', 'browserAction', 'steps'], 1000)
+        || proofPlanRows.action
+        || (shouldDeriveLooseProofPlan ? 'Execute the issue-specific workflow and inspect the affected data/rendering path.' : '');
+    var proofPlanAfter = pickText(proofPlanSource, ['after', 'after_state', 'afterState', 'expected_after'], 1000)
+        || proofPlanRows.after
+        || (shouldDeriveLooseProofPlan && looseProofSubject ? "The workflow produces the expected customer-facing business value instead of the reported wrong result for: ".concat(looseProofSubject) : '');
+    var proofPlanBusinessAssertion = pickText(proofPlanSource, ['business_assertion', 'businessAssertion', 'assertion'], 1000)
+        || proofPlanRows.business_assertion
+        || (shouldDeriveLooseProofPlan && looseProofSubject ? "The customer-reported condition is resolved with business data proof: ".concat(looseProofSubject) : '');
+    var proofPlanDataAssertion = pickText(proofPlanSource, ['data_assertion', 'dataAssertion', 'mongo_delta', 'mongoDelta'], 1000)
+        || proofPlanRows.data_assertion
+        || (shouldDeriveLooseProofPlan ? 'DOM/data or Mongo proof shows the expected business value and does not show the reported wrong value.' : '');
     var proofPlanArtifactExpectation = pickText(proofPlanSource, ['artifact_expectation', 'artifactExpectation', 'artifact', 'screenshot'], 1000)
         || (shouldDeriveLooseProofPlan && proofPlanBusinessAssertion ? 'browser trace/screenshot plus persisted DOM/data or Mongo delta tied to the business assertion' : '');
     var derivedBusinessProofContract = shouldDeriveLooseProofPlan && proofPlanBusinessAssertion ? {
         issue_class: issueClass || source.issue_class || source.issueClass,
-        setup_state: proofPlanBefore || proofPlanBeforeUnavailable,
+        setup_state: proofPlanBeforeResolved || proofPlanBeforeUnavailable,
         action_under_test: proofPlanAction,
         expected_business_state_change: proofPlanAfter || proofPlanBusinessAssertion,
         prohibited_false_pass: 'Route load, screenshot, scorecard, or model claim alone is not acceptance.',
@@ -2216,7 +2290,7 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
         .filter(Boolean);
     var productOwnerFiles = rawOwnerFiles.filter(function (ownerFile) { return !ownerFileLooksNonProductEvidence(ownerFile); });
     var ownerFiles = productOwnerFiles.length ? productOwnerFiles : rawOwnerFiles;
-    var explicitEvidence = normalizeSupportDiagnosisEvidence(source.evidence);
+    var explicitEvidence = normalizeSupportDiagnosisEvidence(source.evidence, ownerFiles);
     var derivedFeatureRequestEvidence = !explicitEvidence.length && featureRequestClassified ? __spreadArray(__spreadArray([], __read((issueCaseText ? [{
             id: "evidence-".concat(hashResolveIOSupportV5Evidence({ type: 'ticket', summary: issueCaseText }).slice(0, 12)),
             type: 'ticket',
@@ -2238,14 +2312,18 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
         || (featureRequestClassified ? 'net-new support feature workflow' : '');
     var expectedResult = pickText(issueCaseSource, ['expected_result', 'expectedResult', 'expected'], 1000)
         || pickText(source, ['expected_result', 'expectedResult', 'expected', 'primary_goal', 'primaryGoal', 'requested_behavior', 'requestedBehavior'], 1000)
+        || (!featureRequestClassified && issueCaseText ? "Expected customer-facing business result from ticket: ".concat(issueCaseText) : '')
         || (featureRequestClassified && issueCaseText ? "Implement the requested workflow: ".concat(issueCaseText) : '');
     var observedResult = pickText(issueCaseSource, ['observed_result', 'observedResult', 'observed', 'actual'], 1000)
         || pickText(source, ['observed_result', 'observedResult', 'observed', 'actual', 'current_state', 'currentState'], 1000)
+        || (!featureRequestClassified && issueCaseText ? "Observed/reported wrong business result from ticket: ".concat(issueCaseText) : '')
         || (featureRequestClassified ? "Current repo evidence indicates no implemented route/module for ".concat(routeModule || 'the requested workflow', ".") : '');
     var accountCustomerContext = pickText(issueCaseSource, ['account_customer_context', 'accountCustomerContext', 'account', 'customer', 'user', 'context'], 800)
         || pickText(source, ['account_customer_context', 'accountCustomerContext', 'affected_account_user', 'affectedAccountUser', 'account', 'customer', 'client', 'user', 'context'], 800)
+        || (issueCaseText ? 'Customer/account context from support ticket intake and hydrated support attachments.' : '')
         || (featureRequestClassified ? 'Customer/account context from support ticket intake.' : '');
     var rawReproductionStatus = issueCaseSource.reproduction_status || issueCaseSource.reproductionStatus || source.reproduction_status;
+    var hasRuntimeReproductionEvidence = diagnosisEvidence.some(function (entry) { return SUPPORT_REPRODUCTION_EVIDENCE_TYPES.has(entry.type); });
     var gate = {
         issue_case: {
             customer_complaint: pickText(issueCaseSource, ['customer_complaint', 'customerComplaint', 'complaint', 'request', 'summary'], 1200) || issueCaseText,
@@ -2253,7 +2331,9 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
             observed_result: observedResult,
             route_module: routeModule,
             account_customer_context: accountCustomerContext,
-            reproduction_status: rawReproductionStatus ? normalizeReproductionStatus(rawReproductionStatus) : (featureRequestClassified ? 'classified' : normalizeReproductionStatus(rawReproductionStatus)),
+            reproduction_status: rawReproductionStatus
+                ? normalizeReproductionStatus(rawReproductionStatus)
+                : (featureRequestClassified || !hasRuntimeReproductionEvidence ? 'classified' : 'reproduced'),
             reproduction_blocker: pickText(issueCaseSource, ['reproduction_blocker', 'reproductionBlocker', 'blocked_reason', 'blockedReason'], 1000)
         },
         issue_class: issueClass || 'missing_wrong_data',
@@ -2272,11 +2352,11 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
             backend: pickText(failingPathSource, ['backend', 'backend_path', 'backendPath', 'methodPublicationPath'], 700),
             shared_library: pickText(failingPathSource, ['shared_library', 'sharedLibrary', 'library', 'lib'], 700),
             data_query: pickText(failingPathSource, ['data_query', 'dataQuery', 'query'], 700),
-            description: pickText(failingPathSource, ['description', 'path', 'summary'], 1200) || failingPathText
+            description: pickText(failingPathSource, ['description', 'path_chain', 'pathChain', 'path', 'assessment', 'summary', 'route'], 1200) || failingPathText
         },
         owner_files: ownerFiles,
         proof_plan: {
-            before: proofPlanBefore,
+            before: proofPlanBeforeResolved,
             before_state_unavailable_reason: proofPlanBeforeUnavailable,
             action: proofPlanAction,
             after: proofPlanAfter,