superpowers-manager 0.5.2 → 0.7.0

package/dist/selection-state-cli.js

@@ -1,85 +0,0 @@
-import { realpathSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { displaySource, normalizePinnedArguments, normalizeSaved, validateSource, } from "./selection.js";
-import { readSelectionState, writeSelectionState } from "./selection-store.js";
-import { oneLine, parseFlags, UsageError } from "./cli-arguments.js";
-const COMMAND_FLAGS = {
-    read: ["path", "output"],
-    "write-pinned": ["path", "source", "requested-ref", "resolved-ref", "commit"],
-    "write-track-latest": ["path", "source"],
-    "validate-source": ["source"],
-    "display-source": ["source"],
-};
-function parseCommand(argv) {
-    const [name, ...rest] = argv;
-    if (name === undefined)
-        throw new UsageError("a subcommand is required");
-    if (!Object.hasOwn(COMMAND_FLAGS, name)) {
-        throw new UsageError(`unknown subcommand: ${name}`);
-    }
-    const command = name;
-    return { name: command, flags: parseFlags(rest, COMMAND_FLAGS[command]) };
-}
-async function dispatch({ name, flags }) {
-    if (name === "read") {
-        const normalized = normalizeSaved(await readSelectionState(flags.path));
-        try {
-            await writeFile(flags.output, `${JSON.stringify(normalized, null, 2)}\n`, "utf8");
-        }
-        catch (cause) {
-            const message = cause instanceof Error ? cause.message : String(cause);
-            throw new Error(`cannot write normalized selection output ${flags.output}: ${message}`, { cause });
-        }
-        return;
-    }
-    if (name === "write-pinned") {
-        await writeSelectionState(flags.path, normalizePinnedArguments({
-            source: flags.source,
-            requestedRef: flags["requested-ref"],
-            resolvedRef: flags["resolved-ref"],
-            commit: flags.commit,
-        }));
-        return;
-    }
-    if (name === "write-track-latest") {
-        await writeSelectionState(flags.path, {
-            schema_version: 1,
-            mode: "track-latest",
-            source: flags.source,
-        });
-        return;
-    }
-    if (name === "validate-source") {
-        validateSource(flags.source);
-        return;
-    }
-    if (name === "display-source") {
-        process.stdout.write(`${displaySource(flags.source)}\n`);
-        return;
-    }
-    const unreachable = name;
-    throw new Error(`unhandled subcommand: ${String(unreachable)}`);
-}
-export async function runSelectionStateCli(argv) {
-    let command;
-    try {
-        command = parseCommand(argv);
-    }
-    catch (cause) {
-        process.stderr.write(`usage: selection-state-cli <subcommand> [options]\n`);
-        process.stderr.write(`error: ${oneLine(cause)}\n`);
-        return 2;
-    }
-    try {
-        await dispatch(command);
-        return 0;
-    }
-    catch (cause) {
-        process.stderr.write(`error: ${oneLine(cause)}\n`);
-        return 1;
-    }
-}
-const entry = process.argv[1];
-if (entry !== undefined && import.meta.filename === realpathSync(entry)) {
-    process.exitCode = await runSelectionStateCli(process.argv.slice(2));
-}

package/dist/status.js

@@ -1,24 +0,0 @@
-// Ports scripts/core/status.sh in full. Both functions are pure: no I/O, no
-// environment. The three status strings are operator-facing and frozen.
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/status.sh:4-9::spw_commit_matches(`.
-// The `[ -n "$observed" ]` guard comes first and is load-bearing: an empty
-// observed commit must never match, or an absent generated tree reads as
-// current.
-export function commitMatches(desired, observed) {
-    if (observed.length === 0)
-        return false;
-    return observed === desired || observed === desired.slice(0, 7);
-}
-// `git show ad56569a4c161e7b122967442e2b026eeb6395f6:scripts/core/status.sh:11-27::spw_status_for_commits`.
-// Branch order is part of the contract: a stale generated tree outranks a null
-// installed fingerprint, so the operator is told to prepare before being told
-// to install.
-export function statusForCommits(desired, generated, installed) {
-    if (generated.length === 0 || !commitMatches(desired, generated)) {
-        return "needs prepare";
-    }
-    if (installed.length === 0 || !commitMatches(desired, installed)) {
-        return "needs install";
-    }
-    return "current";
-}

package/dist/upstream-cli.js

@@ -1,110 +0,0 @@
-import { realpathSync } from "node:fs";
-import { oneLine, parseFlags, UsageError } from "./cli-arguments.js";
-import { COMMIT_INPUT_RE, TAG_RE } from "./domain/refs.js";
-import { fetchExactCommit, gitSafeSource, resolveExactTag, resolveRef, verifyRawCommit, } from "./upstream.js";
-import { manifestVersionForRef } from "./upstream-version.js";
-const COMMAND_FLAGS = {
-    "resolve-ref": ["source", "ref"],
-    "resolve-exact-tag": ["source", "ref"],
-    "verify-raw-commit": ["source", "commit", "workspace-parent"],
-    "fetch-exact-commit": ["source", "commit", "repository", "workspace-parent"],
-    "manifest-version": [
-        "requested-ref",
-        "resolution-kind",
-        "resolved-ref",
-        "commit",
-    ],
-    "pin-kind": ["ref"],
-    "safe-source": ["source"],
-};
-const RESOLUTION_KINDS = [
-    "latest-release",
-    "tag",
-    "ref",
-    "raw-commit",
-];
-function parseResolutionKind(value) {
-    const found = RESOLUTION_KINDS.find((kind) => kind === value);
-    if (found === undefined) {
-        throw new UsageError(`unknown resolution kind: ${value}`);
-    }
-    return found;
-}
-function parseCommand(argv) {
-    const [name, ...rest] = argv;
-    if (name === undefined)
-        throw new UsageError("a subcommand is required");
-    if (!Object.hasOwn(COMMAND_FLAGS, name)) {
-        throw new UsageError(`unknown subcommand: ${name}`);
-    }
-    const command = name;
-    return { name: command, flags: parseFlags(rest, COMMAND_FLAGS[command]) };
-}
-async function dispatch({ name, flags }) {
-    if (name === "resolve-ref") {
-        const resolution = await resolveRef(flags.source, flags.ref);
-        process.stdout.write(`${resolution.kind} ${resolution.ref} ${resolution.commit}\n`);
-        return;
-    }
-    if (name === "resolve-exact-tag") {
-        process.stdout.write(`${await resolveExactTag(flags.source, flags.ref)}\n`);
-        return;
-    }
-    if (name === "verify-raw-commit") {
-        const commit = await verifyRawCommit(flags.source, flags.commit, flags["workspace-parent"]);
-        process.stdout.write(`${commit}\n`);
-        return;
-    }
-    if (name === "fetch-exact-commit") {
-        await fetchExactCommit(flags.source, flags.commit, flags.repository, flags["workspace-parent"]);
-        return;
-    }
-    if (name === "manifest-version") {
-        const version = manifestVersionForRef({
-            requestedRef: flags["requested-ref"],
-            resolutionKind: parseResolutionKind(flags["resolution-kind"]),
-            resolvedRef: flags["resolved-ref"],
-            commit: flags.commit,
-        });
-        process.stdout.write(`${version}\n`);
-        return;
-    }
-    if (name === "pin-kind") {
-        const kind = TAG_RE.test(flags.ref)
-            ? "tag"
-            : COMMIT_INPUT_RE.test(flags.ref)
-                ? "raw-commit"
-                : "none";
-        process.stdout.write(`${kind}\n`);
-        return;
-    }
-    if (name === "safe-source") {
-        process.stdout.write(`${gitSafeSource(flags.source)}\n`);
-        return;
-    }
-    const unreachable = name;
-    throw new Error(`unhandled subcommand: ${String(unreachable)}`);
-}
-export async function runUpstreamCli(argv) {
-    let command;
-    try {
-        command = parseCommand(argv);
-    }
-    catch (cause) {
-        process.stderr.write(`usage: upstream-cli <subcommand> [options]\n`);
-        process.stderr.write(`error: ${oneLine(cause)}\n`);
-        return 2;
-    }
-    try {
-        await dispatch(command);
-        return 0;
-    }
-    catch (cause) {
-        process.stderr.write(`error: ${oneLine(cause)}\n`);
-        return cause instanceof UsageError ? 2 : 1;
-    }
-}
-const entry = process.argv[1];
-if (entry !== undefined && import.meta.filename === realpathSync(entry)) {
-    process.exitCode = await runUpstreamCli(process.argv.slice(2));
-}

package/dist/validate-generated-plugin-cli.js

@@ -1,118 +0,0 @@
-import { realpathSync } from "node:fs";
-import { oneLine, parseFlags, UsageError } from "./cli-arguments.js";
-import { validateGeneratedPlugin, } from "./harnesses/codex/generated-plugin.js";
-const FLAGS = [
-    "plugin-root",
-    "source",
-    "requested-ref",
-    "resolved-ref",
-    "commit",
-    "manifest-version",
-    "manifest-source",
-    "upstream-manifest-version",
-];
-// `argparse` accepts a lone `-` and a bare negative number as a split value;
-// every other dash-leading split value is treated as an option and rejected.
-// CPython's `_negative_number_matcher` is `^-\d+$|^-\d*\.\d+$`, and `re` `\d` on
-// a `str` pattern matches every character in Unicode category Nd. JavaScript
-// `\d` is `[0-9]` whatever the flags, so `\p{Nd}` plus `u` is what mirrors it.
-// The `\.` stays a literal ASCII period: `argparse` accepts no other separator.
-const NEGATIVE_NUMBER_RE = /^-\p{Nd}+$|^-\p{Nd}*\.\p{Nd}+$/u;
-/** True when `argparse` would accept `value` in `--flag value` form. */
-export function isAcceptedSplitValue(value) {
-    if (!value.startsWith("-"))
-        return true;
-    return value === "-" || NEGATIVE_NUMBER_RE.test(value);
-}
-/**
- * Node replaces an undecodable argv byte with U+FFFD before any JavaScript
- * runs, so the original byte is unrecoverable. Rejecting at the boundary is
- * the only portable fail-closed option.
- */
-export function hasReplacementCharacter(value) {
-    return value.includes("�");
-}
-/** Pre-scan argv for split-form values the dash rule rejects. */
-function findRejectedSplitFlag(argv) {
-    for (let index = 0; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (!token.startsWith("--") || token.includes("="))
-            continue;
-        const value = argv[index + 1];
-        if (value === undefined)
-            continue;
-        if (!isAcceptedSplitValue(value))
-            return token;
-        index += 1;
-    }
-    return undefined;
-}
-function parseOptions(argv) {
-    const rejected = findRejectedSplitFlag(argv);
-    if (rejected !== undefined) {
-        throw new UsageError(`option ${rejected} rejects a dash-leading value`);
-    }
-    const flags = parseFlags(argv, FLAGS);
-    if (hasReplacementCharacter(flags["plugin-root"])) {
-        throw new UsageError("option --plugin-root contains an undecodable character");
-    }
-    const manifestSource = flags["manifest-source"];
-    if (manifestSource !== "upstream" && manifestSource !== "fallback") {
-        throw new UsageError("option --manifest-source must be `upstream` or `fallback`");
-    }
-    return {
-        pluginRoot: flags["plugin-root"],
-        source: flags.source,
-        requestedRef: flags["requested-ref"],
-        resolvedRef: flags["resolved-ref"],
-        commit: flags.commit,
-        manifestVersion: flags["manifest-version"],
-        manifestSource,
-        upstreamManifestVersion: flags["upstream-manifest-version"],
-    };
-}
-export async function runValidateGeneratedPluginCli(argv) {
-    let options;
-    try {
-        options = parseOptions(argv);
-    }
-    catch (cause) {
-        process.stderr.write("usage: validate-generated-plugin-cli --plugin-root <path> --source <url> " +
-            "--requested-ref <ref> --resolved-ref <ref> --commit <sha> " +
-            "--manifest-version <version> --manifest-source <upstream|fallback> " +
-            "--upstream-manifest-version <version>\n");
-        process.stderr.write(`error: ${oneLine(cause)}\n`);
-        return 2;
-    }
-    let errors;
-    try {
-        errors = await validateGeneratedPlugin(options);
-    }
-    catch (cause) {
-        // A rejection must never escape as a traceback-shaped crash.
-        process.stderr.write(`error: ${oneLine(cause)}\n`);
-        return 2;
-    }
-    if (errors.length > 0) {
-        process.stderr.write("Generated plugin validation failed:\n");
-        for (const error of errors)
-            process.stderr.write(`- ${error}\n`);
-        return 1;
-    }
-    process.stdout.write(`generated plugin validation passed: ${options.pluginRoot}\n`);
-    return 0;
-}
-const entry = process.argv[1];
-let entryRealpath;
-if (entry !== undefined) {
-    try {
-        entryRealpath = realpathSync(entry);
-    }
-    catch {
-        // An unresolvable argv[1] means "not the entry point", not a crash.
-        entryRealpath = undefined;
-    }
-}
-if (entryRealpath !== undefined && import.meta.filename === entryRealpath) {
-    process.exitCode = await runValidateGeneratedPluginCli(process.argv.slice(2));
-}