superpowers-manager 0.3.0 → 0.5.0

package/dist/commands/probe.js

@@ -1,115 +1,7 @@
 import { assertFailureWritable, writeAdapterFailure, } from "../adapter-result.js";
 import { oneLine } from "../cli-arguments.js";
 import { computeEffectiveSelection } from "../effective-selection.js";
-import { generatedCommitOrEmpty } from "../provenance.js";
-import { displaySource } from "../selection.js";
-import { statusForCommits } from "../status.js";
 export const PROBE_USAGE = "error: usage: superpowers-manager probe [--porcelain]\n";
-// One ordered table drives both formats, so the porcelain key order
-// (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:43-59::printf 'requested_ref`) and the human label order (`git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:61-77::printf 'requested ref`) cannot
-// drift apart. Two parallel lists could each stay self-consistent while
-// disagreeing with one another.
-function fields(f) {
-    return [
-        { key: "requested_ref", label: "requested ref", value: f.requestedRef },
-        { key: "resolved_ref", label: "resolved ref", value: f.resolvedRef },
-        { key: "desired_commit", label: "desired commit", value: f.desiredCommit },
-        {
-            key: "generated_commit",
-            label: "generated plugin commit",
-            value: f.generatedCommit,
-            absent: "not present",
-        },
-        {
-            key: "installed_commit",
-            label: "installed manager commit or fingerprint",
-            value: f.installedCommit,
-            absent: "not detected",
-        },
-        {
-            key: "identity_state",
-            label: "Codex identity state",
-            value: f.identityState,
-        },
-        { key: "status", label: "status", value: f.status },
-        {
-            key: "selection_origin",
-            label: "selection origin",
-            value: f.selectionOrigin,
-        },
-        { key: "selection_mode", label: "selection mode", value: f.selectionMode },
-        {
-            key: "upstream_source_origin",
-            label: "upstream source origin",
-            value: f.upstreamSourceOrigin,
-        },
-        {
-            key: "effective_source",
-            label: "effective source",
-            value: f.effectiveSource,
-        },
-        { key: "saved_mode", label: "saved mode", value: f.savedMode },
-        { key: "saved_source", label: "saved source", value: f.savedSource },
-        {
-            key: "saved_requested_ref",
-            label: "saved requested ref",
-            value: f.savedRequestedRef,
-        },
-        {
-            key: "saved_resolved_ref",
-            label: "saved resolved ref",
-            value: f.savedResolvedRef,
-        },
-        { key: "saved_commit", label: "saved commit", value: f.savedCommit },
-        { key: "update_control", label: "update control", value: f.updateControl },
-    ];
-}
-// Derived from the same fields() table, so the key list a test asserts and
-// the key list formatPorcelain emits cannot be different lists. The facts
-// argument is irrelevant here — fields() is total over ProbeFacts and the
-// keys do not depend on the values.
-const NO_FACTS = {
-    requestedRef: "",
-    resolvedRef: "",
-    desiredCommit: "",
-    generatedCommit: "",
-    installedCommit: "",
-    identityState: "",
-    status: "",
-    selectionOrigin: "",
-    selectionMode: "",
-    upstreamSourceOrigin: "",
-    effectiveSource: "",
-    savedMode: "",
-    savedSource: "",
-    savedRequestedRef: "",
-    savedResolvedRef: "",
-    savedCommit: "",
-    updateControl: "",
-};
-export const PROBE_PORCELAIN_KEYS = fields(NO_FACTS).map((field) => field.key);
-export function formatPorcelain(f) {
-    return fields(f)
-        .map((field) => `${field.key}=${field.value}\n`)
-        .join("");
-}
-export function formatHuman(f) {
-    let text = fields(f)
-        .map((field) => {
-        const shown = field.value.length === 0 && field.absent !== undefined
-            ? field.absent
-            : field.value;
-        return `${field.label}: ${shown}\n`;
-    })
-        .join("");
-    // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:78-81::if [ "$SPW_SELECTION_ORIGIN`.
-    if (f.selectionOrigin !== f.upstreamSourceOrigin) {
-        text +=
-            "warning: effective ref and source have mixed origins " +
-                `(ref: ${f.selectionOrigin}, source: ${f.upstreamSourceOrigin})\n`;
-    }
-    return text;
-}
 // Ports scripts/core/validate-adapter-response.py's replay (:235-238) and its
 // error/hint block (:269-272). The shell ran that validator on EVERY adapter
 // response, so adapter messages reached the operator on their declared streams
@@ -141,6 +33,86 @@ export function replayOutcome(outcome, ctx) {
     // stored, so scanning it here would re-check a population that cannot fail.
     writeAdapterFailure(ctx, outcome);
 }
