akm-cli 0.6.1 → 0.7.0

package/dist/tests/source-manage.test.js

@@ -0,0 +1,366 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { addStash, listStashes, removeStash } from "../src/commands/source-manage";
+import { loadConfig, saveConfig } from "../src/core/config";
+const createdTmpDirs = [];
+function createTmpDir(prefix = "akm-src-mgmt-") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    createdTmpDirs.push(dir);
+    return dir;
+}
+const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
+const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
+const originalAkmStashDir = process.env.AKM_STASH_DIR;
+let testCacheDir = "";
+let testConfigDir = "";
+let testStashDir = "";
+beforeEach(() => {
+    testCacheDir = createTmpDir("akm-src-cache-");
+    testConfigDir = createTmpDir("akm-src-config-");
+    testStashDir = createTmpDir("akm-src-stash-");
+    process.env.XDG_CACHE_HOME = testCacheDir;
+    process.env.XDG_CONFIG_HOME = testConfigDir;
+    process.env.AKM_STASH_DIR = testStashDir;
+    // Write initial config so loadConfig doesn't return defaults with stale caches
+    saveConfig({ semanticSearchMode: "auto" });
+});
+afterEach(() => {
+    if (originalXdgCacheHome === undefined)
+        delete process.env.XDG_CACHE_HOME;
+    else
+        process.env.XDG_CACHE_HOME = originalXdgCacheHome;
+    if (originalXdgConfigHome === undefined)
+        delete process.env.XDG_CONFIG_HOME;
+    else
+        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
+    if (originalAkmStashDir === undefined)
+        delete process.env.AKM_STASH_DIR;
+    else
+        process.env.AKM_STASH_DIR = originalAkmStashDir;
+    for (const dir of createdTmpDirs) {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch { }
+    }
+    createdTmpDirs.length = 0;
+});
+// ── addStash ──────────────────────────────────────────────────────────
+describe("addStash", () => {
+    test("adds a filesystem path", () => {
+        const stashPath = createTmpDir("akm-fs-source-");
+        const result = addStash({ target: stashPath });
+        expect(result.added).toBe(true);
+        expect(result.entry).toBeDefined();
+        expect(result.entry?.type).toBe("filesystem");
+        expect(result.entry?.path).toBe(path.resolve(stashPath));
+        // Verify persisted
+        const config = loadConfig();
+        expect(config.sources).toHaveLength(1);
+        expect(config.sources?.[0].type).toBe("filesystem");
+        expect(config.sources?.[0].path).toBe(path.resolve(stashPath));
+    });
+    test("adds a filesystem path with a name", () => {
+        const stashPath = createTmpDir("akm-fs-named-");
+        const result = addStash({ target: stashPath, name: "my-stash" });
+        expect(result.added).toBe(true);
+        expect(result.entry?.name).toBe("my-stash");
+    });
+    test("rejects duplicate filesystem paths", () => {
+        const stashPath = createTmpDir("akm-fs-dup-");
+        addStash({ target: stashPath });
+        const result = addStash({ target: stashPath });
+        expect(result.added).toBe(false);
+        expect(result.message).toContain("already configured");
+    });
+    test("normalizes relative filesystem paths", () => {
+        const stashPath = createTmpDir("akm-fs-rel-");
+        const relativePath = path.relative(process.cwd(), stashPath);
+        const result = addStash({ target: relativePath });
+        expect(result.added).toBe(true);
+        expect(result.entry?.path).toBe(path.resolve(stashPath));
+    });
+    test("deduplicates paths that resolve to the same directory", () => {
+        const stashPath = createTmpDir("akm-fs-equiv-");
+        addStash({ target: stashPath });
+        // Add again with trailing slash
+        const result = addStash({ target: `${stashPath}/` });
+        expect(result.added).toBe(false);
+        expect(result.message).toContain("already configured");
+    });
+    test("adds a URL source", () => {
+        const url = "https://example.com";
+        const result = addStash({ target: url, providerType: "website" });
+        expect(result.added).toBe(true);
+        expect(result.entry?.type).toBe("website");
+        expect(result.entry?.url).toBe(url);
+        const config = loadConfig();
+        expect(config.sources).toHaveLength(1);
+        expect(config.sources?.[0].type).toBe("website");
+        expect(config.sources?.[0].url).toBe(url);
+    });
+    test("adds a URL source with name and options", () => {
+        const url = "https://example.com";
+        const result = addStash({
+            target: url,
+            providerType: "website",
+            name: "my-source",
+            options: { searchType: "text" },
+        });
+        expect(result.added).toBe(true);
+        expect(result.entry?.name).toBe("my-source");
+        expect(result.entry?.options).toEqual({ searchType: "text" });
+    });
+    test("throws when URL source has no provider type", () => {
+        expect(() => addStash({ target: "https://example.com" })).toThrow("--provider is required");
+    });
+    test("rejects duplicate URL sources", () => {
+        const url = "https://example.com";
+        addStash({ target: url, providerType: "website" });
+        const result = addStash({ target: url, providerType: "website" });
+        expect(result.added).toBe(false);
+        expect(result.message).toContain("already configured");
+    });
+    test("supports custom provider types", () => {
+        const url = "https://custom.example.com";
+        const result = addStash({ target: url, providerType: "custom-provider" });
+        expect(result.added).toBe(true);
+        expect(result.entry?.type).toBe("custom-provider");
+    });
+    test("adds an http:// URL source", () => {
+        const url = "http://example.com";
+        const result = addStash({ target: url, providerType: "website" });
+        expect(result.added).toBe(true);
+        expect(result.entry?.url).toBe(url);
+    });
+    test("allows same URL with different provider types", () => {
+        const url = "https://shared.example.com";
+        addStash({ target: url, providerType: "website" });
+        // Same URL but different provider — deduplicates by URL regardless of type
+        const result = addStash({ target: url, providerType: "custom" });
+        expect(result.added).toBe(false);
+    });
+    test("ignores options for filesystem sources", () => {
+        const fsPath = createTmpDir("akm-fs-opts-");
+        const result = addStash({ target: fsPath, options: { key: "value" } });
+        expect(result.added).toBe(true);
+        expect(result.entry?.options).toBeUndefined();
+    });
+    test("returned stashes array reflects new state", () => {
+        const fsPath = createTmpDir("akm-stashes-return-");
+        const result = addStash({ target: fsPath, name: "ret-test" });
+        expect(result.sources).toHaveLength(1);
+        expect(result.sources[0].name).toBe("ret-test");
+    });
+    test("can add multiple sources of different types", () => {
+        const fsPath = createTmpDir("akm-multi-fs-");
+        addStash({ target: fsPath });
+        addStash({ target: "https://example1.example.com", providerType: "website" });
+        addStash({ target: "https://custom.example.com", providerType: "custom-provider" });
+        const config = loadConfig();
+        expect(config.sources).toHaveLength(3);
+        expect(config.sources?.[0].type).toBe("filesystem");
+        expect(config.sources?.[1].type).toBe("website");
+        expect(config.sources?.[2].type).toBe("custom-provider");
+    });
+    test("preserves existing sources when adding", () => {
+        const config = loadConfig();
+        saveConfig({
+            ...config,
+            sources: [{ type: "website", url: "https://existing.example.com", name: "existing" }],
+        });
+        const fsPath = createTmpDir("akm-preserve-");
+        addStash({ target: fsPath });
+        const updated = loadConfig();
+        expect(updated.sources).toHaveLength(2);
+        expect(updated.sources?.[0].url).toBe("https://existing.example.com");
+        expect(updated.sources?.[1].type).toBe("filesystem");
+    });
+});
+// ── removeStash ───────────────────────────────────────────────────────
+describe("removeStash", () => {
+    test("removes a filesystem source by path", () => {
+        const fsPath = createTmpDir("akm-rm-fs-");
+        addStash({ target: fsPath });
+        const result = removeStash(fsPath);
+        expect(result.removed).toBe(true);
+        expect(result.entry?.type).toBe("filesystem");
+        expect(result.entry?.path).toBe(path.resolve(fsPath));
+        const config = loadConfig();
+        expect(config.sources).toHaveLength(0);
+    });
+    test("removes a URL source by URL", () => {
+        const url = "https://example.com";
+        addStash({ target: url, providerType: "website" });
+        const result = removeStash(url);
+        expect(result.removed).toBe(true);
+        expect(result.entry?.url).toBe(url);
+        const config = loadConfig();
+        expect(config.sources).toHaveLength(0);
+    });
+    test("removes a source by name", () => {
+        const url = "https://example.com";
+        addStash({ target: url, providerType: "website", name: "my-source" });
+        const result = removeStash("my-source");
+        expect(result.removed).toBe(true);
+        expect(result.entry?.name).toBe("my-source");
+    });
+    test("returns removed: false for non-existent source", () => {
+        const result = removeStash("/nonexistent/path");
+        expect(result.removed).toBe(false);
+        expect(result.message).toContain("No matching source found");
+    });
+    test("removes only the matched source, preserving others", () => {
+        const fsPath = createTmpDir("akm-rm-keep-");
+        addStash({ target: fsPath });
+        addStash({ target: "https://example.com", providerType: "website" });
+        removeStash(fsPath);
+        const config = loadConfig();
+        expect(config.sources).toHaveLength(1);
+        expect(config.sources?.[0].type).toBe("website");
+    });
+    test("prefers URL match over name match", () => {
+        const url = "https://example.com";
+        addStash({ target: url, providerType: "website", name: "my-source" });
+        addStash({ target: "https://other.example.com", providerType: "website", name: url });
+        // Should match by URL (first entry), not by name (second entry)
+        const result = removeStash(url);
+        expect(result.removed).toBe(true);
+        expect(result.entry?.name).toBe("my-source");
+        // The second entry (whose name matches the URL) should still exist
+        const config = loadConfig();
+        expect(config.sources).toHaveLength(1);
+        expect(config.sources?.[0].name).toBe(url);
+    });
+    test("prefers path match over name match", () => {
+        const fsPath = createTmpDir("akm-rm-prio-");
+        addStash({ target: fsPath, name: "path-source" });
+        addStash({ target: "https://other.example.com", providerType: "website", name: fsPath });
+        // Should match by path (first entry), not by name (second entry)
+        const result = removeStash(fsPath);
+        expect(result.removed).toBe(true);
+        expect(result.entry?.type).toBe("filesystem");
+    });
+    test("removes http:// URL source", () => {
+        const url = "http://example.com";
+        addStash({ target: url, providerType: "website" });
+        const result = removeStash(url);
+        expect(result.removed).toBe(true);
+        expect(result.entry?.url).toBe(url);
+    });
+    test("returned stashes array reflects new state", () => {
+        const fsPath = createTmpDir("akm-rm-ret-");
+        addStash({ target: fsPath, name: "rm-ret-test" });
+        addStash({ target: "https://keep.example.com", providerType: "website", name: "keep" });
+        const result = removeStash("rm-ret-test");
+        expect(result.sources).toHaveLength(1);
+        expect(result.sources[0].name).toBe("keep");
+    });
+    test("removes filesystem source by relative path that resolves correctly", () => {
+        const fsPath = createTmpDir("akm-rm-rel-");
+        addStash({ target: fsPath });
+        const relativePath = path.relative(process.cwd(), fsPath);
+        const result = removeStash(relativePath);
+        expect(result.removed).toBe(true);
+    });
+});
+// ── listStashes ────────────────────────────────────────────────────────
+describe("listStashes", () => {
+    test("lists empty stash sources", () => {
+        const result = listStashes();
+        expect(result.localSources).toBeDefined();
+        expect(result.sources).toEqual([]);
+        expect(result.remoteSources).toBeUndefined();
+    });
+    test("lists filesystem stash sources", () => {
+        const fsPath = createTmpDir("akm-list-fs-");
+        addStash({ target: fsPath });
+        const result = listStashes();
+        expect(result.sources).toHaveLength(1);
+        expect(result.sources[0].type).toBe("filesystem");
+    });
+    test("lists URL stash sources", () => {
+        addStash({ target: "https://example.com", providerType: "website" });
+        const result = listStashes();
+        expect(result.sources).toHaveLength(1);
+        expect(result.sources[0].type).toBe("website");
+        expect(result.sources[0].url).toBe("https://example.com");
+    });
+    test("lists mixed source types", () => {
+        const fsPath = createTmpDir("akm-list-mixed-");
+        addStash({ target: fsPath });
+        addStash({ target: "https://example.com", providerType: "website" });
+        addStash({ target: "https://custom.example.com", providerType: "custom" });
+        const result = listStashes();
+        expect(result.sources).toHaveLength(3);
+    });
+    test("includes primary stash dir in localSources", () => {
+        const result = listStashes();
+        // The primary stash dir (from AKM_STASH_DIR) should always be first
+        expect(result.localSources.length).toBeGreaterThanOrEqual(1);
+        expect(result.localSources[0].path).toBe(path.resolve(testStashDir));
+    });
+});
+// ── Round-trip integration ──────────────────────────────────────────────────
+describe("round-trip integration", () => {
+    test("add then list then remove filesystem source", () => {
+        const fsPath = createTmpDir("akm-roundtrip-fs-");
+        addStash({ target: fsPath, name: "roundtrip-test" });
+        const listed = listStashes();
+        expect(listed.sources.some((s) => s.name === "roundtrip-test")).toBe(true);
+        removeStash("roundtrip-test");
+        const afterRemove = listStashes();
+        expect(afterRemove.sources.some((s) => s.name === "roundtrip-test")).toBe(false);
+    });
+    test("add then list then remove URL source", () => {
+        const url = "https://roundtrip.example.com";
+        addStash({ target: url, providerType: "website", name: "rt-source" });
+        const listed = listStashes();
+        expect(listed.sources.some((s) => s.name === "rt-source")).toBe(true);
+        removeStash(url);
+        const afterRemove = listStashes();
+        expect(afterRemove.sources.some((s) => s.url === url)).toBe(false);
+    });
+    test("add then list then remove custom provider source", () => {
+        const url = "https://custom-roundtrip.example.com";
+        addStash({
+            target: url,
+            providerType: "my-custom",
+            name: "custom-rt",
+            options: { key: "value" },
+        });
+        const listed = listStashes();
+        const entry = listed.sources.find((s) => s.name === "custom-rt");
+        expect(entry).toBeDefined();
+        expect(entry?.type).toBe("my-custom");
+        expect(entry?.options).toEqual({ key: "value" });
+        removeStash("custom-rt");
+        const afterRemove = listStashes();
+        expect(afterRemove.sources.some((s) => s.name === "custom-rt")).toBe(false);
+    });
+    test("multiple adds and removes maintain order and integrity", () => {
+        const fs1 = createTmpDir("akm-multi-1-");
+        const fs2 = createTmpDir("akm-multi-2-");
+        const url1 = "https://v1.example.com";
+        const url2 = "https://v2.example.com";
+        addStash({ target: fs1, name: "fs1" });
+        addStash({ target: url1, providerType: "website", name: "v1" });
+        addStash({ target: fs2, name: "fs2" });
+        addStash({ target: url2, providerType: "website", name: "v2" });
+        let sources = listStashes().sources;
+        expect(sources).toHaveLength(4);
+        expect(sources.map((s) => s.name)).toEqual(["fs1", "v1", "fs2", "v2"]);
+        // Remove middle entry
+        removeStash("v1");
+        sources = listStashes().sources;
+        expect(sources).toHaveLength(3);
+        expect(sources.map((s) => s.name)).toEqual(["fs1", "fs2", "v2"]);
+        // Remove first entry
+        removeStash("fs1");
+        sources = listStashes().sources;
+        expect(sources).toHaveLength(2);
+        expect(sources.map((s) => s.name)).toEqual(["fs2", "v2"]);
+    });
+});

