@postplus/cli 0.1.39 → 0.1.41

package/build/doctor.js

@@ -25,6 +25,19 @@ function createFail(id, label, detail, fix, input = {}) {
         metadata: input.metadata,
     };
 }
+// A check whose hosted route/key is released but has a known field-level coverage
+// gap. It is not a required failure (does not break `requiredOk`); it is surfaced
+// so the gap is visible instead of a blanket pass.
+function createDegraded(id, label, detail, fix, input = {}) {
+    return {
+        id,
+        label,
+        status: 'degraded',
+        severity: input.severity ?? 'required',
+        detail,
+        fix,
+    };
+}
 export async function generateDoctorReport(options = {}) {
     const hostedBaseUrl = await resolveHostedBaseUrl();
     const checks = [
@@ -109,9 +122,12 @@ async function checkLocalDependencies(skillScope) {
     }
 }
 function buildDoctorReport(checks, skillId) {
-    const requiredOk = checks.every((check) => check.severity !== 'required' || check.status === 'pass');
+    // A degraded required check is a known coverage gap, not a failure: it keeps
+    // `requiredOk` true but `ok` false (doctor is not a clean pass while a gap
+    // exists), mirroring how task-specific warnings surface without failing.
+    const requiredOk = checks.every((check) => check.severity !== 'required' || check.status !== 'fail');
     return {
-        schemaVersion: 1,
+        schemaVersion: 2,
         ok: checks.every((check) => check.status === 'pass'),
         requiredOk,
         checks,
@@ -191,6 +207,15 @@ async function checkHostedCapabilities(input, skillScope) {
             });
         }
         const subscription = readSubscriptionStatusField(payload).label;
+        const degradedLabels = relevantCapabilities
+            .map((value) => readCapabilityDegradedLabel(value, skillScope))
+            .filter((value) => value !== null);
+        if (degradedLabels.length > 0) {
+            const skillId = skillScope?.skill.skillId;
+            return createDegraded('hosted_capabilities', skillId ? `Hosted capabilities for ${skillId}` : 'Hosted capabilities', `Ready with field-level coverage gaps: ${degradedLabels.join(', ')}; subscription ${subscription}`, 'These hosted routes are released but have a known field-level contract gap. Track the readiness convergence plan before relying on field-level validation for these endpoints.', {
+                severity: skillId ? 'required' : 'task_specific',
+            });
+        }
         return createPass('hosted_capabilities', skillScope
             ? `Hosted capabilities for ${skillScope.skill.skillId}`
             : 'Hosted capabilities', `Ready (${relevantCapabilities.length} capability checks passed; subscription ${subscription})`);
@@ -244,6 +269,48 @@ function readReadinessCheckFailureLabel(value) {
             ? record.id
             : 'unknown check';
 }
+// Surfaces a capability whose checks include a `degraded` field-level dimension.
+// Degraded checks keep `ok` true (they do not fail the capability), so the
+// failure reader skips them; this reader reports the gap separately.
+function readCapabilityDegradedLabel(value, skillScope) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    if (value.required === false) {
+        return null;
+    }
+    const degradedChecks = Array.isArray(value.checks)
+        ? value.checks
+            .map(readReadinessCheckDegradedLabel)
+            .filter((check) => check !== null)
+        : [];
+    if (degradedChecks.length === 0) {
+        return null;
+    }
+    const label = typeof value.label === 'string'
+        ? value.label
+        : typeof value.id === 'string'
+            ? value.id
+            : 'unknown capability';
+    const labelWithChecks = `${label} (${degradedChecks.join(', ')})`;
+    return skillScope
+        ? `${labelWithChecks} for ${skillScope.skill.skillId}`
+        : labelWithChecks;
+}
+function readReadinessCheckDegradedLabel(value) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const record = value;
+    if (record.status !== 'degraded') {
+        return null;
+    }
+    return typeof record.label === 'string'
+        ? record.label
+        : typeof record.id === 'string'
+            ? record.id
+            : 'unknown check';
+}
 function filterCapabilitiesForSkill(capabilities, requirements) {
     if (!hasHostedRequirements(requirements)) {
         return [];
@@ -401,18 +468,23 @@ export function formatDoctorReport(report) {
     for (const check of report.checks) {
         const marker = check.status === 'pass'
             ? '[PASS]'
-            : check.severity === 'task_specific'
-                ? '[WARN]'
-                : '[FAIL]';
+            : check.status === 'degraded'
+                ? '[DEGRADED]'
+                : check.severity === 'task_specific'
+                    ? '[WARN]'
+                    : '[FAIL]';
         lines.push(`${marker} ${check.label}: ${check.detail}`);
         if (check.fix) {
             lines.push(`  Fix: ${check.fix}`);
         }
     }
+    const hasDegraded = report.checks.some((check) => check.status === 'degraded');
     lines.push('', report.ok
         ? 'Doctor passed.'
         : report.requiredOk
-            ? 'Doctor incomplete: task-specific checks need attention.'
+            ? hasDegraded
+                ? 'Doctor incomplete: hosted readiness has known field-level coverage gaps.'
+                : 'Doctor incomplete: task-specific checks need attention.'
             : 'Doctor failed.');
     return lines.join('\n');
 }