akm-cli 0.6.0 → 0.7.0-rc1

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

@@ -0,0 +1,251 @@
+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

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,163 @@
+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

@@ -0,0 +1,94 @@
+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");
+    });
+});