@sweny-ai/core 0.1.65 → 0.1.67

package/dist/cli/__tests__/diagram.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/__tests__/diagram.test.js

@@ -0,0 +1,201 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Command } from "commander";
+import { runWorkflowDiagram } from "../diagram.js";
+const sampleWorkflow = {
+    id: "sample",
+    name: "Sample",
+    description: "sample",
+    entry: "a",
+    nodes: {
+        a: { name: "A", instruction: "do a", skills: [] },
+        b: { name: "B", instruction: "do b", skills: [] },
+    },
+    edges: [{ from: "a", to: "b" }],
+};
+// Minimal in-memory writable stream that accumulates text. Avoids the
+// overhead of real Node streams for these pure-output assertions.
+function captureStream() {
+    const chunks = [];
+    const stream = {
+        write: (chunk) => {
+            chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return true;
+        },
+    };
+    return {
+        stream,
+        get text() {
+            return chunks.join("");
+        },
+    };
+}
+describe("runWorkflowDiagram", () => {
+    let tmpdir;
+    const loadWorkflowFile = vi.fn((_f) => sampleWorkflow);
+    const exit = vi.fn();
+    beforeEach(() => {
+        tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-diagram-test-"));
+        loadWorkflowFile.mockClear();
+        exit.mockClear();
+    });
+    afterEach(() => {
+        fs.rmSync(tmpdir, { recursive: true, force: true });
+    });
+    describe("stdout", () => {
+        it("writes a fenced mermaid block to stdout by default", () => {
+            const stdout = captureStream();
+            const stderr = captureStream();
+            runWorkflowDiagram("any.yml", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: stderr.stream, exit });
+            expect(stdout.text).toMatch(/^```mermaid\n/);
+            expect(stdout.text).toMatch(/\n```\n$/);
+            expect(exit).not.toHaveBeenCalled();
+        });
+        it("writes raw mermaid when --no-block is explicit", () => {
+            const stdout = captureStream();
+            const stderr = captureStream();
+            runWorkflowDiagram("any.yml", { block: false }, { loadWorkflowFile, stdout: stdout.stream, stderr: stderr.stream, exit });
+            expect(stdout.text).not.toMatch(/```mermaid/);
+            expect(stdout.text).toMatch(/graph TB/);
+        });
+        it("honors --direction LR", () => {
+            const stdout = captureStream();
+            runWorkflowDiagram("any.yml", { direction: "LR" }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(stdout.text).toMatch(/graph LR/);
+        });
+        it("honors --title override", () => {
+            const stdout = captureStream();
+            runWorkflowDiagram("any.yml", { title: "Custom Title" }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(stdout.text).toContain("Custom Title");
+        });
+    });
+    describe("-o / --output file", () => {
+        it("writes raw mermaid to .mmd by default (no fence)", () => {
+            const out = path.join(tmpdir, "diagram.mmd");
+            const stderr = captureStream();
+            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: stderr.stream, exit });
+            const contents = fs.readFileSync(out, "utf8");
+            expect(contents).not.toMatch(/```mermaid/);
+            expect(contents).toMatch(/graph TB/);
+            expect(stderr.text).toMatch(/✓ Wrote diagram to/);
+        });
+        it("writes fenced markdown to .md by default", () => {
+            const out = path.join(tmpdir, "diagram.md");
+            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
+            const contents = fs.readFileSync(out, "utf8");
+            expect(contents).toMatch(/^```mermaid\n/);
+            expect(contents).toMatch(/\n```\n$/);
+        });
+        it("falls back to fenced default for unknown extensions", () => {
+            const out = path.join(tmpdir, "diagram.txt");
+            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
+            const contents = fs.readFileSync(out, "utf8");
+            expect(contents).toMatch(/```mermaid/);
+        });
+        it("creates parent directories as needed (-o nested/subdir/file.mmd)", () => {
+            const out = path.join(tmpdir, "a", "b", "c", "diagram.mmd");
+            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
+            expect(fs.existsSync(out)).toBe(true);
+            expect(fs.readFileSync(out, "utf8")).toMatch(/graph TB/);
+        });
+        it("does not write anything to stdout when -o is set", () => {
+            const stdout = captureStream();
+            const out = path.join(tmpdir, "diagram.mmd");
+            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(stdout.text).toBe("");
+        });
+    });
+    describe("explicit --block / --no-block precedence over extension inference", () => {
+        function cmdWithBlock(block, explicit) {
+            const cmd = new Command();
+            cmd.option("--block", "fenced", true);
+            cmd.option("--no-block", "raw");
+            if (explicit) {
+                // Simulate user typing `--block` or `--no-block` on the CLI — commander
+                // marks the source as "cli" when the flag is seen in argv.
+                cmd.setOptionValueWithSource("block", block, "cli");
+            }
+            return cmd;
+        }
+        it("explicit --block wins over .mmd extension (writes fenced to .mmd)", () => {
+            const out = path.join(tmpdir, "diagram.mmd");
+            runWorkflowDiagram("any.yml", { output: out, block: true }, {
+                loadWorkflowFile,
+                command: cmdWithBlock(true, true),
+                stdout: captureStream().stream,
+                stderr: captureStream().stream,
+                exit,
+            });
+            expect(fs.readFileSync(out, "utf8")).toMatch(/```mermaid/);
+        });
+        it("explicit --no-block wins over .md extension (writes raw to .md)", () => {
+            const out = path.join(tmpdir, "diagram.md");
+            runWorkflowDiagram("any.yml", { output: out, block: false }, {
+                loadWorkflowFile,
+                command: cmdWithBlock(false, true),
+                stdout: captureStream().stream,
+                stderr: captureStream().stream,
+                exit,
+            });
+            expect(fs.readFileSync(out, "utf8")).not.toMatch(/```mermaid/);
+        });
+        it("default --block source does not suppress .mmd extension inference", () => {
+            // Commander always sets `block: true` via the declared default, but its
+            // source is "default" — our inference should still kick in for .mmd.
+            const out = path.join(tmpdir, "diagram.mmd");
+            runWorkflowDiagram("any.yml", { output: out, block: true }, {
+                loadWorkflowFile,
+                command: cmdWithBlock(true, false), // not explicit
+                stdout: captureStream().stream,
+                stderr: captureStream().stream,
+                exit,
+            });
+            expect(fs.readFileSync(out, "utf8")).not.toMatch(/```mermaid/);
+        });
+    });
+    describe("builtin workflow names", () => {
+        it("resolves 'triage' without calling loadWorkflowFile", () => {
+            const stdout = captureStream();
+            runWorkflowDiagram("triage", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(loadWorkflowFile).not.toHaveBeenCalled();
+            expect(stdout.text).toMatch(/```mermaid/);
+        });
+        it("resolves 'implement' without calling loadWorkflowFile", () => {
+            const stdout = captureStream();
+            runWorkflowDiagram("implement", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(loadWorkflowFile).not.toHaveBeenCalled();
+            expect(stdout.text.length).toBeGreaterThan(0);
+        });
+        it("resolves 'seed-content' without calling loadWorkflowFile", () => {
+            const stdout = captureStream();
+            runWorkflowDiagram("seed-content", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(loadWorkflowFile).not.toHaveBeenCalled();
+            expect(stdout.text.length).toBeGreaterThan(0);
+        });
+    });
+    describe("error handling", () => {
+        it("exits with code 1 and prints an error when loadWorkflowFile throws", () => {
+            const stderr = captureStream();
+            const throwingLoader = vi.fn(() => {
+                throw new Error("file not found: missing.yml");
+            });
+            runWorkflowDiagram("missing.yml", {}, { loadWorkflowFile: throwingLoader, stdout: captureStream().stream, stderr: stderr.stream, exit });
+            expect(exit).toHaveBeenCalledWith(1);
+            expect(stderr.text).toMatch(/file not found/);
+        });
+        it("exits with code 1 when the output path is unwritable", () => {
+            // Point -o at a path where the parent is a file (not a dir). mkdirSync
+            // with recursive:true will throw EEXIST, writeFileSync then fails. We
+            // specifically want to assert the error path doesn't crash the process.
+            const blocker = path.join(tmpdir, "blocker");
+            fs.writeFileSync(blocker, "im-a-file");
+            const out = path.join(blocker, "diagram.mmd");
+            const stderr = captureStream();
+            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: stderr.stream, exit });
+            expect(exit).toHaveBeenCalledWith(1);
+            expect(stderr.text).toMatch(/Error:/);
+        });
+    });
+});

package/dist/cli/__tests__/upgrade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/__tests__/upgrade.test.js

@@ -0,0 +1,306 @@
+import { describe, it, expect, vi } from "vitest";
+import { compareVersions, detectPackageManager, resolveInstallRoot, installCommandFor, runUpgrade, fetchLatestFromNpm, } from "../upgrade.js";
+// In-memory writable stream for pure assertions on output. Cheaper and
+// simpler than a real Node stream and identical to the helper used by
+// diagram.test.ts — keeps test utilities consistent across the cli/ dir.
+function captureStream() {
+    const chunks = [];
+    const stream = {
+        write: (chunk) => {
+            chunks.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+            return true;
+        },
+    };
+    return {
+        stream,
+        get text() {
+            return chunks.join("");
+        },
+    };
+}
+/**
+ * Build an UpgradeDeps object with sensible defaults. Tests override only
+ * the bits relevant to the behavior they're asserting — keeps each case
+ * focused on its condition rather than plumbing.
+ */
+function makeDeps(over = {}) {
+    const stdout = captureStream();
+    const stderr = captureStream();
+    const exit = vi.fn();
+    const runInstall = vi.fn(() => 0);
+    const deps = {
+        currentVersion: "0.1.65",
+        installPath: "/Users/x/.nvm/versions/node/v22/lib/node_modules/@sweny-ai/core/dist/cli/main.js",
+        fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        runInstall,
+        canWrite: () => true,
+        stdout: stdout.stream,
+        stderr: stderr.stream,
+        exit,
+        ...over,
+    };
+    return { deps, stdout, stderr, exit, runInstall };
+}
+describe("compareVersions", () => {
+    it("ranks by numeric core segments", () => {
+        expect(compareVersions("0.1.10", "0.1.9")).toBeGreaterThan(0);
+        expect(compareVersions("0.1.9", "0.1.10")).toBeLessThan(0);
+        expect(compareVersions("1.0.0", "0.9.999")).toBeGreaterThan(0);
+        expect(compareVersions("0.1.65", "0.1.65")).toBe(0);
+    });
+    it("handles missing segments as zero", () => {
+        expect(compareVersions("1", "1.0.0")).toBe(0);
+        expect(compareVersions("1.0", "1.0.1")).toBeLessThan(0);
+    });
+    it("ranks pre-releases below their release", () => {
+        expect(compareVersions("1.0.0-alpha.1", "1.0.0")).toBeLessThan(0);
+        expect(compareVersions("1.0.0", "1.0.0-beta.3")).toBeGreaterThan(0);
+        expect(compareVersions("1.0.0-alpha", "1.0.0-beta")).toBeLessThan(0);
+    });
+    it("treats non-numeric core segments as zero (defensive)", () => {
+        // Malformed numeric segments shouldn't throw or return NaN — they
+        // collapse to 0 so the comparison still returns a deterministic ordering.
+        expect(compareVersions("1.x.0", "1.0.0")).toBe(0);
+        expect(compareVersions("1.0.y", "1.0.0")).toBe(0);
+    });
+});
+describe("detectPackageManager", () => {
+    it("detects npm from nvm-style layout", () => {
+        expect(detectPackageManager("/Users/x/.nvm/versions/node/v22.22.0/lib/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("npm");
+    });
+    it("detects npm from fnm / asdf / vanilla Node paths", () => {
+        expect(detectPackageManager("/usr/lib/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("npm");
+        expect(detectPackageManager("/home/x/.fnm/node-versions/v22/installation/lib/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("npm");
+    });
+    it("detects pnpm global installs", () => {
+        expect(detectPackageManager("/Users/x/.local/share/pnpm/global/5/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("pnpm");
+        expect(detectPackageManager("/Users/x/Library/pnpm-global/5/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("pnpm");
+    });
+    it("detects homebrew", () => {
+        expect(detectPackageManager("/opt/homebrew/Cellar/sweny/0.1.65/libexec/bin/sweny")).toBe("brew");
+        expect(detectPackageManager("/usr/local/Cellar/sweny/0.1.65/libexec/bin/sweny")).toBe("brew");
+    });
+    it("detects volta-managed installs", () => {
+        expect(detectPackageManager("/Users/x/.volta/tools/image/packages/@sweny-ai/core/bin/sweny")).toBe("volta");
+    });
+    it("detects bun global installs", () => {
+        expect(detectPackageManager("/Users/x/.bun/install/global/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("bun");
+    });
+    it("detects yarn global", () => {
+        expect(detectPackageManager("/Users/x/.yarn/global/node_modules/@sweny-ai/core/dist/cli/main.js")).toBe("yarn");
+    });
+    it("normalizes Windows paths (forward-slash rules)", () => {
+        const win = "C:\\Users\\x\\AppData\\Roaming\\npm\\node_modules\\@sweny-ai\\core\\dist\\cli\\main.js";
+        expect(detectPackageManager(win)).toBe("npm");
+    });
+    it("returns 'unknown' for paths that don't look like a package-manager install", () => {
+        expect(detectPackageManager("/tmp/some-random-path/main.js")).toBe("unknown");
+    });
+});
+describe("resolveInstallRoot", () => {
+    it("returns the prefix above node_modules for a typical npm layout", () => {
+        const p = "/Users/x/.nvm/versions/node/v22/lib/node_modules/@sweny-ai/core/dist/cli/main.js";
+        expect(resolveInstallRoot(p)).toBe("/Users/x/.nvm/versions/node/v22/lib");
+    });
+    it("returns null when @sweny-ai is not in the parent chain", () => {
+        expect(resolveInstallRoot("/tmp/random/main.js")).toBeNull();
+    });
+});
+describe("installCommandFor", () => {
+    it("emits the correct CLI invocation per package manager", () => {
+        expect(installCommandFor("npm", "latest")).toEqual({
+            cmd: "npm",
+            args: ["install", "-g", "@sweny-ai/core@latest"],
+        });
+        expect(installCommandFor("pnpm", "latest")).toEqual({ cmd: "pnpm", args: ["add", "-g", "@sweny-ai/core@latest"] });
+        expect(installCommandFor("yarn", "latest")).toEqual({
+            cmd: "yarn",
+            args: ["global", "add", "@sweny-ai/core@latest"],
+        });
+        expect(installCommandFor("bun", "latest")).toEqual({ cmd: "bun", args: ["add", "-g", "@sweny-ai/core@latest"] });
+        expect(installCommandFor("volta", "latest")).toEqual({ cmd: "volta", args: ["install", "@sweny-ai/core@latest"] });
+    });
+    it("passes through non-default tags", () => {
+        expect(installCommandFor("npm", "beta")).toEqual({ cmd: "npm", args: ["install", "-g", "@sweny-ai/core@beta"] });
+    });
+    it("returns null for brew / unknown (can't drive automatically)", () => {
+        expect(installCommandFor("brew", "latest")).toBeNull();
+        expect(installCommandFor("unknown", "latest")).toBeNull();
+    });
+});
+describe("runUpgrade — no-op paths", () => {
+    it("reports already-latest and exits 0", async () => {
+        const { deps, stdout, exit, runInstall } = makeDeps({
+            currentVersion: "0.1.66",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({}, deps);
+        expect(stdout.text).toMatch(/already the latest/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("reports when running ahead of the registry (local build) and exits 0", async () => {
+        const { deps, stdout, exit, runInstall } = makeDeps({
+            currentVersion: "0.2.0",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({}, deps);
+        expect(stdout.text).toMatch(/newer than the published/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("installs anyway when --force is set even if already latest", async () => {
+        const { deps, runInstall, exit } = makeDeps({
+            currentVersion: "0.1.66",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({ force: true }, deps);
+        expect(runInstall).toHaveBeenCalledWith("npm", ["install", "-g", "@sweny-ai/core@latest"]);
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+});
+describe("runUpgrade — install dispatch", () => {
+    it("invokes the detected package manager and exits 0 on success", async () => {
+        const { deps, stdout, runInstall, exit } = makeDeps();
+        await runUpgrade({}, deps);
+        expect(runInstall).toHaveBeenCalledWith("npm", ["install", "-g", "@sweny-ai/core@latest"]);
+        expect(stdout.text).toMatch(/Upgrading sweny 0\.1\.65 → 0\.1\.66/);
+        expect(stdout.text).toMatch(/✓ Upgraded sweny to 0\.1\.66/);
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("uses pnpm when the install path is a pnpm global root", async () => {
+        const { deps, runInstall } = makeDeps({
+            installPath: "/Users/x/.local/share/pnpm/global/5/node_modules/@sweny-ai/core/dist/cli/main.js",
+        });
+        await runUpgrade({}, deps);
+        expect(runInstall).toHaveBeenCalledWith("pnpm", ["add", "-g", "@sweny-ai/core@latest"]);
+    });
+    it("forwards a non-default --tag to the install command", async () => {
+        const { deps, runInstall } = makeDeps({
+            fetchLatestVersion: vi.fn(async (tag) => (tag === "beta" ? "0.2.0-beta.1" : "0.1.66")),
+        });
+        await runUpgrade({ tag: "beta" }, deps);
+        expect(runInstall).toHaveBeenCalledWith("npm", ["install", "-g", "@sweny-ai/core@beta"]);
+    });
+    it("propagates a non-zero install exit code", async () => {
+        const { deps, stderr, exit } = makeDeps({
+            runInstall: vi.fn(() => 42),
+        });
+        await runUpgrade({}, deps);
+        expect(stderr.text).toMatch(/exited with code 42/);
+        expect(exit).toHaveBeenCalledWith(42);
+    });
+});
+describe("runUpgrade — permissions + platform edges", () => {
+    it("prints sudo hint and exits 1 when the install prefix isn't writable", async () => {
+        const { deps, stderr, exit, runInstall } = makeDeps({
+            canWrite: () => false,
+        });
+        await runUpgrade({}, deps);
+        expect(stderr.text).toMatch(/no write permission/);
+        expect(stderr.text).toMatch(/sudo npm install -g @sweny-ai\/core@latest/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(1);
+    });
+    it("defers to brew for homebrew installs (doesn't try to npm-install over it)", async () => {
+        const { deps, stdout, stderr, exit, runInstall } = makeDeps({
+            installPath: "/opt/homebrew/Cellar/sweny/0.1.65/libexec/bin/sweny",
+        });
+        await runUpgrade({}, deps);
+        expect(stdout.text).toMatch(/0\.1\.66 is available/);
+        expect(stderr.text).toMatch(/brew upgrade sweny/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(1);
+    });
+    it("prints a manual-install hint for unknown layouts", async () => {
+        const { deps, stdout, stderr, exit, runInstall } = makeDeps({
+            installPath: "/tmp/some-random-path/main.js",
+        });
+        await runUpgrade({}, deps);
+        expect(stdout.text).toMatch(/0\.1\.66 is available/);
+        expect(stderr.text).toMatch(/npm install -g @sweny-ai\/core@latest/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(1);
+    });
+});
+describe("runUpgrade — --check (dry run)", () => {
+    it("reports the command without running it", async () => {
+        const { deps, stdout, runInstall, exit } = makeDeps();
+        await runUpgrade({ check: true }, deps);
+        expect(stdout.text).toMatch(/0\.1\.66 is available/);
+        expect(stdout.text).toMatch(/npm install -g @sweny-ai\/core@latest/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+    it("still short-circuits on already-latest under --check", async () => {
+        const { deps, stdout, exit } = makeDeps({
+            currentVersion: "0.1.66",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({ check: true }, deps);
+        expect(stdout.text).toMatch(/already the latest/);
+        expect(exit).toHaveBeenCalledWith(0);
+    });
+});
+describe("runUpgrade — error handling", () => {
+    it("exits 1 with a helpful message when the registry fetch fails", async () => {
+        const { deps, stderr, exit, runInstall } = makeDeps({
+            fetchLatestVersion: vi.fn(async () => {
+                throw new Error("ENETDOWN");
+            }),
+        });
+        await runUpgrade({}, deps);
+        expect(stderr.text).toMatch(/couldn't reach the npm registry/);
+        expect(stderr.text).toMatch(/ENETDOWN/);
+        expect(runInstall).not.toHaveBeenCalled();
+        expect(exit).toHaveBeenCalledWith(1);
+    });
+});
+describe("fetchLatestFromNpm", () => {
+    it("parses the dist-tag JSON and returns the version", async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockImplementation(async () => new Response(JSON.stringify({ version: "9.9.9" }), { status: 200 }));
+        try {
+            expect(await fetchLatestFromNpm("latest")).toBe("9.9.9");
+            expect(fetchSpy).toHaveBeenCalledWith("https://registry.npmjs.org/@sweny-ai/core/latest", expect.objectContaining({ headers: expect.objectContaining({ accept: "application/json" }) }));
+        }
+        finally {
+            fetchSpy.mockRestore();
+        }
+    });
+    it("throws a clear error when the registry returns non-2xx", async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockImplementation(async () => new Response("not found", { status: 404, statusText: "Not Found" }));
+        try {
+            await expect(fetchLatestFromNpm("bogus-tag")).rejects.toThrow(/404/);
+        }
+        finally {
+            fetchSpy.mockRestore();
+        }
+    });
+    it("throws when the registry payload is missing `version`", async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockImplementation(async () => new Response(JSON.stringify({}), { status: 200 }));
+        try {
+            await expect(fetchLatestFromNpm("latest")).rejects.toThrow(/version/);
+        }
+        finally {
+            fetchSpy.mockRestore();
+        }
+    });
+    it("URL-encodes the tag so custom tags don't break the path", async () => {
+        const fetchSpy = vi
+            .spyOn(globalThis, "fetch")
+            .mockImplementation(async () => new Response(JSON.stringify({ version: "1.0.0" }), { status: 200 }));
+        try {
+            await fetchLatestFromNpm("next beta");
+            expect(fetchSpy).toHaveBeenCalledWith("https://registry.npmjs.org/@sweny-ai/core/next%20beta", expect.anything());
+        }
+        finally {
+            fetchSpy.mockRestore();
+        }
+    });
+});

package/dist/cli/__tests__/version-check.test.d.ts

@@ -0,0 +1 @@
+export {};