+function record(value) {
+    return value !== null && typeof value === "object"
+        ? value
+        : null;
+}
+export function validOutput(value) {
+    const candidate = record(value);
+    return (candidate !== null &&
+        Array.isArray(candidate.stdout) &&
+        candidate.stdout.every((line) => typeof line === "string") &&
+        Array.isArray(candidate.stderr) &&
+        candidate.stderr.every((line) => typeof line === "string"));
+}
+function validDecision(value) {
+    const candidate = record(value);
+    return (candidate !== null &&
+        (candidate.kind === "allowed" ||
+            (candidate.kind === "blocked" && validOutput(candidate.output))));
+}
+function validCompatibility(value) {
+    const candidate = record(value);
+    if (candidate === null ||
+        typeof candidate.reason !== "string" ||
+        (candidate.kind !== "unknown" &&
+            candidate.kind !== "supported" &&
+            candidate.kind !== "experimental" &&
+            candidate.kind !== "unsupported"))
+        return false;
+    return ((candidate.kind !== "supported" && candidate.kind !== "experimental") ||
+        typeof candidate.generation === "string");
+}
+function validPreparedArtifact(value) {
+    const candidate = record(value);
+    return (candidate !== null &&
+        typeof candidate.root === "string" &&
+        typeof candidate.commit === "string" &&
+        typeof candidate.identity === "string" &&
+        validCompatibility(candidate.compatibility));
+}
+function validPrepared(value) {
+    const candidate = record(value);
+    return (candidate !== null &&
+        typeof candidate.observedIdentity === "string" &&
+        validCompatibility(candidate.compatibility) &&
+        (candidate.kind === "needs-prepare" ||
+            (candidate.kind === "current" &&
+                validPreparedArtifact(candidate.artifact))));
+}
+export function validInstalled(value) {
+    const candidate = record(value);
+    return (candidate !== null &&
+        (candidate.kind === "current" ||
+            candidate.kind === "mismatch" ||
+            candidate.kind === "absent") &&
+        typeof candidate.observedIdentity === "string" &&
+        (candidate.kind !== "absent" || candidate.observedIdentity === ""));
+}
+function validOwnership(value) {
+    const candidate = record(value);
+    return (candidate !== null &&
+        validDecision(candidate.installEligibility) &&
+        Object.prototype.hasOwnProperty.call(candidate, "removalInput") &&
+        validDecision(candidate.removalVerification) &&
+        validOutput(candidate.postRemovalOutput) &&
+        typeof candidate.presentationValue === "string" &&
+        (candidate.presentationConflicts === undefined ||
+            (Array.isArray(candidate.presentationConflicts) &&
+                candidate.presentationConflicts.every((conflict) => typeof conflict === "string"))));
+}
+function validControl(value) {
+    const candidate = record(value);
+    return (candidate !== null &&
+        validDecision(candidate.probeEligibility) &&
+        validDecision(candidate.mutationEligibility) &&
+        typeof candidate.presentationValue === "string" &&
+        (candidate.recoveryState === undefined ||
+            (candidate.recoveryState === "required" &&
+                candidate.probeEligibility.kind === "blocked" &&
+                candidate.mutationEligibility.kind === "blocked")));
+}
 // `runAdapter` reports a CONTROLLED failure by RETURN VALUE, not by throwing
 // (`src/adapter-result.ts:32-35::export interface AdapterResult`). The shell got
 // fail-closed behaviour for free: spw_invoke_adapter returned 1 and
