akm-cli 0.7.0-rc1 → 0.7.1

package/dist/tests/ripgrep-install.test.js

@@ -1,251 +0,0 @@
-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";
-// We test the module by importing and mocking its dependencies.
-// Since ensureRg calls spawnSync and resolveRg, we mock at the module level.
-// ── Helpers ─────────────────────────────────────────────────────────────────
-let tmpDirs = [];
-function makeTmpDir() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-rg-install-test-"));
-    tmpDirs.push(dir);
-    return dir;
-}
-function makeToolchainDir() {
-    const dir = makeTmpDir();
-    fs.writeFileSync(path.join(dir, "curl"), '#!/bin/sh\nout=\'\'\nwhile [ $# -gt 0 ]; do\n  if [ "$1" = "-o" ]; then\n    out=$2\n    shift 2\n    continue\n  fi\n  shift\ndone\n/bin/cp "$FAKE_CURL_SOURCE" "$out"\n');
-    fs.chmodSync(path.join(dir, "curl"), 0o755);
-    fs.symlinkSync("/usr/bin/tar", path.join(dir, "tar"));
-    fs.symlinkSync("/usr/bin/gzip", path.join(dir, "gzip"));
-    return dir;
-}
-function makeFailingCurlDir() {
-    const dir = makeTmpDir();
-    fs.writeFileSync(path.join(dir, "curl"), "#!/bin/sh\necho 'fake curl failure' >&2\nexit 1\n");
-    fs.chmodSync(path.join(dir, "curl"), 0o755);
-    return dir;
-}
-function makeRipgrepTarball() {
-    const root = makeTmpDir();
-    const packageDir = path.join(root, "ripgrep-14.1.1-x86_64-unknown-linux-musl");
-    fs.mkdirSync(packageDir, { recursive: true });
-    fs.writeFileSync(path.join(packageDir, "rg"), "#!/bin/sh\necho 'ripgrep 14.1.1'\n");
-    fs.chmodSync(path.join(packageDir, "rg"), 0o755);
-    const tarballPath = path.join(root, "ripgrep.tar.gz");
-    const result = spawnSync("tar", ["czf", tarballPath, "-C", root, path.basename(packageDir)], { encoding: "utf8" });
-    if (result.status !== 0) {
-        throw new Error(result.stderr || result.error?.message || "Failed to create ripgrep tarball");
-    }
-    return tarballPath;
-}
-afterEach(() => {
-    for (const dir of tmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-    tmpDirs = [];
-});
-// ── ensureRg – already available ────────────────────────────────────────────
-describe("ensureRg", () => {
-    test("returns existing rg when already available in binDir", async () => {
-        // Create a fake rg binary so resolveRg finds it
-        const binDir = makeTmpDir();
-        const rgPath = path.join(binDir, "rg");
-        fs.writeFileSync(rgPath, "#!/bin/sh\necho 'ripgrep 14.1.1'\n");
-        fs.chmodSync(rgPath, 0o755);
-        // We need to isolate PATH so only our binDir is searched
-        const origPath = process.env.PATH;
-        const origXdgCache = process.env.XDG_CACHE_HOME;
-        const origHome = process.env.HOME;
-        process.env.PATH = "";
-        process.env.XDG_CACHE_HOME = makeTmpDir();
-        try {
-            const { ensureRg } = await import("../src/setup/ripgrep-install");
-            const result = ensureRg(binDir);
-            expect(result.rgPath).toBe(rgPath);
-            expect(result.installed).toBe(false);
-        }
-        finally {
-            process.env.PATH = origPath;
-            if (origXdgCache === undefined)
-                delete process.env.XDG_CACHE_HOME;
-            else
-                process.env.XDG_CACHE_HOME = origXdgCache;
-            if (origHome === undefined)
-                delete process.env.HOME;
-            else
-                process.env.HOME = origHome;
-        }
-    });
-});
-// ── getRgPlatformTarget (tested via ensureRg behavior) ──────────────────────
-describe("platform detection", () => {
-    // We can test this indirectly: ensureRg will throw for unsupported platforms
-    // We test current platform should be supported (we're running on linux/x64 or similar)
-    test("current platform is recognized (does not throw unsupported)", async () => {
-        const binDir = makeTmpDir();
-        const origPath = process.env.PATH;
-        const origXdgCache = process.env.XDG_CACHE_HOME;
-        process.env.PATH = makeFailingCurlDir();
-        process.env.XDG_CACHE_HOME = makeTmpDir();
-        try {
-            const { ensureRg } = await import("../src/setup/ripgrep-install");
-            // This will try to actually download, so we expect a network error or curl error,
-            // NOT an "Unsupported platform" error.
-            try {
-                ensureRg(binDir);
-            }
-            catch (err) {
-                const message = err.message;
-                // Should NOT be the unsupported platform error
-                expect(message).not.toContain("Unsupported platform");
-                // It should be a download/extraction error since we're not actually downloading
-                expect(message.includes("Failed to download") ||
-                    message.includes("Failed to extract") ||
-                    message.includes("not found at")).toBe(true);
-            }
-        }
-        finally {
-            process.env.PATH = origPath;
-            if (origXdgCache === undefined)
-                delete process.env.XDG_CACHE_HOME;
-            else
-                process.env.XDG_CACHE_HOME = origXdgCache;
-        }
-    });
-});
-// ── getRgVersion (tested via ensureRg result) ───────────────────────────────
-describe("getRgVersion", () => {
-    test("extracts version from rg binary output", async () => {
-        const binDir = makeTmpDir();
-        const rgPath = path.join(binDir, "rg");
-        // Create a script that mimics rg --version output
-        fs.writeFileSync(rgPath, '#!/bin/sh\necho "ripgrep 14.1.1 (rev abc123)"\n');
-        fs.chmodSync(rgPath, 0o755);
-        const origPath = process.env.PATH;
-        const origXdgCache = process.env.XDG_CACHE_HOME;
-        process.env.PATH = "";
-        process.env.XDG_CACHE_HOME = makeTmpDir();
-        try {
-            const { ensureRg } = await import("../src/setup/ripgrep-install");
-            const result = ensureRg(binDir);
-            expect(result.version).toBe("14.1.1");
-            expect(result.installed).toBe(false);
-        }
-        finally {
-            process.env.PATH = origPath;
-            if (origXdgCache === undefined)
-                delete process.env.XDG_CACHE_HOME;
-            else
-                process.env.XDG_CACHE_HOME = origXdgCache;
-        }
-    });
-    test("returns 'unknown' when rg binary does not output version format", async () => {
-        const binDir = makeTmpDir();
-        const rgPath = path.join(binDir, "rg");
-        fs.writeFileSync(rgPath, '#!/bin/sh\necho "something else"\n');
-        fs.chmodSync(rgPath, 0o755);
-        const origPath = process.env.PATH;
-        const origXdgCache = process.env.XDG_CACHE_HOME;
-        process.env.PATH = "";
-        process.env.XDG_CACHE_HOME = makeTmpDir();
-        try {
-            const { ensureRg } = await import("../src/setup/ripgrep-install");
-            const result = ensureRg(binDir);
-            expect(result.version).toBe("unknown");
-        }
-        finally {
-            process.env.PATH = origPath;
-            if (origXdgCache === undefined)
-                delete process.env.XDG_CACHE_HOME;
-            else
-                process.env.XDG_CACHE_HOME = origXdgCache;
-        }
-    });
-});
-// ── EnsureRgResult shape ────────────────────────────────────────────────────
-describe("EnsureRgResult", () => {
-    test("result has correct shape for existing binary", async () => {
-        const binDir = makeTmpDir();
-        const rgPath = path.join(binDir, "rg");
-        fs.writeFileSync(rgPath, '#!/bin/sh\necho "ripgrep 14.0.0"\n');
-        fs.chmodSync(rgPath, 0o755);
-        const origPath = process.env.PATH;
-        const origXdgCache = process.env.XDG_CACHE_HOME;
-        process.env.PATH = "";
-        process.env.XDG_CACHE_HOME = makeTmpDir();
-        try {
-            const { ensureRg } = await import("../src/setup/ripgrep-install");
-            const result = ensureRg(binDir);
-            expect(typeof result.rgPath).toBe("string");
-            expect(typeof result.installed).toBe("boolean");
-            expect(typeof result.version).toBe("string");
-        }
-        finally {
-            process.env.PATH = origPath;
-            if (origXdgCache === undefined)
-                delete process.env.XDG_CACHE_HOME;
-            else
-                process.env.XDG_CACHE_HOME = origXdgCache;
-        }
-    });
-});
-// ── Download error handling ─────────────────────────────────────────────────
-describe("download error handling", () => {
-    test("creates binDir if it does not exist", async () => {
-        const parentDir = makeTmpDir();
-        const binDir = path.join(parentDir, "nested", "bin");
-        const rgPath = path.join(binDir, "rg");
-        // Pre-create an rg binary so ensureRg finds it and doesn't try to download
-        fs.mkdirSync(binDir, { recursive: true });
-        fs.writeFileSync(rgPath, '#!/bin/sh\necho "ripgrep 14.1.1"\n');
-        fs.chmodSync(rgPath, 0o755);
-        const origPath = process.env.PATH;
-        const origXdgCache = process.env.XDG_CACHE_HOME;
-        process.env.PATH = "";
-        process.env.XDG_CACHE_HOME = makeTmpDir();
-        try {
-            const { ensureRg } = await import("../src/setup/ripgrep-install");
-            const result = ensureRg(binDir);
-            expect(result.rgPath).toBe(rgPath);
-            expect(result.installed).toBe(false);
-        }
-        finally {
-            process.env.PATH = origPath;
-            if (origXdgCache === undefined)
-                delete process.env.XDG_CACHE_HOME;
-            else
-                process.env.XDG_CACHE_HOME = origXdgCache;
-        }
-    });
-    test("ensureRg returns installed=true when it installs a new binary", async () => {
-        const binDir = makeTmpDir();
-        const origPath = process.env.PATH;
-        const origXdgCache = process.env.XDG_CACHE_HOME;
-        const origFakeCurlSource = process.env.FAKE_CURL_SOURCE;
-        process.env.XDG_CACHE_HOME = makeTmpDir();
-        process.env.FAKE_CURL_SOURCE = makeRipgrepTarball();
-        process.env.PATH = makeToolchainDir();
-        try {
-            const { ensureRg } = await import("../src/setup/ripgrep-install");
-            const rgInBin = path.join(binDir, "rg");
-            if (fs.existsSync(rgInBin))
-                fs.unlinkSync(rgInBin);
-            const result = ensureRg(binDir);
-            expect(result.installed).toBe(true);
-            expect(result.version).toBe("14.1.1");
-            expect(fs.existsSync(result.rgPath)).toBe(true);
-        }
-        finally {
-            process.env.PATH = origPath;
-            if (origXdgCache === undefined)
-                delete process.env.XDG_CACHE_HOME;
-            else
-                process.env.XDG_CACHE_HOME = origXdgCache;
-            if (origFakeCurlSource === undefined)
-                delete process.env.FAKE_CURL_SOURCE;
-            else
-                process.env.FAKE_CURL_SOURCE = origFakeCurlSource;
-        }
-    });
-});

package/dist/tests/ripgrep-resolve.test.js

@@ -1,108 +0,0 @@
-import { afterAll, afterEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { isRgAvailable, resolveRg } from "../src/setup/ripgrep-resolve";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-const tempDirs = [];
-function makeTempDir() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-rg-"));
-    tempDirs.push(dir);
-    return dir;
-}
-afterAll(() => {
-    for (const dir of tempDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-const origPath = process.env.PATH;
-const origXdgCacheHome = process.env.XDG_CACHE_HOME;
-const origHome = process.env.HOME;
-afterEach(() => {
-    if (origPath === undefined) {
-        delete process.env.PATH;
-    }
-    else {
-        process.env.PATH = origPath;
-    }
-    if (origXdgCacheHome === undefined) {
-        delete process.env.XDG_CACHE_HOME;
-    }
-    else {
-        process.env.XDG_CACHE_HOME = origXdgCacheHome;
-    }
-    if (origHome === undefined) {
-        delete process.env.HOME;
-    }
-    else {
-        process.env.HOME = origHome;
-    }
-});
-/** Isolate cache so getBinDir() never finds a real rg binary. */
-function isolateCache() {
-    process.env.XDG_CACHE_HOME = makeTempDir();
-}
-// ── resolveRg ───────────────────────────────────────────────────────────────
-describe("resolveRg", () => {
-    test("finds rg in provided bin directory", () => {
-        const binDir = makeTempDir();
-        const rgPath = path.join(binDir, "rg");
-        fs.writeFileSync(rgPath, "#!/bin/sh\necho rg\n");
-        fs.chmodSync(rgPath, 0o755);
-        const result = resolveRg(binDir);
-        expect(result).toBe(rgPath);
-    });
-    test("falls back to system PATH", () => {
-        const fakeBinDir = makeTempDir();
-        const fakeRg = path.join(fakeBinDir, "rg");
-        fs.writeFileSync(fakeRg, "#!/bin/sh\necho rg\n");
-        fs.chmodSync(fakeRg, 0o755);
-        // Put our fake bin dir at the front of PATH
-        process.env.PATH = `${fakeBinDir}${path.delimiter}${origPath}`;
-        // No bin dir provided -- should find from PATH
-        const result = resolveRg();
-        expect(result).toBeTruthy();
-    });
-    test("returns null when not found anywhere", () => {
-        const emptyDir = makeTempDir();
-        process.env.PATH = "";
-        isolateCache();
-        const result = resolveRg(emptyDir);
-        expect(result).toBeNull();
-    });
-    test("skips non-executable file in bin dir", () => {
-        const binDir = makeTempDir();
-        // Create an rg file that is NOT executable
-        const rgPath = path.join(binDir, "rg");
-        fs.writeFileSync(rgPath, "not executable");
-        fs.chmodSync(rgPath, 0o644);
-        process.env.PATH = "";
-        isolateCache();
-        const result = resolveRg(binDir);
-        expect(result).toBeNull();
-    });
-});
-// ── isRgAvailable ───────────────────────────────────────────────────────────
-describe("isRgAvailable", () => {
-    test("returns true when resolveRg finds a binary", () => {
-        const binDir = makeTempDir();
-        const rgPath = path.join(binDir, "rg");
-        fs.writeFileSync(rgPath, "#!/bin/sh\necho rg\n");
-        fs.chmodSync(rgPath, 0o755);
-        expect(isRgAvailable(binDir)).toBe(true);
-    });
-    test("returns false when resolveRg finds nothing", () => {
-        const emptyDir = makeTempDir();
-        process.env.PATH = "";
-        isolateCache();
-        expect(isRgAvailable(emptyDir)).toBe(false);
-    });
-    test("boolean result matches resolveRg truthiness", () => {
-        const binDir = makeTempDir();
-        process.env.PATH = "";
-        isolateCache();
-        const resolved = resolveRg(binDir);
-        const available = isRgAvailable(binDir);
-        expect(available).toBe(resolved !== null);
-    });
-});

package/dist/tests/ripgrep.test.js

@@ -1,163 +0,0 @@
-import { afterAll, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { isRgAvailable, resolveRg } from "../src/setup/ripgrep-resolve";
-const createdTmpDirs = [];
-function expectDefined(value) {
-    expect(value).toBeDefined();
-    if (value === undefined || value === null) {
-        throw new Error("Expected value to be defined");
-    }
-    return value;
-}
-function tmpDir() {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-rg-"));
-    createdTmpDirs.push(dir);
-    return dir;
-}
-afterAll(() => {
-    for (const dir of createdTmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-function writeFile(filePath, content = "") {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-}
-// ── resolveRg ───────────────────────────────────────────────────────────────
-test("resolveRg finds system ripgrep on PATH", () => {
-    const originalPath = process.env.PATH;
-    const stashDir = tmpDir();
-    const binDir = path.join(stashDir, "bin");
-    fs.mkdirSync(binDir, { recursive: true });
-    // Create a fake rg binary on PATH so the test does not depend on the host environment
-    const rgName = process.platform === "win32" ? "rg.cmd" : "rg";
-    const fakeRg = path.join(binDir, rgName);
-    const scriptContent = process.platform === "win32" ? "@echo off\r\necho fake rg\r\n" : "#!/bin/sh\necho fake rg\n";
-    fs.writeFileSync(fakeRg, scriptContent);
-    try {
-        // Make sure the fake rg is executable where that concept applies
-        if (process.platform !== "win32") {
-            fs.chmodSync(fakeRg, 0o755);
-        }
-    }
-    catch {
-        // Ignore chmod errors on platforms/filesystems that do not support it
-    }
-    // Prepend the fake rg directory to PATH for this test only
-    process.env.PATH = binDir + path.delimiter + (originalPath ?? "");
-    try {
-        const rg = resolveRg();
-        expect(expectDefined(rg)).toContain("rg");
-    }
-    finally {
-        process.env.PATH = originalPath;
-    }
-});
-test("resolveRg finds rg in provided bin directory", () => {
-    const binDir = tmpDir();
-    // Create a fake rg binary
-    const fakeRg = path.join(binDir, "rg");
-    fs.writeFileSync(fakeRg, "#!/bin/sh\necho fake rg\n");
-    fs.chmodSync(fakeRg, 0o755);
-    const rg = resolveRg(binDir);
-    expect(rg).toBe(fakeRg);
-});
-test("resolveRg skips non-executable files in bin dir", () => {
-    const binDir = tmpDir();
-    // Create a non-executable rg file
-    const fakeRg = path.join(binDir, "rg");
-    fs.writeFileSync(fakeRg, "not executable");
-    fs.chmodSync(fakeRg, 0o644);
-    const rg = resolveRg(binDir);
-    // Should fall through to system PATH
-    expect(rg).not.toBe(fakeRg);
-});
-// ── isRgAvailable ───────────────────────────────────────────────────────────
-test("isRgAvailable returns true when rg is on PATH", () => {
-    const originalPath = process.env.PATH;
-    const stashDir = tmpDir();
-    const binDir = path.join(stashDir, "bin");
-    fs.mkdirSync(binDir, { recursive: true });
-    const rgName = process.platform === "win32" ? "rg.cmd" : "rg";
-    const fakeRg = path.join(binDir, rgName);
-    const scriptContent = process.platform === "win32" ? "@echo off\r\necho fake rg\r\n" : "#!/bin/sh\necho fake rg\n";
-    fs.writeFileSync(fakeRg, scriptContent);
-    if (process.platform !== "win32") {
-        fs.chmodSync(fakeRg, 0o755);
-    }
-    process.env.PATH = binDir + path.delimiter + (originalPath ?? "");
-    try {
-        expect(isRgAvailable()).toBe(true);
-    }
-    finally {
-        process.env.PATH = originalPath;
-    }
-});
-// ── Integration: indexed search pipeline ────────────────────────────────────
-test("search pipeline returns ranked results when index exists", async () => {
-    const stashDir = tmpDir();
-    for (const sub of ["scripts", "skills", "commands", "agents"]) {
-        fs.mkdirSync(path.join(stashDir, sub), { recursive: true });
-    }
-    // Create scripts with .stash.json metadata
-    writeFile(path.join(stashDir, "scripts", "docker", "build.sh"), "#!/bin/bash\necho build\n");
-    writeFile(path.join(stashDir, "scripts", "docker", ".stash.json"), JSON.stringify({
-        entries: [
-            {
-                name: "docker-build",
-                type: "script",
-                description: "build docker images",
-                tags: ["docker", "container"],
-                filename: "build.sh",
-            },
-        ],
-    }));
-    writeFile(path.join(stashDir, "scripts", "git", "diff.sh"), "#!/bin/bash\necho diff\n");
-    writeFile(path.join(stashDir, "scripts", "git", ".stash.json"), JSON.stringify({
-        entries: [
-            {
-                name: "git-diff",
-                type: "script",
-                description: "summarize git changes",
-                tags: ["git", "diff"],
-                filename: "diff.sh",
-            },
-        ],
-    }));
-    // Isolation: ensure index cache and config are written to temp directories
-    const oldXdgCacheHome = process.env.XDG_CACHE_HOME;
-    const oldXdgConfigHome = process.env.XDG_CONFIG_HOME;
-    const oldAkmStashDir = process.env.AKM_STASH_DIR;
-    const tempCacheDir = tmpDir();
-    const tempConfigDir = tmpDir();
-    process.env.XDG_CACHE_HOME = tempCacheDir;
-    process.env.XDG_CONFIG_HOME = tempConfigDir;
-    try {
-        // Build index
-        process.env.AKM_STASH_DIR = stashDir;
-        const { akmIndex } = await import("../src/indexer/indexer");
-        await akmIndex({ stashDir });
-        // Search — TF-IDF should rank docker-related results first
-        const { akmSearch } = await import("../src/commands/search");
-        const result = await akmSearch({ query: "docker", type: "any" });
-        expect(result.hits.length).toBeGreaterThan(0);
-        // Docker-related result should be ranked first
-        expect(result.hits[0].name).toContain("docker");
-    }
-    finally {
-        if (oldXdgCacheHome === undefined)
-            delete process.env.XDG_CACHE_HOME;
-        else
-            process.env.XDG_CACHE_HOME = oldXdgCacheHome;
-        if (oldXdgConfigHome === undefined)
-            delete process.env.XDG_CONFIG_HOME;
-        else
-            process.env.XDG_CONFIG_HOME = oldXdgConfigHome;
-        if (oldAkmStashDir === undefined)
-            delete process.env.AKM_STASH_DIR;
-        else
-            process.env.AKM_STASH_DIR = oldAkmStashDir;
-    }
-});

package/dist/tests/save-command.test.js

@@ -1,94 +0,0 @@
-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";
-const CLI = path.join(__dirname, "..", "src", "cli.ts");
-const tempDirs = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-function runCli(args, stashDir) {
-    const xdgCache = makeTempDir("akm-save-cache-");
-    const xdgConfig = makeTempDir("akm-save-cfg-");
-    return spawnSync("bun", [CLI, ...args], {
-        encoding: "utf8",
-        timeout: 30_000,
-        env: {
-            ...process.env,
-            AKM_STASH_DIR: stashDir,
-            XDG_CACHE_HOME: xdgCache,
-            XDG_CONFIG_HOME: xdgConfig,
-        },
-    });
-}
-function parseSaveOutput(stdout) {
-    return JSON.parse(stdout.trim());
-}
-/** Initialise a bare git repo in `dir` so akm save can commit. */
-function initGitRepo(dir) {
-    fs.mkdirSync(dir, { recursive: true });
-    spawnSync("git", ["init", dir], { encoding: "utf8" });
-    spawnSync("git", ["-C", dir, "config", "commit.gpgsign", "false"], { encoding: "utf8" });
-}
-describe("akm save", () => {
-    test("returns skipped when stash is not a git repo", () => {
-        const stashDir = makeTempDir("akm-save-nongit-");
-        const result = runCli(["save"], stashDir);
-        expect(result.status).toBe(0);
-        const json = parseSaveOutput(result.stdout);
-        expect(json.skipped).toBe(true);
-        expect(json.committed).toBe(false);
-        expect(json.pushed).toBe(false);
-    });
-    test("reports nothing to commit on a clean git repo", () => {
-        const stashDir = makeTempDir("akm-save-clean-");
-        initGitRepo(stashDir);
-        // Create an initial commit so the repo is not bare
-        const f = path.join(stashDir, "README.md");
-        fs.writeFileSync(f, "hello");
-        spawnSync("git", ["-C", stashDir, "add", "-A"], { encoding: "utf8" });
-        spawnSync("git", ["-C", stashDir, "-c", "user.name=test", "-c", "user.email=t@t", "commit", "-m", "init"], {
-            encoding: "utf8",
-        });
-        const result = runCli(["save"], stashDir);
-        expect(result.status).toBe(0);
-        const json = parseSaveOutput(result.stdout);
-        expect(json.committed).toBe(false);
-        expect(json.skipped).toBe(false);
-        expect(json.output).toContain("nothing to commit");
-    });
-    test("commits changes in a git repo with no remote", () => {
-        const stashDir = makeTempDir("akm-save-commit-");
-        initGitRepo(stashDir);
-        // Write a file so there's something to commit
-        fs.writeFileSync(path.join(stashDir, "skill.md"), "# Test");
-        const result = runCli(["save", "-m", "test commit"], stashDir);
-        expect(result.status).toBe(0);
-        const json = parseSaveOutput(result.stdout);
-        expect(json.committed).toBe(true);
-        expect(json.pushed).toBe(false);
-        expect(json.skipped).toBe(false);
-        // Verify the commit actually landed
-        const log = spawnSync("git", ["-C", stashDir, "log", "--oneline"], { encoding: "utf8" });
-        expect(log.stdout).toContain("test commit");
-    });
-    test("uses timestamp message when -m is omitted", () => {
-        const stashDir = makeTempDir("akm-save-ts-");
-        initGitRepo(stashDir);
-        fs.writeFileSync(path.join(stashDir, "skill.md"), "# Test");
-        const result = runCli(["save"], stashDir);
-        expect(result.status).toBe(0);
-        const json = parseSaveOutput(result.stdout);
-        expect(json.committed).toBe(true);
-        const log = spawnSync("git", ["-C", stashDir, "log", "--oneline"], { encoding: "utf8" });
-        expect(log.stdout).toContain("akm save");
-    });
-});