akm-cli 0.7.0-rc1 → 0.7.1

package/dist/tests/search-include-proposed-cli.test.js

@@ -1,118 +0,0 @@
-/**
- * `akm search --include-proposed` CLI integration test (#284 GAP-HIGH 9).
- *
- * Spawns the real CLI against an indexed stash that contains both a
- * `quality: stable` and a `quality: proposed` skill, and asserts that:
- *   - default search excludes the proposed entry,
- *   - `--include-proposed` retains it in the hits list.
- */
-import { afterEach, describe, expect, test } from "bun:test";
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { saveConfig } from "../src/core/config";
-import { akmIndex } from "../src/indexer/indexer";
-const tempDirs = [];
-const savedEnv = {
-    AKM_STASH_DIR: process.env.AKM_STASH_DIR,
-    XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
-    XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
-};
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function writeFile(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-}
-const CLI = path.join(__dirname, "..", "src", "cli.ts");
-function runCli(args, stashDir) {
-    const result = spawnSync("bun", [CLI, ...args], {
-        encoding: "utf8",
-        timeout: 30_000,
-        env: {
-            ...process.env,
-            AKM_STASH_DIR: stashDir,
-            XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
-            XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
-        },
-    });
-    return {
-        stdout: result.stdout ?? "",
-        stderr: result.stderr ?? "",
-        status: result.status ?? -1,
-    };
-}
-afterEach(() => {
-    if (savedEnv.AKM_STASH_DIR === undefined)
-        delete process.env.AKM_STASH_DIR;
-    else
-        process.env.AKM_STASH_DIR = savedEnv.AKM_STASH_DIR;
-    if (savedEnv.XDG_CACHE_HOME === undefined)
-        delete process.env.XDG_CACHE_HOME;
-    else
-        process.env.XDG_CACHE_HOME = savedEnv.XDG_CACHE_HOME;
-    if (savedEnv.XDG_CONFIG_HOME === undefined)
-        delete process.env.XDG_CONFIG_HOME;
-    else
-        process.env.XDG_CONFIG_HOME = savedEnv.XDG_CONFIG_HOME;
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-describe("akm search --include-proposed (CLI)", () => {
-    test("default excludes proposed entries; --include-proposed keeps them", async () => {
-        const stash = makeTempDir("akm-search-proposed-stash-");
-        process.env.XDG_CACHE_HOME = makeTempDir("akm-search-proposed-cache-");
-        process.env.XDG_CONFIG_HOME = makeTempDir("akm-search-proposed-config-");
-        for (const sub of ["skills", "commands", "agents", "knowledge", "scripts"]) {
-            fs.mkdirSync(path.join(stash, sub), { recursive: true });
-        }
-        // Curated entry
-        writeFile(path.join(stash, "skills", "stable-deploy", "SKILL.md"), "---\ndescription: deploy widgets uniformly\n---\n# Stable deploy\n");
-        writeFile(path.join(stash, "skills", "stable-deploy", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "stable-deploy",
-                    type: "skill",
-                    description: "deploy widgets uniformly",
-                    tags: ["deploy"],
-                    filename: "SKILL.md",
-                    quality: "curated",
-                },
-            ],
-        }));
-        // Proposed entry
-        writeFile(path.join(stash, "skills", "proposed-deploy", "SKILL.md"), "---\ndescription: deploy widgets experimentally\n---\n# Proposed deploy\n");
-        writeFile(path.join(stash, "skills", "proposed-deploy", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "proposed-deploy",
-                    type: "skill",
-                    description: "deploy widgets experimentally",
-                    tags: ["deploy"],
-                    filename: "SKILL.md",
-                    quality: "proposed",
-                },
-            ],
-        }));
-        process.env.AKM_STASH_DIR = stash;
-        saveConfig({ semanticSearchMode: "off" });
-        await akmIndex({ stashDir: stash, full: true });
-        const baseline = runCli(["search", "deploy", "--format=json"], stash);
-        expect(baseline.status).toBe(0);
-        const baselineJson = JSON.parse(baseline.stdout);
-        const baselineNames = baselineJson.hits.map((h) => h.name);
-        expect(baselineNames).toContain("stable-deploy");
-        expect(baselineNames).not.toContain("proposed-deploy");
-        const withProposed = runCli(["search", "deploy", "--include-proposed", "--format=json"], stash);
-        expect(withProposed.status).toBe(0);
-        const withProposedJson = JSON.parse(withProposed.stdout);
-        const withProposedNames = withProposedJson.hits.map((h) => h.name);
-        expect(withProposedNames).toContain("stable-deploy");
-        expect(withProposedNames).toContain("proposed-deploy");
-    });
-});

