akm-cli 0.6.0 → 0.7.0-rc1

package/dist/tests/commands/remember.test.js

@@ -0,0 +1,97 @@
+/**
+ * remember --target tests
+ *
+ * Verifies the `--target` flag added to `akm remember` per v1 implementation
+ * plan §6 decision 3. Resolution order is:
+ *   --target → defaultWriteTarget → working stash → ConfigError
+ *
+ * These tests exercise the explicit-target path:
+ *   - resolves to a configured filesystem source by name
+ *   - errors on unknown target names (UsageError)
+ *   - errors on non-writable targets (ConfigError)
+ */
+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;
+}
+function writeConfig(configDir, body) {
+    const akmDir = path.join(configDir, "akm");
+    fs.mkdirSync(akmDir, { recursive: true });
+    fs.writeFileSync(path.join(akmDir, "config.json"), JSON.stringify(body, null, 2), "utf8");
+}
+function runCli(args, options) {
+    const stashDir = options.stashDir ?? makeTempDir("akm-remember-stash-");
+    const xdgCache = makeTempDir("akm-remember-cache-");
+    const result = spawnSync("bun", [CLI, ...args], {
+        encoding: "utf8",
+        timeout: 30_000,
+        input: options.input,
+        env: {
+            ...process.env,
+            AKM_STASH_DIR: stashDir,
+            AKM_CONFIG_DIR: path.join(options.configDir, "akm"),
+            XDG_CACHE_HOME: xdgCache,
+        },
+    });
+    return { stashDir, result };
+}
+afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("remember --target", () => {
+    test("--target resolves to a configured filesystem source", () => {
+        const configDir = makeTempDir("akm-remember-config-");
+        const targetDir = makeTempDir("akm-remember-target-");
+        writeConfig(configDir, {
+            semanticSearchMode: "off",
+            sources: [{ type: "filesystem", name: "writable-target", path: targetDir, writable: true }],
+        });
+        const { stashDir, result } = runCli(["remember", "Pinned context for the rollout", "--target", "writable-target"], {
+            configDir,
+        });
+        expect(result.status).toBe(0);
+        const json = JSON.parse(result.stdout);
+        expect(json.ok).toBe(true);
+        expect(json.ref).toBe("memory:pinned-context-for-the-rollout");
+        // The memory must land in the explicit target — NOT the working stash.
+        const expectedPath = path.join(targetDir, "memories", "pinned-context-for-the-rollout.md");
+        expect(json.path).toBe(expectedPath);
+        expect(fs.existsSync(expectedPath)).toBe(true);
+        expect(fs.existsSync(path.join(stashDir, "memories", "pinned-context-for-the-rollout.md"))).toBe(false);
+    });
+    test("--target with an unknown source name throws a usage error", () => {
+        const configDir = makeTempDir("akm-remember-config-");
+        const targetDir = makeTempDir("akm-remember-target-");
+        writeConfig(configDir, {
+            semanticSearchMode: "off",
+            sources: [{ type: "filesystem", name: "real-target", path: targetDir, writable: true }],
+        });
+        const { result } = runCli(["remember", "won't be written", "--target", "nope"], { configDir });
+        expect(result.status).toBe(2);
+        const json = JSON.parse(result.stderr);
+        expect(json.error).toContain('No source named "nope" is configured');
+        expect(json.error).toContain("--target must reference a source name");
+    });
+    test("--target on a non-writable source throws a config error", () => {
+        const configDir = makeTempDir("akm-remember-config-");
+        const targetDir = makeTempDir("akm-remember-target-");
+        writeConfig(configDir, {
+            semanticSearchMode: "off",
+            sources: [{ type: "filesystem", name: "read-only", path: targetDir, writable: false }],
+        });
+        const { result } = runCli(["remember", "won't be written", "--target", "read-only"], { configDir });
+        expect(result.status).not.toBe(0);
+        const json = JSON.parse(result.stderr);
+        expect(json.error).toContain("source read-only is not writable");
+    });
+});

package/dist/tests/commands/scope-flags.test.js