package/dist/tests/source-providers/filesystem.test.js

@@ -0,0 +1,82 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { resolveSourceProviderFactory } from "../../src/sources/provider-factory";
+// Trigger self-registration
+import "../../src/sources/providers/filesystem";
+const createdTmpDirs = [];
+function createTmpDir(prefix = "akm-fs-") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    createdTmpDirs.push(dir);
+    return dir;
+}
+const originalAkmStashDir = process.env.AKM_STASH_DIR;
+beforeEach(() => {
+    process.env.AKM_STASH_DIR = createTmpDir("akm-fs-stash-");
+});
+afterEach(() => {
+    if (originalAkmStashDir === undefined)
+        delete process.env.AKM_STASH_DIR;
+    else
+        process.env.AKM_STASH_DIR = originalAkmStashDir;
+});
+afterAll(() => {
+    for (const dir of createdTmpDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("FilesystemSourceProvider", () => {
+    test("self-registers as 'filesystem'", () => {
+        expect(resolveSourceProviderFactory("filesystem")).toBeTruthy();
+    });
+    test("init resolves and path returns the configured path", async () => {
+        const factory = resolveSourceProviderFactory("filesystem");
+        expect(factory).toBeTruthy();
+        if (!factory)
+            throw new Error("expected filesystem factory to be registered");
+        const stashDir = createTmpDir("akm-fs-init-");
+        const provider = factory({ type: "filesystem", path: stashDir, name: "mine" });
+        await provider.init({
+            name: "mine",
+            options: {},
+            cacheDir: stashDir,
+            resolveOption: (v) => (typeof v === "string" ? v : undefined),
+        });
+        expect(provider.kind).toBe("filesystem");
+        expect(provider.name).toBe("mine");
+        expect(provider.path()).toBe(stashDir);
+    });
+    test("path() returns the same value across calls (lifetime stability)", () => {
+        const factory = resolveSourceProviderFactory("filesystem");
+        expect(factory).toBeTruthy();
+        if (!factory)
+            throw new Error("expected filesystem factory to be registered");
+        const stashDir = createTmpDir("akm-fs-stable-");
+        const provider = factory({ type: "filesystem", path: stashDir, name: "stable" });
+        const first = provider.path();
+        const second = provider.path();
+        expect(second).toBe(first);
+    });
+    test("filesystem providers have no sync() (content is user-managed)", () => {
+        const factory = resolveSourceProviderFactory("filesystem");
+        expect(factory).toBeTruthy();
+        if (!factory)
+            throw new Error("expected filesystem factory to be registered");
+        const stashDir = createTmpDir("akm-fs-nosync-");
+        const provider = factory({ type: "filesystem", path: stashDir, name: "nosync" });
+        expect(provider.sync).toBeUndefined();
+    });
+    test("provider exposes only the v1 SourceProvider surface", () => {
+        const factory = resolveSourceProviderFactory("filesystem");
+        expect(factory).toBeTruthy();
+        if (!factory)
+            throw new Error("expected filesystem factory to be registered");
+        const stashDir = createTmpDir("akm-fs-iface-");
+        const provider = factory({ type: "filesystem", path: stashDir });
+        expect(provider.search).toBeUndefined();
+        expect(provider.show).toBeUndefined();
+        expect(provider.canShow).toBeUndefined();
+        expect(provider.getContentDir).toBeUndefined();
+    });
+});