superpowers-manager 0.4.0 → 0.5.1

package/dist/{codex-presentation.js → harnesses/codex/presentation.js}

@@ -1,9 +1,10 @@
-import { normalizeCodexInstall, normalizeCodexInstalled, } from "./codex-harness.js";
-import { displaySource } from "./selection.js";
+import { normalizeCodexInstall, normalizeCodexInstalled } from "./harness.js";
+import { displaySource } from "../../selection.js";
 // One ordered table drives both formats, preserving the public human and
 // porcelain field order exposed through the harness presentation.
 export function fields(f) {
     return [
+        { key: "harness", label: "harness", value: f.harness },
         { 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 },
@@ -58,6 +59,7 @@ export function fields(f) {
     ];
 }
 const NO_FACTS = {
+    harness: "codex",
     requestedRef: "",
     resolvedRef: "",
     desiredCommit: "",
@@ -114,7 +116,7 @@ export function codexInstallReceipt(missingHint, mismatchHint) {
         mismatchVerificationOutput: verificationOutput("mismatch", mismatchHint),
     };
 }
-// Compatibility export target for src/lifecycle.ts. Delegate to the production
+// Compatibility export target for src/harnesses/codex/lifecycle.ts. Delegate to the production
 // normalizers and renderer so the retained verdict cannot drift from commands.
 export function verifyInstalledFingerprint(desiredCommit, installResult, inspectResult) {
     const receipt = normalizeCodexInstall(installResult);
@@ -129,6 +131,7 @@ function probeFacts(facts) {
     const selection = facts.selection;
     const saved = selection.saved;
     return {
+        harness: "codex",
         requestedRef: selection.requestedRef,
         resolvedRef: selection.resolvedRef,
         desiredCommit: selection.desiredCommit,
@@ -205,7 +208,27 @@ export const codexPresentation = {
     currentNotice: "manager is current",
     renderProbe(snapshot) {
         const facts = probeFacts(snapshot);
-        return { human: formatHuman(facts), porcelain: formatPorcelain(facts) };
+        const conflicts = snapshot.ownership.presentationConflicts ?? [];
+        const additional = [
+            ["installation_state", snapshot.installed.kind],
+            ["resource_state", snapshot.resourceState ?? "idle"],
+            ["compatibility", snapshot.compatibility.kind],
+            ["compatibility_reason", snapshot.compatibility.reason],
+        ];
+        return {
+            human: formatHuman(facts) +
+                additional
+                    .map(([key, value]) => `${key.replaceAll("_", " ")}: ${value}\n`)
+                    .join("") +
+                conflicts
+                    .map((conflict) => `ownership conflict: ${conflict}\n`)
+                    .join(""),
+            porcelain: formatPorcelain(facts) +
+                additional.map(([key, value]) => `${key}=${value}\n`).join("") +
+                conflicts
+                    .map((conflict) => `ownership_conflict=${conflict}\n`)
+                    .join(""),
+        };
     },
     renderInstallVerification(desiredCommit, receipt, inspection) {
         if (inspection.status !== 0 || !inspection.outcome.ok) {

package/dist/{codex-state.js → harnesses/codex/state.js}

@@ -1,8 +1,8 @@
 import { readFile, realpath } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { COMMIT_INPUT_RE } from "./domain/refs.js";
-import { SafetyError } from "./safety-error.js";
-import { parseStrictJson, } from "./strict-json.js";
+import { COMMIT_INPUT_RE } from "../../domain/refs.js";
+import { SafetyError } from "../../safety-error.js";
+import { parseStrictJson, } from "../../strict-json.js";
 const INSTALLED_PROFILE = {
     duplicateKeys: "last-wins",
     nonStandardConstants: "reject",

package/dist/harnesses/pi/compatibility.js

@@ -0,0 +1,73 @@
+import { createHash } from "node:crypto";
+import { lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { readArtifactFile, readArtifactObject, validateNativeSkill, } from "../../artifact-tree.js";
+import { SEMVER_RE } from "../../domain/refs.js";
+import { validateSource } from "../../selection.js";
+const OFFICIAL_SOURCES = new Set([
+    "https://github.com/obra/superpowers",
+    "https://github.com/obra/superpowers.git",
+    "ssh://git@github.com/obra/superpowers.git",
+    "git@github.com:obra/superpowers.git",
+]);
+export function samePiSource(left, right) {
+    validateSource(left);
+    validateSource(right);
+    return (left === right ||
+        (OFFICIAL_SOURCES.has(left) && OFFICIAL_SOURCES.has(right)));
+}
+export async function assessPiCompatibility(root, selection) {
+    try {
+        validateSource(selection.effectiveSource);
+        const official = OFFICIAL_SOURCES.has(selection.effectiveSource);
+        const pkg = await readArtifactObject(root, join(root, "package.json"));
+        if (pkg.name !== "superpowers" ||
+            pkg.type !== "module" ||
+            typeof pkg.version !== "string" ||
+            !SEMVER_RE.test(pkg.version))
+            throw new Error("package metadata");
+        const pi = pkg.pi;
+        if (!pi ||
+            typeof pi !== "object" ||
+            Array.isArray(pi) ||
+            Object.keys(pi).length !== 2 ||
+            JSON.stringify(pi.extensions) !== '["./.pi/extensions/superpowers.ts"]' ||
+            JSON.stringify(pi.skills) !== '["./skills"]')
+            throw new Error("resource declaration");
+        for (const key of [
+            "dependencies",
+            "optionalDependencies",
+            "peerDependencies",
+            "bundleDependencies",
+            "bundledDependencies",
+        ]) {
+            const value = pkg[key];
+            if (value !== undefined &&
+                (value === null ||
+                    typeof value !== "object" ||
+                    Object.keys(value).length !== 0))
+                throw new Error("runtime dependencies");
+        }
+        await validateNativeSkill(root);
+        const bootstrap = join(root, ".pi/extensions/superpowers.ts");
+        const bytes = await readArtifactFile(root, bootstrap, 4283);
+        if ((await lstat(bootstrap)).mode & 0o111 ||
+            bytes.length !== 4283 ||
+            createHash("sha256").update(bytes).digest("hex") !==
+                "39c27000c047f8a1399a76e032e4cd239d7bdb0be168a121f46a2ac719deaae0")
+            throw new Error("bootstrap implementation");
+        return {
+            kind: official ? "supported" : "experimental",
+            generation: "pi-native-bootstrap-v1",
+            reason: official
+                ? "qualified upstream-native Pi bootstrap"
+                : "qualified Pi mechanics from a custom source",
+        };
+    }
+    catch {
+        return {
+            kind: "unsupported",
+            reason: `Pi package does not match the qualified native bootstrap profile: ${root}`,
+        };
+    }
+}

package/dist/harnesses/pi/harness.js

@@ -0,0 +1,63 @@
+import { failureResult, successResult } from "../../adapter-result.js";
+import { classifyPathNoFollow } from "../../safe-path.js";
+import { installPi, removePi } from "./install.js";
+import { piPaths } from "./paths.js";
+import { inspectPiPrepared, piPreparationLocation, preparePiCandidate, readPiPrepared, } from "./prepare.js";
+import { piPresentation } from "./presentation.js";
+import { inspectPiControl, inspectPiInstalled, inspectPiOwnership, } from "./state.js";
+export const piHarness = {
+    preparationLocation: piPreparationLocation,
+    mutationRoots: async (ctx) => [
+        piPaths(ctx.env ?? {}, process.cwd()).agentDir,
+    ],
+    validatePreparationBeforeFetch: async () => successResult("validate-pi-preparation", null, []),
+    prepareCandidate: preparePiCandidate,
+    inspectPrepared: inspectPiPrepared,
+    readPrepared: readPiPrepared,
+    inspectOwnership: inspectPiOwnership,
+    async inspectUpdateControl(ctx) {
+        const paths = piPaths(ctx.env ?? {}, process.cwd());
+        try {
+            if ((await classifyPathNoFollow(paths.recoveryRoot)) !== "missing") {
+                const decision = {
+                    kind: "blocked",
+                    output: {
+                        stdout: [],
+                        stderr: [
+                            `error: Pi recovery required; preserve material at ${paths.recoveryRoot} for manual resolution`,
+                        ],
+                    },
+                };
+                return successResult("inspect-pi-control", {
+                    probeEligibility: decision,
+                    mutationEligibility: decision,
+                    presentationValue: `recovery required at ${paths.recoveryRoot}`,
+                    recoveryState: "required",
+                }, []);
+            }
+        }
+        catch {
+            return failureResult("inspect-pi-control", "invalid-state", `cannot inspect Pi recovery state at ${paths.recoveryRoot}`, [], []);
+        }
+        return await inspectPiControl(ctx);
+    },
+    inspectInstalled: inspectPiInstalled,
+    install: installPi,
+    remove: removePi,
+    requirements(command, env) {
+        if (command !== "install" &&
+            command !== "update" &&
+            command !== "uninstall")
+            return [];
+        const executable = env.SUPERPOWERS_PI || "pi";
+        return [
+            {
+                name: "pi",
+                executable,
+                lookup: "explicit-path-or-path",
+                missingMessage: `required command not found: ${executable} — install the Pi CLI or set SUPERPOWERS_PI`,
+            },
+        ];
+    },
+    presentation: piPresentation,
+};