@@ -156,25 +128,19 @@ export function replayOutcome(outcome, ctx) {
 // adapter module: src/commands/prepare.ts and this module are the two the
 // injected double must observe, because install reaches the adapter through
 // gatherProbe and runPrepare. Spec §4.5.
-async function inspect(view, key, ctx) {
+async function inspect(call, unexpected, invalidStatus, valid) {
     let result;
     try {
-        result = await ctx.adapter(["inspect", "--view", view], {
-            root: ctx.root,
-            env: ctx.env,
-        });
+        result = await call();
+        if (!result ||
+            !Number.isInteger(result.status) ||
+            !result.outcome ||
+            typeof result.outcome.ok !== "boolean" ||
+            !Array.isArray(result.outcome.messages))
+            return { ok: false, result: null, message: invalidStatus };
     }
     catch {
-        // Deliberately does NOT interpolate the cause. A rethrown non-
-        // AdapterFailure is by construction the one failure src/adapter.ts chose
-        // not to own: free-form text of unknown provenance, which AGENTS.md bars
-        // from this stream. `view` is a bounded token -- one of three literals
-        // this function is ever called with -- so naming the input is safe.
-        return {
-            ok: false,
-            outcome: null,
-            message: `cannot inspect Codex adapter state for view ${view}`,
-        };
+        return { ok: false, result: null, message: unexpected };
     }
     const outcome = result.outcome;
     if (result.status !== 0 || !outcome.ok) {
@@ -183,27 +149,19 @@ async function inspect(view, key, ctx) {
         // rather than falling through to a replay that would print nothing.
         return {
             ok: false,
-            outcome,
-            message: outcome.ok
-                ? `adapter reported a failure status for inspect --view ${view}`
-                : null,
+            result,
+            message: outcome.ok ? invalidStatus : null,
         };
     }
-    const value = outcome.result?.[key];
-    // The Python reader printed the empty string for a JSON null
-    // (scripts/core/provenance.sh's spw_json_get), and `fingerprint` is null
-    // whenever no plugin version is active (`src/adapter.ts:820::fingerprint: null`).
-    if (value === null || value === undefined) {
-        return { ok: true, value: "", outcome };
+    try {
+        if (!valid(outcome.result)) {
+            return { ok: false, result, message: invalidStatus };
+        }
     }
-    if (typeof value !== "string") {
-        return {
-            ok: false,
-            outcome,
-            message: `adapter returned a non-string ${key} for inspect --view ${view}`,
-        };
+    catch {
+        return { ok: false, result, message: invalidStatus };
     }
-    return { ok: true, value, outcome };
+    return { ok: true, result: { status: result.status, outcome } };
 }
 // Runs every step that can throw or fail closed, returning the outcome as
 // data. It performs no writes of its own, so nothing inside runProbe's try can
@@ -222,51 +180,107 @@ async function inspect(view, key, ctx) {
 // gone.
 export async function gatherProbe(ctx) {
     // Order mirrors `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:24-40::spw_compute_effective_selection` exactly.
-    const selection = await computeEffectiveSelection(ctx.root, ctx.env);
-    const generatedCommit = await generatedCommitOrEmpty(ctx.root);
+    const selection = ctx.selection ?? (await computeEffectiveSelection(ctx.root, ctx.env));
     const outcomes = [];
-    const collect = async (view, key) => {
-        const result = await inspect(view, key, ctx);
-        if (result.outcome !== null)
-            outcomes.push(result.outcome);
+    const adapterContext = { root: ctx.root, env: ctx.env };
+    let resources;
+    try {
+        resources = [
+            ctx.adapter.preparationLocation(adapterContext).destinationRoot,
+            ...(await ctx.adapter.mutationRoots(adapterContext)),
+        ];
+    }
+    catch {
+        resources = null;
+    }
+    const before = resources === null
+        ? []
+        : await ctx.coordination.observeResources(resources);
+    const collect = async (call, unexpected, invalidStatus, valid, replaySuccess = true) => {
+        const result = await inspect(call, unexpected, invalidStatus, valid);
+        if (result.result !== null && (replaySuccess || !result.result.outcome.ok))
+            outcomes.push(result.result.outcome);
         return result;
     };
-    const fingerprint = await collect("fingerprint", "fingerprint");
-    if (!fingerprint.ok) {
-        return { status: 1, outcomes, message: fingerprint.message };
+    const prepared = await collect(() => ctx.adapter.inspectPrepared(selection, adapterContext), "cannot inspect prepared harness state", "adapter reported a failure status for prepared harness inspection", validPrepared);
+    if (!prepared.ok) {
+        return { status: 1, outcomes, message: prepared.message };
+    }
+    const failure = (site) => ctx.adapter.presentation.callFailure(site, adapterContext);
+    const installedFailure = failure("probe-installed");
+    const installed = await collect(() => ctx.adapter.inspectInstalled(selection, adapterContext), installedFailure.unexpected, installedFailure.invalidStatus, validInstalled);
+    if (!installed.ok) {
+        return { status: 1, outcomes, message: installed.message };
     }
-    const ownership = await collect("ownership", "identity_state");
+    if (resources === null)
+        return {
+            status: 1,
+            outcomes,
+            message: "cannot determine harness observation resources",
+        };
+    const ownershipFailure = failure("probe-ownership");
+    const ownership = await collect(() => ctx.adapter.inspectOwnership(adapterContext), ownershipFailure.unexpected, ownershipFailure.invalidStatus, validOwnership);
     if (!ownership.ok) {
         return { status: 1, outcomes, message: ownership.message };
     }
-    const updateControl = await collect("update-control", "update_control");
-    if (!updateControl.ok) {
-        return { status: 1, outcomes, message: updateControl.message };
+    const controlFailure = failure("probe-control");
+    const control = await collect(() => ctx.adapter.inspectUpdateControl(adapterContext), controlFailure.unexpected, controlFailure.invalidStatus, validControl);
+    if (!control.ok) {
+        return { status: 1, outcomes, message: control.message };
     }
-    const saved = selection.saved;
+    const preparedAfter = await collect(() => ctx.adapter.inspectPrepared(selection, adapterContext), "cannot inspect prepared harness state", "adapter reported a failure status for prepared harness inspection", validPrepared, false);
+    if (!preparedAfter.ok)
+        return { status: 1, outcomes, message: preparedAfter.message };
+    const installedAfter = await collect(() => ctx.adapter.inspectInstalled(selection, adapterContext), installedFailure.unexpected, installedFailure.invalidStatus, validInstalled, false);
+    if (!installedAfter.ok)
+        return { status: 1, outcomes, message: installedAfter.message };
+    const controlAfter = await collect(() => ctx.adapter.inspectUpdateControl(adapterContext), controlFailure.unexpected, controlFailure.invalidStatus, validControl, false);
+    if (!controlAfter.ok)
+        return { status: 1, outcomes, message: controlAfter.message };
+    const after = await ctx.coordination.observeResources(resources);
+    if (JSON.stringify(before) !== JSON.stringify(after) ||
+        JSON.stringify(prepared.result.outcome.result) !==
+            JSON.stringify(preparedAfter.result.outcome.result) ||
+        JSON.stringify(installed.result.outcome.result) !==
+            JSON.stringify(installedAfter.result.outcome.result) ||
+        JSON.stringify(control.result.outcome.result) !==
+            JSON.stringify(controlAfter.result.outcome.result)) {
+        return {
+            status: 1,
+            outcomes,
+            message: "harness state changed during observation; retry for a coherent probe",
+        };
+    }
+    const unavailable = after.find((observation) => observation.state === "busy" || observation.state === "uninspectable");
+    if (unavailable)
+        return {
+            status: 1,
+            outcomes,
+            message: `harness resource is ${unavailable.state}: ${unavailable.resource}`,
+        };
+    const preparedState = prepared.result.outcome.result;
+    const installedState = installed.result.outcome.result;
     return {
         status: 0,
         outcomes,
         facts: {
-            requestedRef: selection.requestedRef,
-            resolvedRef: selection.resolvedRef,
-            desiredCommit: selection.desiredCommit,
-            generatedCommit,
-            installedCommit: fingerprint.value,
-            identityState: ownership.value,
-            status: statusForCommits(selection.desiredCommit, generatedCommit, fingerprint.value),
-            selectionOrigin: selection.selectionOrigin,
-            selectionMode: selection.selectionMode,
-            upstreamSourceOrigin: selection.upstreamSourceOrigin,
-            effectiveSource: displaySource(selection.effectiveSource),
-            savedMode: saved.saved_mode,
-            // `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/probe:26-30::if [ -`: an absent saved source stays empty rather than
-            // being run through displaySource, which would render <redacted-source>.
-            savedSource: saved.saved_source.length > 0 ? displaySource(saved.saved_source) : "",
-            savedRequestedRef: saved.saved_requested_ref,
-            savedResolvedRef: saved.saved_resolved_ref,
-            savedCommit: saved.saved_commit,
-            updateControl: updateControl.value,
+            selection,
+            prepared: preparedState,
+            installed: installedState,
+            ownership: ownership.result.outcome.result,
+            control: control.result.outcome.result,
+            compatibility: preparedState.compatibility,
+            resources: after,
+            resourceState: control.result.outcome.result.recoveryState === "required"
+                ? "recovery-required"
+                : after.some((observation) => observation.state === "owned")
+                    ? "owned"
+                    : "idle",
+            status: preparedState.kind !== "current"
+                ? "needs prepare"
+                : installedState.kind !== "current"
+                    ? "needs install"
+                    : "current",
         },
     };
 }
@@ -319,7 +333,7 @@ export async function runProbe(argv, ctx) {
         //      every unpinned run does: resolveRef's COMMIT_INPUT_RE branch returns
         //      before any runGit call, so a 40-hex requested ref splices nothing.
         //      Pinned by
-        //      `tests/unit/upstream.test.js:460::void test("resolveRef reports a query failure for latest`,
+        //      `tests/unit/upstream.test.ts:453::void test("resolveRef reports a query failure for latest`,
         //      :471, and :483.
         //   2. The
         //      `src/selection-store.ts:120-124::cause.module === "selection") {`
@@ -387,6 +401,7 @@ export async function runProbe(argv, ctx) {
         }
         return 1;
     }
-    ctx.stdout.write(porcelain ? formatPorcelain(outcome.facts) : formatHuman(outcome.facts));
-    return 0;
+    const rendered = ctx.adapter.presentation.renderProbe(outcome.facts);
+    ctx.stdout.write(porcelain ? rendered.porcelain : rendered.human);
+    return outcome.facts.resourceState === "recovery-required" ? 1 : 0;
 }