@sweny-ai/core 0.1.66 → 0.1.68

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

@@ -2,8 +2,7 @@ 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";
+import { runWorkflowDiagram, resolveUseBlock } from "../diagram.js";
 const sampleWorkflow = {
     id: "sample",
     name: "Sample",
@@ -32,6 +31,42 @@ function captureStream() {
         },
     };
 }
+describe("resolveUseBlock", () => {
+    // Centralized behavior test — the renderer is a tiny switch around this
+    // so keeping the rules here as one table makes the policy easy to audit.
+    it("returns false by default (stdout, no -o, no flags)", () => {
+        expect(resolveUseBlock({})).toBe(false);
+    });
+    it("returns true when --block is explicit", () => {
+        expect(resolveUseBlock({ block: true })).toBe(true);
+    });
+    it("returns false when --no-block is explicit, even for .md", () => {
+        expect(resolveUseBlock({ block: false, output: "diagram.md" })).toBe(false);
+    });
+    it("infers true for .md output", () => {
+        expect(resolveUseBlock({ output: "diagram.md" })).toBe(true);
+    });
+    it("infers true for .markdown output", () => {
+        expect(resolveUseBlock({ output: "diagram.markdown" })).toBe(true);
+    });
+    it("infers false for .mmd output", () => {
+        expect(resolveUseBlock({ output: "diagram.mmd" })).toBe(false);
+    });
+    it("infers false for .mermaid output", () => {
+        expect(resolveUseBlock({ output: "diagram.mermaid" })).toBe(false);
+    });
+    it("infers false for any other extension (.txt, no ext, etc.)", () => {
+        expect(resolveUseBlock({ output: "diagram.txt" })).toBe(false);
+        expect(resolveUseBlock({ output: "diagram" })).toBe(false);
+    });
+    it("is case-insensitive on extension", () => {
+        expect(resolveUseBlock({ output: "Diagram.MD" })).toBe(true);
+        expect(resolveUseBlock({ output: "Diagram.MMD" })).toBe(false);
+    });
+    it("lets explicit --block override .mmd extension", () => {
+        expect(resolveUseBlock({ block: true, output: "diagram.mmd" })).toBe(true);
+    });
+});
 describe("runWorkflowDiagram", () => {
     let tmpdir;
     const loadWorkflowFile = vi.fn((_f) => sampleWorkflow);
@@ -44,55 +79,78 @@ describe("runWorkflowDiagram", () => {
     afterEach(() => {
         fs.rmSync(tmpdir, { recursive: true, force: true });
     });
-    describe("stdout", () => {
-        it("writes a fenced mermaid block to stdout by default", () => {
+    describe("stdout — default behavior", () => {
+        it("writes RAW mermaid (no fence, no title frontmatter) by default", () => {
+            // This is the Mermaid-CLI / Live-Editor-compatible output. No ```,
+            // no `---\ntitle: …\n---` — just `graph TB` and the nodes.
             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(stdout.text).not.toMatch(/```mermaid/);
+            expect(stdout.text).not.toMatch(/^---\ntitle:/);
+            expect(stdout.text).toMatch(/^graph TB/);
             expect(exit).not.toHaveBeenCalled();
         });
-        it("writes raw mermaid when --no-block is explicit", () => {
+        it("wraps in a ```mermaid fence when --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/);
+            runWorkflowDiagram("any.yml", { block: true }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(stdout.text).toMatch(/^```mermaid\n/);
+            expect(stdout.text).toMatch(/\n```\n$/);
         });
         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", () => {
+        it("emits --title as frontmatter only when explicitly set", () => {
             const stdout = captureStream();
             runWorkflowDiagram("any.yml", { title: "Custom Title" }, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
-            expect(stdout.text).toContain("Custom Title");
+            expect(stdout.text).toMatch(/^---\ntitle: Custom Title\n---\n/);
+            expect(stdout.text).toContain("graph TB");
+        });
+        it("does NOT default title to the workflow name", () => {
+            // Regression guard: previously we auto-filled `title` from workflow.name,
+            // which broke mmdc / mermaid-live because they don't accept title frontmatter.
+            const stdout = captureStream();
+            runWorkflowDiagram("any.yml", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
+            expect(stdout.text).not.toMatch(/title:/);
+            expect(stdout.text).not.toContain("Sample"); // workflow.name
         });
     });
     describe("-o / --output file", () => {
-        it("writes raw mermaid to .mmd by default (no fence)", () => {
+        it("writes raw mermaid to .mmd (default)", () => {
             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(contents).not.toMatch(/title:/);
+            expect(contents).toMatch(/^graph TB/);
             expect(stderr.text).toMatch(/✓ Wrote diagram to/);
         });
-        it("writes fenced markdown to .md by default", () => {
+        it("writes raw mermaid to .mermaid (Mermaid CLI's canonical extension)", () => {
+            const out = path.join(tmpdir, "diagram.mermaid");
+            runWorkflowDiagram("any.yml", { output: out }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
+            const contents = fs.readFileSync(out, "utf8");
+            expect(contents).not.toMatch(/```mermaid/);
+            expect(contents).toMatch(/^graph TB/);
+        });
+        it("writes fenced markdown to .md", () => {
             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", () => {
+        it("writes raw mermaid for unknown extensions (no longer falls back to fenced)", () => {
+            // Behavior change: previously .txt and friends got fenced as the
+            // "safe default". Now raw mermaid is the safe default because that's
+            // what every renderer actually accepts.
             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/);
+            expect(contents).not.toMatch(/```mermaid/);
+            expect(contents).toMatch(/graph TB/);
         });
         it("creates parent directories as needed (-o nested/subdir/file.mmd)", () => {
             const out = path.join(tmpdir, "a", "b", "c", "diagram.mmd");
@@ -107,51 +165,15 @@ describe("runWorkflowDiagram", () => {
             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)", () => {
+    describe("explicit --block / --no-block override extension inference", () => {
+        it("explicit --block wins over .mmd (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,
-            });
+            runWorkflowDiagram("any.yml", { output: out, block: true }, { loadWorkflowFile, 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)", () => {
+        it("explicit --no-block wins over .md (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,
-            });
+            runWorkflowDiagram("any.yml", { output: out, block: false }, { loadWorkflowFile, stdout: captureStream().stream, stderr: captureStream().stream, exit });
             expect(fs.readFileSync(out, "utf8")).not.toMatch(/```mermaid/);
         });
     });
@@ -160,7 +182,9 @@ describe("runWorkflowDiagram", () => {
             const stdout = captureStream();
             runWorkflowDiagram("triage", {}, { loadWorkflowFile, stdout: stdout.stream, stderr: captureStream().stream, exit });
             expect(loadWorkflowFile).not.toHaveBeenCalled();
-            expect(stdout.text).toMatch(/```mermaid/);
+            expect(stdout.text).toMatch(/graph TB/);
+            // Confirm built-in renders raw by default too.
+            expect(stdout.text).not.toMatch(/```mermaid/);
         });
         it("resolves 'implement' without calling loadWorkflowFile", () => {
             const stdout = captureStream();

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

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

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

@@ -0,0 +1,317 @@
+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);
+    });
+    it("downgrades when --force is set against a local-dev build ahead of the registry", async () => {
+        const { deps, runInstall, exit } = makeDeps({
+            currentVersion: "0.2.0",
+            fetchLatestVersion: vi.fn(async () => "0.1.66"),
+        });
+        await runUpgrade({ force: true }, deps);
+        // --force explicitly overrides the "ahead" short-circuit — this is how
+        // someone pins back to the published train from a stale local build.
+        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 {};