@resolveio/server-lib 22.3.212 → 22.3.214

package/package.json

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

package/util/support-runner-v5.js

@@ -130,7 +130,7 @@ function cleanListEntryText(value, max) {
     if (value && typeof value === 'object' && !Array.isArray(value)) {
         var source = value;
         var hypothesis = cleanListEntryText(source.hypothesis, Math.floor(max / 2));
-        var whyRejected = cleanListEntryText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected, Math.floor(max / 2));
+        var whyRejected = cleanListEntryText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected || source.reason, Math.floor(max / 2));
         if (hypothesis && whyRejected) {
             return "".concat(hypothesis, " rejected because ").concat(whyRejected).slice(0, max);
         }
@@ -149,8 +149,11 @@ function cleanListEntryText(value, max) {
                 'artifactPath',
                 'artifact_path',
                 'summary',
+                'detail',
                 'message',
                 'description',
+                'proof_required',
+                'proofRequired',
                 'reason',
                 'value',
                 'label',
@@ -924,6 +927,13 @@ function normalizeIssueClass(value) {
         upload: 'upload_import',
         import: 'upload_import',
         upload_import: 'upload_import',
+        behavior: 'missing_wrong_data',
+        workflow_behavior: 'missing_wrong_data',
+        general: 'missing_wrong_data',
+        general_inquiry: 'missing_wrong_data',
+        customer_inquiry: 'missing_wrong_data',
+        data_mismatch: 'missing_wrong_data',
+        warehouse_mismatch: 'missing_wrong_data',
         route_auth: 'route_auth_hydration',
         auth_hydration: 'route_auth_hydration',
         route_auth_hydration: 'route_auth_hydration',
@@ -948,24 +958,88 @@ 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();
+    var pathText = cleanText(artifactPath, 500).toLowerCase();
+    if (/\b(screenshot|screen shot)\b/i.test(text) || /\.(?:png|jpe?g|webp|gif)$/i.test(pathText)) {
+        return 'browser';
+    }
+    if (/\b(angular|server|client|src|methods|publications|routing|permission|component|template)\b/i.test(pathText)) {
+        return 'code';
+    }
+    if (/\b(browser|dom|click|route|page|playwright|puppeteer)\b/i.test(text)) {
+        return 'browser';
+    }
+    if (/\b(ticket|customer|client|reporter|reported|support request|manual-ticket|email\.metadata)\b/i.test(text)) {
+        return 'ticket';
+    }
+    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
@@ -973,30 +1047,45 @@ function normalizeSupportDiagnosisEvidence(values) {
         .map(function (entry) {
         var type = cleanText(entry.type, 80).toLowerCase();
         var artifactPath = cleanText(entry.artifactPath || entry.artifact_path || entry.path || entry.file, 500);
+        var summary = cleanText(entry.summary || entry.detail || entry.message || entry.evidence || entry.reason || entry.fact || entry.description || entry.proof_required || entry.proofRequired, 1200)
+            || (artifactPath ? "Evidence from ".concat(artifactPath) : '');
+        var evidenceText = [summary, artifactPath].filter(Boolean).join(' ');
         var inferredType = (function () {
-            if (allowed.has(type)) {
+            var inferredFromText = inferSupportDiagnosisEvidenceTypeFromText(summary, artifactPath);
+            if (allowed.has(type) && type !== 'other') {
+                if (type === 'ticket' && inferredFromText === 'browser') {
+                    return 'browser';
+                }
                 return type;
             }
-            if (/\b(ticket|manual-ticket|support-context|email\.metadata)\b/i.test(artifactPath)) {
+            if (/\b(screenshot|screen shot)\b/i.test(evidenceText)
+                || /\.(?:png|jpe?g|webp|gif)$/i.test(artifactPath)) {
+                return 'browser';
+            }
+            if (/\b(angular|server|client|src|methods|publications|routing|permission|component|template)\b/i.test(artifactPath)) {
+                return 'code';
+            }
+            if (/\b(playwright|puppeteer|browser|dom|click|route|page)\b/i.test(evidenceText)) {
+                return 'browser';
+            }
+            if (/\b(ticket|manual-ticket|support request|customer|reporter|email\.metadata)\b/i.test(evidenceText)) {
                 return 'ticket';
             }
-            if (/\b(commit|git)\b/i.test(artifactPath)) {
+            if (/\b(commit|git)\b/i.test(evidenceText)) {
                 return 'commit';
             }
-            if (/\b(mongo|query|database|collection)\b/i.test(artifactPath)) {
+            if (/\b(mongo|query|database|collection)\b/i.test(evidenceText)) {
                 return 'mongo';
             }
-            if (/\b(log|trace)\b/i.test(artifactPath)) {
+            if (/\b(log|trace|console|network)\b/i.test(evidenceText)) {
                 return 'log';
             }
-            if (/\b(angular|server|client|src|methods|publications|routing|permission|component)\b/i.test(artifactPath)) {
+            if (/\b(angular|server|client|src|methods|publications|routing|permission|component|template)\b/i.test(evidenceText)) {
                 return 'code';
             }
-            return 'other';
+            return inferredFromText;
         })();
         var normalizedType = inferredType;
-        var summary = cleanText(entry.summary || entry.message || entry.evidence || entry.reason || entry.fact || entry.description, 1200)
-            || (artifactPath ? "Evidence from ".concat(artifactPath) : '');
         var ownerFiles = cleanList(entry.ownerFiles || entry.owner_files || entry.files, 12, 500)
             .map(normalizeOwnerFilePath)
             .filter(Boolean);
@@ -1656,8 +1745,14 @@ function supportDiagnosisNarrativeText(value, max) {
     if (!Object.keys(source).length) {
         return '';
     }
+    var hypothesis = cleanText(source.hypothesis, Math.floor(max / 2));
+    var whyRejected = cleanText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected || source.reason, Math.floor(max / 2));
+    if (hypothesis && whyRejected) {
+        return "".concat(hypothesis, " rejected because ").concat(whyRejected).slice(0, max);
+    }
     var direct = pickText(source, [
         'summary',
+        'detail',
         'description',
         'statement',
         'issue_case',
@@ -1668,18 +1763,19 @@ function supportDiagnosisNarrativeText(value, max) {
         'expectedResult',
         'observed_result',
         'observedResult',
+        'route',
+        'path_chain',
+        'pathChain',
+        'assessment',
         'path',
+        'proof_required',
+        'proofRequired',
         'reason',
         'fact'
     ], max);
     if (direct) {
         return direct;
     }
-    var hypothesis = cleanText(source.hypothesis, Math.floor(max / 2));
-    var whyRejected = cleanText(source.why_rejected || source.whyRejected || source.reason_rejected || source.reasonRejected, Math.floor(max / 2));
-    if (hypothesis && whyRejected) {
-        return "".concat(hypothesis, " rejected because ").concat(whyRejected).slice(0, max);
-    }
     var routeModulePermission = cleanText(source.route_module_permission_gate || source.routeModulePermissionGate, Math.floor(max / 2));
     var templateGate = cleanText(source.template_conditional_rendering_gate || source.templateConditionalRenderingGate, Math.floor(max / 2));
     var backingGate = cleanText(source.backing_role_group_config_publications_gate || source.backingRoleGroupConfigPublicationsGate, Math.floor(max / 2));
@@ -2164,6 +2260,7 @@ function evaluateResolveIOSupportDiagnosisEvidenceQuality(value) {
     };
 }
 function normalizeResolveIOSupportDiagnosisGate(value, now) {
+    var _a, _b, _c;
     var rootSource = cleanObject(value);
     var source = cleanObject(rootSource.support_diagnosis_gate
         || rootSource.supportDiagnosisGate
@@ -2188,18 +2285,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 +2326,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',
@@ -2232,28 +2342,53 @@ function normalizeResolveIOSupportDiagnosisGate(value, now) {
         ownerFiles: [ownerFile]
     }); })), false) : [];
     var diagnosisEvidence = explicitEvidence.length ? explicitEvidence : derivedFeatureRequestEvidence;
+    var ticketEvidenceText = ((_a = diagnosisEvidence.find(function (entry) { return entry.type === 'ticket'; })) === null || _a === void 0 ? void 0 : _a.summary) || '';
+    var browserEvidenceText = ((_b = diagnosisEvidence.find(function (entry) { return entry.type === 'browser'; })) === null || _b === void 0 ? void 0 : _b.summary) || '';
+    var rootCauseEvidenceText = ((_c = diagnosisEvidence.find(function (entry) { return SUPPORT_ROOT_CAUSE_EVIDENCE_TYPES.has(entry.type); })) === null || _c === void 0 ? void 0 : _c.summary) || '';
+    var customerIssueCaseText = (function () {
+        var issueText = cleanText(issueCaseText, 1200);
+        if (issueText && !supportDiagnosisTextLooksGeneric(issueText, 18)
+            && !/\b(general inquiry|existing behavior|not a confirmed runtime failure)\b/i.test(issueText)) {
+            return issueText;
+        }
+        return cleanText([ticketEvidenceText, browserEvidenceText]
+            .filter(Boolean)
+            .join(' '), 1200);
+    })();
+    var issueCasePrimaryText = customerIssueCaseText || cleanText([
+        rootCauseEvidenceText,
+        failingPathText,
+        hypothesisText
+    ].filter(Boolean).join(' '), 1200);
     var routeModule = pickText(issueCaseSource, ['route_module', 'routeModule', 'route', 'module', 'screen'], 500)
         || pickText(source, ['route_module', 'routeModule', 'module', 'screen'], 500)
         || pickText(failingPathSource, ['route', 'module', 'path', 'description'], 500)
+        || failingPathText
         || (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 ? "Implement the requested workflow: ".concat(issueCaseText) : '');
+        || (!featureRequestClassified && issueCasePrimaryText ? "Expected customer-facing business result from ticket evidence: ".concat(issueCasePrimaryText) : '')
+        || (featureRequestClassified && issueCasePrimaryText ? "Implement the requested workflow: ".concat(issueCasePrimaryText) : '');
     var observedResult = pickText(issueCaseSource, ['observed_result', 'observedResult', 'observed', 'actual'], 1000)
         || pickText(source, ['observed_result', 'observedResult', 'observed', 'actual', 'current_state', 'currentState'], 1000)
+        || (!featureRequestClassified && (browserEvidenceText || issueCasePrimaryText) ? "Observed/reported wrong business result from ticket or screenshot evidence: ".concat(browserEvidenceText || issueCasePrimaryText) : '')
         || (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)
+        || (issueCasePrimaryText ? '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,
+            customer_complaint: pickText(issueCaseSource, ['customer_complaint', 'customerComplaint', 'complaint', 'request', 'summary'], 1200) || customerIssueCaseText,
             expected_result: expectedResult,
             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 +2407,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,