package/dist/tests/self-update.test.js

@@ -1,442 +0,0 @@
-import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
-import * as childProcess from "node:child_process";
-import { checkForUpdate, detectInstallMethod, getAkmBinaryName, getPackageManagerUpgradeCommand, performUpgrade, } from "../src/commands/self-update";
-// ── Fetch mocking helper ────────────────────────────────────────────────────
-let originalFetch;
-function mockFetch(handler) {
-    originalFetch = globalThis.fetch;
-    globalThis.fetch = (async (input) => {
-        const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
-        return handler(url);
-    });
-}
-afterEach(() => {
-    mock.restore();
-    if (originalFetch) {
-        globalThis.fetch = originalFetch;
-    }
-});
-function fakeRelease(tagName) {
-    return Response.json({ tag_name: tagName });
-}
-// ── detectInstallMethod ─────────────────────────────────────────────────────
-describe("detectInstallMethod", () => {
-    test("returns a valid install method when running via bun run (not compiled)", () => {
-        const method = detectInstallMethod();
-        // In test context we're running from source. May be "binary" if AKM_VERSION
-        // is defined (e.g. compiled test runner), otherwise "unknown" or a package-manager install.
-        expect(["unknown", "npm", "pnpm", "bun", "binary"]).toContain(method);
-    });
-    test("does not throw", () => {
-        expect(() => detectInstallMethod()).not.toThrow();
-    });
-    test("returns 'binary' when Bun.main starts with /$bunfs/", () => {
-        const signals = {
-            bunMain: "/$bunfs/root/src/cli.ts",
-            importMetaDir: "/some/path",
-            hasAkmVersion: false,
-        };
-        expect(detectInstallMethod(signals)).toBe("binary");
-    });
-    test("returns 'binary' when AKM_VERSION is defined (fallback)", () => {
-        const signals = {
-            bunMain: "/usr/local/bin/akm",
-            importMetaDir: "/some/path",
-            hasAkmVersion: true,
-        };
-        expect(detectInstallMethod(signals)).toBe("binary");
-    });
-    test("returns 'bun' for Bun global install path", () => {
-        const signals = {
-            bunMain: "/usr/local/bin/bun",
-            importMetaDir: "/home/user/.bun/install/global/node_modules/akm-cli/dist",
-            hasAkmVersion: false,
-        };
-        expect(detectInstallMethod(signals)).toBe("bun");
-    });
-    test("returns 'bun' for Windows-style Bun global install path", () => {
-        const signals = {
-            bunMain: "C:\\Program Files\\Bun\\bun.exe",
-            importMetaDir: "C:\\Users\\me\\.bun\\install\\global\\node_modules\\akm-cli\\dist",
-            hasAkmVersion: false,
-        };
-        expect(detectInstallMethod(signals)).toBe("bun");
-    });
-    test("returns 'pnpm' for pnpm global install path", () => {
-        const signals = {
-            bunMain: "/usr/local/bin/bun",
-            importMetaDir: "/home/user/.local/share/pnpm/global/5/node_modules/akm-cli/dist",
-            hasAkmVersion: false,
-        };
-        expect(detectInstallMethod(signals)).toBe("pnpm");
-    });
-    test("returns 'pnpm' for Windows-style pnpm global install path", () => {
-        const signals = {
-            bunMain: "C:\\Program Files\\Bun\\bun.exe",
-            importMetaDir: "C:\\Users\\me\\AppData\\Local\\pnpm\\global\\5\\node_modules\\akm-cli\\dist",
-            hasAkmVersion: false,
-        };
-        expect(detectInstallMethod(signals)).toBe("pnpm");
-    });
-    test("returns 'npm' when importMetaDir contains node_modules without bun/pnpm markers", () => {
-        const signals = {
-            bunMain: "/usr/local/bin/bun",
-            importMetaDir: "/usr/local/lib/node_modules/akm-cli/dist",
-            hasAkmVersion: false,
-        };
-        expect(detectInstallMethod(signals)).toBe("npm");
-    });
-    test("package-manager detection takes priority over binary signals", () => {
-        const signals = {
-            bunMain: "/$bunfs/root/src/cli.ts",
-            importMetaDir: "/some/node_modules/akm",
-            hasAkmVersion: true,
-        };
-        expect(detectInstallMethod(signals)).toBe("npm");
-    });
-    test("returns 'unknown' when no signals match", () => {
-        const signals = {
-            bunMain: undefined,
-            importMetaDir: "/some/path",
-            hasAkmVersion: false,
-        };
-        expect(detectInstallMethod(signals)).toBe("unknown");
-    });
-    test("returns 'unknown' when Bun is present but no binary indicators", () => {
-        const signals = {
-            bunMain: "/home/user/akm/src/cli.ts",
-            importMetaDir: "/home/user/akm/src",
-            hasAkmVersion: false,
-        };
-        expect(detectInstallMethod(signals)).toBe("unknown");
-    });
-});
-// ── getAkmBinaryName ────────────────────────────────────────────────────────
-describe("getAkmBinaryName", () => {
-    test("returns a string containing 'akm'", () => {
-        const name = getAkmBinaryName();
-        expect(name).toContain("akm");
-    });
-    test("returns platform-appropriate name for current platform", () => {
-        const name = getAkmBinaryName();
-        const platform = process.platform;
-        const arch = process.arch;
-        if (platform === "linux") {
-            expect(name).toStartWith("akm-linux-");
-        }
-        else if (platform === "darwin") {
-            expect(name).toStartWith("akm-darwin-");
-        }
-        else if (platform === "win32") {
-            expect(name).toStartWith("akm-windows-");
-            expect(name).toEndWith(".exe");
-        }
-        if (arch === "x64") {
-            expect(name).toContain("x64");
-        }
-        else if (arch === "arm64") {
-            expect(name).toContain("arm64");
-        }
-    });
-});
-// ── checkForUpdate (mocked fetch) ───────────────────────────────────────────
-describe("checkForUpdate", () => {
-    test("returns valid UpgradeCheckResponse", async () => {
-        mockFetch(() => fakeRelease("v0.0.14"));
-        const result = await checkForUpdate("0.0.13");
-        expect(result.currentVersion).toBe("0.0.13");
-        expect(result.latestVersion).toBe("0.0.14");
-        expect(result.updateAvailable).toBe(true);
-        expect(["binary", "bun", "npm", "pnpm", "unknown"]).toContain(result.installMethod);
-    });
-    test("updateAvailable is false when current matches latest", async () => {
-        mockFetch(() => fakeRelease("v0.0.13"));
-        const result = await checkForUpdate("0.0.13");
-        expect(result.updateAvailable).toBe(false);
-        expect(result.latestVersion).toBe("0.0.13");
-    });
-    test("updateAvailable is true for an old version", async () => {
-        mockFetch(() => fakeRelease("v0.0.14"));
-        const result = await checkForUpdate("0.0.0");
-        expect(result.updateAvailable).toBe(true);
-        expect(result.currentVersion).toBe("0.0.0");
-        expect(result.latestVersion).toBe("0.0.14");
-    });
-    test("handles missing tag_name gracefully", async () => {
-        mockFetch(() => Response.json({}));
-        const result = await checkForUpdate("0.0.13");
-        expect(result.latestVersion).toBe("");
-        expect(result.updateAvailable).toBe(false);
-    });
-    test("throws on non-OK response", async () => {
-        mockFetch(() => new Response("Not Found", { status: 404, statusText: "Not Found" }));
-        await expect(checkForUpdate("0.0.13")).rejects.toThrow("Failed to check for updates");
-    });
-});
-// ── performUpgrade ──────────────────────────────────────────────────────────
-describe("performUpgrade", () => {
-    test("runs npm global install for npm installs", async () => {
-        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
-            status: 0,
-            stdout: "",
-            stderr: "",
-        });
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "npm",
-        });
-        expect(spawnSyncSpy).toHaveBeenCalledWith(expect.stringContaining("npm"), ["install", "-g", "akm-cli@latest"], expect.objectContaining({ encoding: "utf8", stdio: "pipe" }));
-        expect(result.upgraded).toBe(true);
-        expect(result.installMethod).toBe("npm");
-    });
-    test("runs bun global install for bun installs", async () => {
-        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
-            status: 0,
-            stdout: "",
-            stderr: "",
-        });
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "bun",
-        });
-        expect(spawnSyncSpy).toHaveBeenCalledWith(expect.stringContaining("bun"), ["install", "-g", "akm-cli@latest"], expect.objectContaining({ encoding: "utf8", stdio: "pipe" }));
-        expect(result.upgraded).toBe(true);
-        expect(result.installMethod).toBe("bun");
-    });
-    test("runs pnpm global add for pnpm installs", async () => {
-        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
-            status: 0,
-            stdout: "",
-            stderr: "",
-        });
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "pnpm",
-        });
-        expect(spawnSyncSpy).toHaveBeenCalledWith(expect.stringContaining("pnpm"), ["add", "-g", "akm-cli@latest"], expect.objectContaining({ encoding: "utf8", stdio: "pipe" }));
-        expect(result.upgraded).toBe(true);
-        expect(result.installMethod).toBe("pnpm");
-    });
-    test("returns guidance message for unknown install method", async () => {
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "unknown",
-        });
-        expect(result.upgraded).toBe(false);
-        expect(result.installMethod).toBe("unknown");
-        expect(result.message).toContain("manually");
-    });
-    test("returns already-latest message when no update available", async () => {
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.13",
-            updateAvailable: false,
-            installMethod: "binary",
-        });
-        expect(result.upgraded).toBe(false);
-        expect(result.message).toContain("already the latest");
-    });
-    test("runs `akm index` post-upgrade after a successful pkg-manager install", async () => {
-        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
-            status: 0,
-            stdout: "",
-            stderr: "",
-        });
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "npm",
-        });
-        expect(result.upgraded).toBe(true);
-        expect(result.postUpgrade).toBeDefined();
-        expect(result.postUpgrade?.ok).toBe(true);
-        expect(result.postUpgrade?.skipped).toBe(false);
-        expect(result.postUpgrade?.exitCode).toBe(0);
-        // First spawnSync = the install; second spawnSync = the post-upgrade `akm index`.
-        expect(spawnSyncSpy).toHaveBeenCalledTimes(2);
-        expect(spawnSyncSpy).toHaveBeenLastCalledWith("akm", ["index"], expect.objectContaining({ encoding: "utf8", stdio: "pipe" }));
-    });
-    test("skips the post-upgrade `akm index` when skipPostUpgrade is set", async () => {
-        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
-            status: 0,
-            stdout: "",
-            stderr: "",
-        });
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "npm",
-        }, { skipPostUpgrade: true });
-        expect(result.upgraded).toBe(true);
-        expect(result.postUpgrade).toBeDefined();
-        expect(result.postUpgrade?.skipped).toBe(true);
-        expect(result.postUpgrade?.ok).toBe(true);
-        // Only the install spawnSync ran — no second call for `akm index`.
-        expect(spawnSyncSpy).toHaveBeenCalledTimes(1);
-    });
-    test("captures post-upgrade failure without failing the upgrade", async () => {
-        let call = 0;
-        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockImplementation((() => {
-            call++;
-            if (call === 1) {
-                // The install itself succeeds.
-                return { status: 0, stdout: "", stderr: "" };
-            }
-            // The post-upgrade `akm index` fails with a non-zero exit.
-            return { status: 1, stdout: "", stderr: "no embedding model configured" };
-        }));
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "npm",
-        });
-        expect(result.upgraded).toBe(true); // upgrade itself succeeded
-        expect(result.postUpgrade?.ok).toBe(false);
-        expect(result.postUpgrade?.exitCode).toBe(1);
-        expect(result.postUpgrade?.message).toContain("no embedding model configured");
-        expect(spawnSyncSpy).toHaveBeenCalledTimes(2);
-    });
-    test("throws when latestVersion is empty and force is used", async () => {
-        await expect(performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "",
-            updateAvailable: false,
-            installMethod: "binary",
-        }, { force: true })).rejects.toThrow("Unable to determine latest version");
-    });
-    // Note: tests for the binary install path (installMethod: "binary") that test
-    // checksum verification must avoid actually reaching the filesystem write step,
-    // which would overwrite the running bun binary. We mock the download to return
-    // a non-OK status after the checksum check fails, so the code throws before
-    // trying to write to disk.
-    test("blocks upgrade when checksum URL returns 404 (default)", async () => {
-        mockFetch((url) => {
-            if (url.includes("checksums.txt"))
-                return new Response("", { status: 404, statusText: "Not Found" });
-            // Use a non-OK download response so the code throws before reaching the write step
-            return new Response("", { status: 500 });
-        });
-        // The binary download fails first (500), but if checksum fetch is tried before
-        // binary download, it should throw a checksum error.
-        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
-            status: 0,
-            stdout: "",
-            stderr: "",
-        });
-        await expect(performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "npm",
-        }, { skipPostUpgrade: true })).resolves.toMatchObject({ upgraded: true, installMethod: "npm" });
-        // Only the install spawnSync ran; skipPostUpgrade keeps the test focused
-        // on the checksum-bypass behavior, not the new post-upgrade hook.
-        expect(spawnSyncSpy).toHaveBeenCalledTimes(1);
-    });
-    test("checksum URL 404 throws Checksum verification failed for binary install", async () => {
-        // Use a mock that: binary download succeeds, checksum returns 404.
-        // IMPORTANT: We ensure the test does NOT write to disk by making the checksum
-        // step fail first (it runs after binary download).
-        mockFetch((url) => {
-            if (url.includes("checksums.txt"))
-                return new Response("", { status: 404 });
-            // Fake binary download — must succeed for checksum check to be reached
-            return new Response(new Uint8Array(100), { status: 200 });
-        });
-        await expect(performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "binary",
-        })).rejects.toThrow(/Checksum verification failed/);
-    });
-    test("skipChecksum: true option is accepted by performUpgrade (npm path)", async () => {
-        const spawnSyncSpy = spyOn(childProcess, "spawnSync").mockReturnValue({
-            status: 0,
-            stdout: "",
-            stderr: "",
-        });
-        const result = await performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "npm",
-        }, { skipChecksum: true, skipPostUpgrade: true });
-        // Only the install spawnSync ran; skipPostUpgrade keeps the test focused
-        // on the skipChecksum option, not the new post-upgrade hook.
-        expect(spawnSyncSpy).toHaveBeenCalledTimes(1);
-        expect(result.upgraded).toBe(true);
-        expect(result.installMethod).toBe("npm");
-    });
-    test("blocks upgrade when binary name not in checksums.txt (default)", async () => {
-        const binaryName = getAkmBinaryName();
-        mockFetch((url) => {
-            if (url.includes("checksums.txt")) {
-                // Valid checksums format but does NOT include the current binary name
-                return new Response(`${"a".repeat(64)}  other-binary\n${"b".repeat(64)}  another-binary\n`, { status: 200 });
-            }
-            return new Response(new Uint8Array(100), { status: 200 });
-        });
-        await expect(performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "binary",
-        })).rejects.toThrow(new RegExp(`${binaryName.replace(".", "\\.")}.*not listed|Checksum verification failed`));
-    });
-    test("blocks upgrade on checksum mismatch (default)", async () => {
-        const binaryName = getAkmBinaryName();
-        const wrongHash = "0".repeat(64);
-        mockFetch((url) => {
-            if (url.includes("checksums.txt")) {
-                return new Response(`${wrongHash}  ${binaryName}\n`, { status: 200 });
-            }
-            // Return binary content that will NOT match the all-zeros hash
-            return new Response(new Uint8Array(Array.from({ length: 100 }, (_, i) => i % 256)), { status: 200 });
-        });
-        await expect(performUpgrade({
-            currentVersion: "0.0.13",
-            latestVersion: "0.0.14",
-            updateAvailable: true,
-            installMethod: "binary",
-        })).rejects.toThrow(/Checksum mismatch/);
-    });
-});
-describe("getPackageManagerUpgradeCommand", () => {
-    test("returns npm install command", () => {
-        expect(getPackageManagerUpgradeCommand("npm", "akm-cli")).toEqual({
-            command: expect.stringContaining("npm"),
-            args: ["install", "-g", "akm-cli@latest"],
-            displayCommand: "npm install -g akm-cli@latest",
-        });
-    });
-    test("returns bun install command", () => {
-        expect(getPackageManagerUpgradeCommand("bun", "akm-cli")).toEqual({
-            command: expect.stringContaining("bun"),
-            args: ["install", "-g", "akm-cli@latest"],
-            displayCommand: "bun install -g akm-cli@latest",
-        });
-    });
-    test("returns pnpm add command", () => {
-        expect(getPackageManagerUpgradeCommand("pnpm", "akm-cli")).toEqual({
-            command: expect.stringContaining("pnpm"),
-            args: ["add", "-g", "akm-cli@latest"],
-            displayCommand: "pnpm add -g akm-cli@latest",
-        });
-    });
-    test("returns undefined for non-package-manager installs", () => {
-        expect(getPackageManagerUpgradeCommand("binary", "akm-cli")).toBeUndefined();
-        expect(getPackageManagerUpgradeCommand("unknown", "akm-cli")).toBeUndefined();
-    });
-});