@@ -0,0 +1,300 @@
+/**
+ * Native scoping flags (#202) — frontmatter shape, search filters, show scope.
+ *
+ * Verifies:
+ *   - `akm remember --user --agent --run --channel` writes the canonical
+ *     `scope_*` top-level frontmatter keys.
+ *   - `akm search --filter k=v` narrows results without changing ranking.
+ *   - `akm show --scope k=v` resolves to scoped assets and rejects
+ *     out-of-scope ones with NotFoundError.
+ *   - Legacy memories without scope keys still match unfiltered queries.
+ */
+import { afterAll, afterEach, beforeEach, 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 { buildMemoryFrontmatter } from "../../src/commands/remember";
+import { akmSearch, entryMatchesScopeFilters, parseScopeFilterFlags } from "../../src/commands/search";
+import { akmShowUnified } from "../../src/commands/show";
+import { saveConfig } from "../../src/core/config";
+import { NotFoundError, UsageError } from "../../src/core/errors";
+import { parseFrontmatter } from "../../src/core/frontmatter";
+import { akmIndex } from "../../src/indexer/indexer";
+const CLI = path.join(__dirname, "..", "..", "src", "cli.ts");
+const createdTmpDirs = [];
+function createTmpDir(prefix = "akm-scope-") {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    createdTmpDirs.push(dir);
+    return dir;
+}
+function writeFile(filePath, content = "") {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, content);
+}
+function tmpStash() {
+    const dir = createTmpDir("akm-scope-stash-");
+    for (const sub of ["skills", "commands", "agents", "knowledge", "scripts", "memories"]) {
+        fs.mkdirSync(path.join(dir, sub), { recursive: true });
+    }
+    return dir;
+}
+afterAll(() => {
+    for (const dir of createdTmpDirs) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+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 = "";
+beforeEach(() => {
+    testCacheDir = createTmpDir("akm-scope-cache-");
+    testConfigDir = createTmpDir("akm-scope-config-");
+    process.env.XDG_CACHE_HOME = testCacheDir;
+    process.env.XDG_CONFIG_HOME = testConfigDir;
+});
+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;
+});
+// ── Pure-function tests (no spawn) ────────────────────────────────────────
+describe("buildMemoryFrontmatter — scope keys", () => {
+    test("emits scope_* top-level keys when scope is supplied", () => {
+        const block = buildMemoryFrontmatter({
+            tags: ["t"],
+            scope: { user: "alice", agent: "claude" },
+        });
+        expect(block).toContain("scope_user: alice");
+        expect(block).toContain("scope_agent: claude");
+        expect(block).not.toContain("scope_run");
+        expect(block).not.toContain("scope_channel");
+        // Frontmatter must be valid YAML
+        const parsed = parseFrontmatter(`${block}\nbody\n`);
+        expect(parsed.data.scope_user).toBe("alice");
+        expect(parsed.data.scope_agent).toBe("claude");
+    });
+    test("trims and drops empty scope values", () => {
+        const block = buildMemoryFrontmatter({
+            scope: { user: "  ", agent: "alice", run: "" },
+        });
+        expect(block).not.toContain("scope_user");
+        expect(block).not.toContain("scope_run");
+        expect(block).toContain("scope_agent: alice");
+    });
+    test("legacy frontmatter (no scope) round-trips unchanged", () => {
+        const block = buildMemoryFrontmatter({ tags: ["legacy"] });
+        expect(block).not.toContain("scope_");
+        const parsed = parseFrontmatter(`${block}\nbody\n`);
+        expect(parsed.data.scope_user).toBeUndefined();
+        expect(parsed.data.tags).toEqual(["legacy"]);
+    });
+});
+describe("parseScopeFilterFlags", () => {
+    test("parses k=v tokens into a scope filter", () => {
+        const filters = parseScopeFilterFlags(["user=alice", "channel=ops"], "--filter");
+        expect(filters).toEqual({ user: "alice", channel: "ops" });
+    });
+    test("rejects unknown keys with UsageError", () => {
+        let captured;
+        try {
+            parseScopeFilterFlags(["foo=bar"], "--filter");
+        }
+        catch (err) {
+            captured = err;
+        }
+        expect(captured).toBeInstanceOf(UsageError);
+        expect(captured.message).toMatch(/Unknown scope key/);
+        // Spec: UsageError → exit 2 and {ok:false, error, code} envelope on stderr.
+        const result = spawnSync("bun", [CLI, "search", "foo", "--filter", "foo=bar"], {
+            encoding: "utf8",
+            timeout: 30_000,
+            env: {
+                ...process.env,
+                AKM_STASH_DIR: tmpStash(),
+                AKM_CONFIG_DIR: path.join(createTmpDir("akm-scope-config-"), "akm"),
+                XDG_CACHE_HOME: createTmpDir("akm-scope-cache-"),
+            },
+        });
+        expect(result.status).toBe(2); // EXIT_USAGE
+        const envelope = JSON.parse(result.stderr);
+        expect(envelope.ok).toBe(false);
+        expect(typeof envelope.error).toBe("string");
+        expect(envelope.error).toMatch(/Unknown scope key/);
+    });
+    test("rejects malformed tokens", () => {
+        expect(() => parseScopeFilterFlags(["nope"], "--filter")).toThrow(/Expected key=value/);
+    });
+    test("rejects empty values", () => {
+        expect(() => parseScopeFilterFlags(["user="], "--filter")).toThrow(/non-empty value/);
+    });
+    test("returns undefined for empty input", () => {
+        expect(parseScopeFilterFlags([], "--filter")).toBeUndefined();
+    });
+});
+describe("entryMatchesScopeFilters", () => {
+    test("returns true when no filter supplied (legacy entries match)", () => {
+        expect(entryMatchesScopeFilters(undefined, undefined)).toBe(true);
+        expect(entryMatchesScopeFilters({ user: "alice" }, undefined)).toBe(true);
+    });
+    test("returns false when entry lacks the filtered key", () => {
+        expect(entryMatchesScopeFilters(undefined, { user: "alice" })).toBe(false);
+        expect(entryMatchesScopeFilters({ agent: "claude" }, { user: "alice" })).toBe(false);
+    });
+    test("AND-joins multiple filter keys", () => {
+        const scope = { user: "alice", agent: "claude" };
+        expect(entryMatchesScopeFilters(scope, { user: "alice", agent: "claude" })).toBe(true);
+        expect(entryMatchesScopeFilters(scope, { user: "alice", agent: "other" })).toBe(false);
+    });
+});
+// ── End-to-end via akmIndex + akmSearch / akmShow ─────────────────────────
+describe("akm search --filter narrows by scope", () => {
+    test("filter user=alice returns only alice's memory", async () => {
+        const stashDir = tmpStash();
+        process.env.AKM_STASH_DIR = stashDir;
+        saveConfig({ semanticSearchMode: "off" });
+        writeFile(path.join(stashDir, "memories", "alice-note.md"), "---\ntags: [deployment]\ndescription: alice deployment note\nscope_user: alice\n---\nAlice deployment context\n");
+        writeFile(path.join(stashDir, "memories", "bob-note.md"), "---\ntags: [deployment]\ndescription: bob deployment note\nscope_user: bob\n---\nBob deployment context\n");
+        writeFile(path.join(stashDir, "memories", "legacy-note.md"), "---\ntags: [deployment]\ndescription: legacy deployment note\n---\nLegacy memory with no scope\n");
+        await akmIndex({ stashDir, full: true });
+        // Unscoped query sees all three memories
+        const all = await akmSearch({ query: "deployment", source: "stash" });
+        const allLocal = all.hits.filter((h) => h.type !== "registry");
+        const allNames = allLocal.map((h) => h.name).sort();
+        expect(allNames).toContain("alice-note");
+        expect(allNames).toContain("bob-note");
+        // Filter user=alice — only alice's memory
+        const filtered = await akmSearch({
+            query: "deployment",
+            source: "stash",
+            filters: { user: "alice" },
+        });
+        const filteredLocal = filtered.hits.filter((h) => h.type !== "registry");
+        const filteredNames = filteredLocal.map((h) => h.name);
+        expect(filteredNames).toEqual(["alice-note"]);
+    });
+    test("legacy memories without scope still match unfiltered queries", async () => {
+        const stashDir = tmpStash();
+        process.env.AKM_STASH_DIR = stashDir;
+        saveConfig({ semanticSearchMode: "off" });
+        writeFile(path.join(stashDir, "memories", "legacy.md"), "---\ntags: [legacy]\ndescription: legacy memory description\n---\nLegacy memory without scope keys\n");
+        await akmIndex({ stashDir, full: true });
+        const result = await akmSearch({ query: "legacy", source: "stash" });
+        const hits = result.hits.filter((h) => h.type !== "registry");
+        expect(hits.some((h) => h.name === "legacy")).toBe(true);
+    });
+    test("scope filter on a key the entry lacks excludes it", async () => {
+        const stashDir = tmpStash();
+        process.env.AKM_STASH_DIR = stashDir;
+        saveConfig({ semanticSearchMode: "off" });
+        writeFile(path.join(stashDir, "memories", "legacy.md"), "---\ntags: [legacy]\ndescription: legacy memory description\n---\nLegacy memory\n");
+        await akmIndex({ stashDir, full: true });
+        const result = await akmSearch({
+            query: "legacy",
+            source: "stash",
+            filters: { user: "alice" },
+        });
+        const hits = result.hits.filter((h) => h.type !== "registry");
+        expect(hits.length).toBe(0);
+    });
+});
+describe("akm show --scope narrows resolution", () => {
+    test("returns the asset when scope matches", async () => {
+        const stashDir = tmpStash();
+        process.env.AKM_STASH_DIR = stashDir;
+        saveConfig({ semanticSearchMode: "off" });
+        writeFile(path.join(stashDir, "memories", "scoped.md"), "---\ntags: [scoped]\nscope_user: alice\nscope_agent: claude\n---\nAlice's note\n");
+        await akmIndex({ stashDir, full: true });
+        const result = await akmShowUnified({
+            ref: "memory:scoped",
+            scope: { user: "alice" },
+        });
+        expect(result.name).toBe("scoped");
+    });
+    test("throws NotFoundError when scope does not match and body content is not leaked", async () => {
+        const stashDir = tmpStash();
+        process.env.AKM_STASH_DIR = stashDir;
+        saveConfig({ semanticSearchMode: "off" });
+        const SECRET_BODY = "ALICE_SECRET_DEPLOY_TOKEN_XYZ123";
+        writeFile(path.join(stashDir, "memories", "scoped.md"), `---\ntags: [scoped]\nscope_user: alice\n---\n${SECRET_BODY}\n`);
+        await akmIndex({ stashDir, full: true });
+        let thrown;
+        let returned;
+        try {
+            returned = await akmShowUnified({ ref: "memory:scoped", scope: { user: "bob" } });
+        }
+        catch (err) {
+            thrown = err;
+        }
+        expect(returned).toBeUndefined();
+        expect(thrown).toBeInstanceOf(NotFoundError);
+        // Crucial leak-prevention guarantee: the out-of-scope body must NOT appear
+        // anywhere in the thrown error's message, name, or stack.
+        const err = thrown;
+        expect(err.message).not.toContain(SECRET_BODY);
+        expect(err.name).not.toContain(SECRET_BODY);
+        expect(String(err.stack ?? "")).not.toContain(SECRET_BODY);
+        expect(JSON.stringify({ ok: false, error: err.message })).not.toContain(SECRET_BODY);
+    });
+    test("throws NotFoundError when asset has no scope but a scope filter is supplied", async () => {
+        const stashDir = tmpStash();
+        process.env.AKM_STASH_DIR = stashDir;
+        saveConfig({ semanticSearchMode: "off" });
+        writeFile(path.join(stashDir, "memories", "legacy.md"), "---\ntags: [legacy]\n---\nLegacy\n");
+        await akmIndex({ stashDir, full: true });
+        await expect(akmShowUnified({ ref: "memory:legacy", scope: { user: "alice" } })).rejects.toBeInstanceOf(NotFoundError);
+    });
+});
+// ── CLI smoke test ────────────────────────────────────────────────────────
+describe("akm remember --user / --agent / --run / --channel (CLI)", () => {
+    test("persists all four scope_* keys to frontmatter", () => {
+        const stashDir = tmpStash();
+        const configDir = createTmpDir("akm-scope-config-");
+        const xdgCache = createTmpDir("akm-scope-cache-");
+        const result = spawnSync("bun", [
+            CLI,
+            "remember",
+            "Multi-tenant memory",
+            "--user",
+            "alice",
+            "--agent",
+            "claude",
+            "--run",
+            "run-42",
+            "--channel",
+            "#ops",
+        ], {
+            encoding: "utf8",
+            timeout: 30_000,
+            env: {
+                ...process.env,
+                AKM_STASH_DIR: stashDir,
+                AKM_CONFIG_DIR: path.join(configDir, "akm"),
+                XDG_CACHE_HOME: xdgCache,
+            },
+        });
+        expect(result.status).toBe(0);
+        const parsed = JSON.parse(result.stdout);
+        expect(parsed.ok).toBe(true);
+        const written = fs.readFileSync(parsed.path, "utf8");
+        expect(written).toContain("scope_user: alice");
+        expect(written).toContain("scope_agent: claude");
+        expect(written).toContain("scope_run: run-42");
+        expect(written).toContain('scope_channel: "#ops"');
+        // Body content preserved
+        expect(written).toContain("Multi-tenant memory");
+        // Tags are NOT required when only scope is supplied
+        expect(written).not.toContain("tags:");
+    });
+});