@kuznai/inception-engine 0.18.0 → 0.20.0

package/dist/test/helpers/skill-dir.js

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { lstat, mkdir, readFile, readlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { defaultRegistryPersistence } from "../../src/core/ownership.js";
+import { exists } from "./fs.js";
+export async function createSkillSource(baseDir, skillPath = "skills/test-skill", skillBody = "---\nname: test\ndescription: Test skill\n---\n# Test") {
+    const fullPath = path.join(baseDir, skillPath);
+    await mkdir(fullPath, { recursive: true });
+    await writeFile(path.join(fullPath, "SKILL.md"), skillBody);
+    return fullPath;
+}
+export const testSkillManifest = {
+    skills: [
+        {
+            name: "test-skill",
+            path: "skills/test-skill",
+            agents: ["claude-code"],
+        },
+    ],
+    files: [],
+    configs: [],
+    mcpServers: [],
+    agentRules: [],
+    permissions: [],
+    agentDefinitions: [],
+};
+export function createFailingRegistryPersistence(error = new Error("simulated registry persistence failure")) {
+    return {
+        load(home) {
+            return defaultRegistryPersistence.load(home);
+        },
+        async save() {
+            throw error;
+        },
+    };
+}
+export async function assertSymlinkTarget(target, source) {
+    assert.ok(await exists(target), "expected target to exist");
+    assert.ok((await lstat(target)).isSymbolicLink(), "expected a symlink target");
+    assert.equal(await readlink(target), source);
+}
+export async function assertCopyTarget(target, expectedSkillMd) {
+    assert.ok(await exists(target), "expected target to exist");
+    assert.ok(!(await lstat(target)).isSymbolicLink(), "expected a copied directory");
+    assert.equal(await readFile(path.join(target, "SKILL.md"), "utf-8"), expectedSkillMd);
+}

package/dist/test/os/cross-platform/cross-platform.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/os/cross-platform/cross-platform.test.js

@@ -0,0 +1,328 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { AGENT_REGISTRY } from "../../../src/config/agents.js";
+import { getDeployMethod, lookupHomeForUserWith, resolveAgentDetectPathFor, resolveAgentSkillPathFor, } from "../../../src/core/resolve.js";
+import { resolveTargetTemplate } from "../../../src/core/runtime-paths.js";
+import { UserError } from "../../../src/errors.js";
+const HOME = "/home/u";
+const SKILL = "s";
+const posixJoin = path.posix.join;
+const joinLikeRoot = (root, ...segments) => (root.includes("\\") || /^[a-zA-Z]:/.test(root)
+    ? path.win32
+    : path.posix).join(root, ...segments);
+function getAgent(id) {
+    const agent = AGENT_REGISTRY.find((a) => a.id === id);
+    assert.ok(agent, `agent "${id}" not found in AGENT_REGISTRY`);
+    return agent;
+}
+// ---------------------------------------------------------------------------
+// resolveAgentSkillPathFor — POSIX
+// ---------------------------------------------------------------------------
+describe("resolveAgentSkillPathFor — posix", () => {
+    const p = "posix";
+    it("claude-code", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".claude", "skills", SKILL));
+    });
+    it("codex", () => {
+        const agent = getAgent("codex");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".codex", "skills", SKILL));
+    });
+    it("gemini-cli", () => {
+        const agent = getAgent("gemini-cli");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "skills", SKILL));
+    });
+    it("antigravity", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "antigravity", "skills", SKILL));
+    });
+    it("opencode defaults to home/.config when XDG_CONFIG_HOME is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            delete process.env.XDG_CONFIG_HOME;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode uses XDG_CONFIG_HOME when set to an absolute path", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin("/custom/config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode ignores relative XDG_CONFIG_HOME and falls back to home/.config", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "relative/path";
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentSkillPathFor — Windows
+// ---------------------------------------------------------------------------
+describe("resolveAgentSkillPathFor — windows", () => {
+    const p = "windows";
+    it("claude-code uses home (same template as posix)", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".claude", "skills", SKILL));
+    });
+    it("opencode uses APPDATA when set", () => {
+        const agent = getAgent("opencode");
+        const appdata = "C:\\Users\\u\\AppData\\Roaming";
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = appdata;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), joinLikeRoot(appdata, "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("opencode falls back to home/AppData/Roaming when APPDATA is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.APPDATA;
+        try {
+            delete process.env.APPDATA;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, "AppData", "Roaming", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("antigravity uses home (same template as posix)", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "antigravity", "skills", SKILL));
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentDetectPathFor — POSIX
+// ---------------------------------------------------------------------------
+describe("resolveAgentDetectPathFor — posix", () => {
+    const p = "posix";
+    it("claude-code", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".claude"));
+    });
+    it("opencode detect path defaults to home/.config when XDG_CONFIG_HOME is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            delete process.env.XDG_CONFIG_HOME;
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".config", "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode detect path uses XDG_CONFIG_HOME when set to an absolute path", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin("/custom/config", "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("antigravity has nested detect path", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".gemini", "antigravity"));
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentDetectPathFor — Windows
+// ---------------------------------------------------------------------------
+describe("resolveAgentDetectPathFor — windows", () => {
+    const p = "windows";
+    it("opencode uses APPDATA when set", () => {
+        const agent = getAgent("opencode");
+        const appdata = "C:\\Users\\u\\AppData\\Roaming";
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = appdata;
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), joinLikeRoot(appdata, "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("claude-code uses home (same template as posix)", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".claude"));
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — getent path (linux)
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — getent (linux)", () => {
+    const platform = "linux";
+    const noopRead = readFileSync; // won't be called in success cases
+    it("returns home from valid getent output", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "alice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, noopRead), "/home/alice");
+    });
+    it("falls through on getent failure and reads /etc/passwd", () => {
+        const execFileFn = ((_cmd, _args, _opts) => {
+            throw new Error("getent: command not found");
+        });
+        const readFileFn = ((_p, _enc) => "root:x:0:0:root:/root:/bin/bash\nalice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/home/alice");
+    });
+    it("falls through when getent returns malformed output (no 6th field)", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "badinput");
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/home/alice");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — dscl path (darwin)
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — dscl (darwin)", () => {
+    const platform = "darwin";
+    it("returns home from valid dscl output", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "NFSHomeDirectory: /Users/alice\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileSync), "/Users/alice");
+    });
+    it("falls through on dscl failure and reads /etc/passwd", () => {
+        const execFileFn = ((_cmd, _args, _opts) => {
+            throw new Error("dscl: record not found");
+        });
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/Users/alice:/bin/zsh\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/Users/alice");
+    });
+    it("falls through when dscl returns non-absolute home", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "NFSHomeDirectory: \n");
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/Users/alice:/bin/zsh\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/Users/alice");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — /etc/passwd fallback
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — /etc/passwd fallback", () => {
+    const platform = "linux";
+    const throwExec = ((_cmd, _args, _opts) => {
+        throw new Error("getent absent");
+    });
+    it("finds user among multiple users", () => {
+        const readFileFn = ((_p, _enc) => "root:x:0:0:root:/root:/bin/bash\nalice:x:1000:1000::/home/alice:/bin/bash\nbob:x:1001:1001::/home/bob:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("bob", platform, throwExec, readFileFn), "/home/bob");
+    });
+    it("ignores lines with wrong username", () => {
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/home/alice:/bin/bash\nbob:x:1001:1001::/home/bob:/bin/bash\n");
+        // looking up "alice", should not return bob's home
+        assert.equal(lookupHomeForUserWith("alice", platform, throwExec, readFileFn), "/home/alice");
+    });
+    it("ignores passwd lines with non-absolute home field", () => {
+        // alice's home field is empty — should fall through to error
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000:::");
+        assert.throws(() => lookupHomeForUserWith("alice", platform, throwExec, readFileFn), (err) => err instanceof UserError && err.code === "RESOLVE_FAILED");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — all methods fail
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — all methods fail", () => {
+    it("throws UserError with code RESOLVE_FAILED", () => {
+        const throwExec = ((_cmd, _args, _opts) => {
+            throw new Error("no exec");
+        });
+        const throwRead = ((_p, _enc) => {
+            throw new Error("no read");
+        });
+        assert.throws(() => lookupHomeForUserWith("alice", "linux", throwExec, throwRead), (err) => {
+            assert.ok(err instanceof UserError);
+            assert.equal(err.code, "RESOLVE_FAILED");
+            assert.match(err.message, /Cannot determine home directory/);
+            return true;
+        });
+    });
+});
+describe("resolveTargetTemplate", () => {
+    it("uses APPDATA for Windows-style target templates", () => {
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = "C:\\Users\\u\\AppData\\Roaming";
+            assert.equal(resolveTargetTemplate("{appdata}\\opencode\\AGENTS.md", "/unused/home"), "C:\\Users\\u\\AppData\\Roaming\\opencode\\AGENTS.md");
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("falls back to home/AppData/Roaming when APPDATA is unset", () => {
+        const saved = process.env.APPDATA;
+        try {
+            delete process.env.APPDATA;
+            assert.equal(resolveTargetTemplate("{appdata}/opencode/AGENTS.md", "/home/u"), `${posixJoin("/home/u", "AppData", "Roaming")}/opencode/AGENTS.md`);
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("uses absolute XDG_CONFIG_HOME and ignores relative values", () => {
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveTargetTemplate("{xdg_config}/opencode/AGENTS.md", "/home/u"), "/custom/config/opencode/AGENTS.md");
+            process.env.XDG_CONFIG_HOME = "relative/path";
+            assert.equal(resolveTargetTemplate("{xdg_config}/opencode/AGENTS.md", "/home/u"), `${posixJoin("/home/u", ".config")}/opencode/AGENTS.md`);
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+});
+describe("getDeployMethod", () => {
+    it("returns a host-appropriate skill-dir deployment method", () => {
+        assert.equal(getDeployMethod(), process.platform === "win32" ? "copy" : "symlink");
+    });
+});

package/dist/test/os/posix/skill-dir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/os/posix/skill-dir.test.js

@@ -0,0 +1,19 @@
+import { describe } from "node:test";
+import { assertSymlinkTarget } from "../../helpers/skill-dir.js";
+import { registerSharedSkillDirDeployScenarios, registerSharedSkillDirRevertScenarios, } from "../../helpers/skill-dir-scenarios.js";
+describe("skill-dir deploy and revert (POSIX)", {
+    skip: process.platform === "win32",
+}, () => {
+    registerSharedSkillDirDeployScenarios({
+        method: "symlink",
+        async assertManagedTarget(target, source) {
+            await assertSymlinkTarget(target, source);
+        },
+    });
+    registerSharedSkillDirRevertScenarios({
+        method: "symlink",
+        async assertManagedTarget(target, source) {
+            await assertSymlinkTarget(target, source);
+        },
+    });
+});

package/dist/test/os/windows/revert-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/os/windows/revert-integration.test.js

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { lookupDeployment, registerDeployment, } from "../../../src/core/ownership.js";
+import { executeRevert } from "../../../src/core/revert.js";
+import { exists, makeTmpDir } from "../../helpers/fs.js";
+describe("revert integration (Windows)", {
+    skip: process.platform !== "win32",
+}, () => {
+    it("reverts a deployed mcpServer config-patch and unregisters it", async () => {
+        const home = await makeTmpDir("ie-revert-home");
+        try {
+            const configFile = path.join(home, ".claude.json");
+            await writeFile(configFile, JSON.stringify({
+                other: "value",
+                mcpServers: { "my-mcp": { command: "npx" } },
+            }));
+            await registerDeployment(home, configFile, {
+                kind: "config-patch",
+                patch: { mcpServers: { "my-mcp": { command: "npx" } } },
+                undoPatch: { mcpServers: null },
+                skill: "my-mcp",
+                agent: "claude-code",
+            });
+            const action = {
+                kind: "config-patch",
+                skill: "my-mcp",
+                agent: "claude-code",
+                target: configFile,
+            };
+            const { succeeded, failed } = await executeRevert([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.deepEqual(JSON.parse(await readFile(configFile, "utf-8")), {
+                other: "value",
+            });
+            assert.equal(await lookupDeployment(home, configFile), null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("reverts a deployed agentRule file-write and unregisters it", async () => {
+        const home = await makeTmpDir("ie-revert-home");
+        try {
+            const rulesFile = path.join(home, ".claude", "CLAUDE.md");
+            await mkdir(path.dirname(rulesFile), { recursive: true });
+            await writeFile(rulesFile, "# My Rules\n");
+            await registerDeployment(home, rulesFile, {
+                kind: "file-write",
+                source: "/some/source/CLAUDE.md",
+                skill: "my-rules",
+                agent: "claude-code",
+            });
+            const action = {
+                kind: "file-write",
+                skill: "my-rules",
+                agent: "claude-code",
+                target: rulesFile,
+            };
+            const { succeeded, failed } = await executeRevert([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(!(await exists(rulesFile)));
+            assert.equal(await lookupDeployment(home, rulesFile), null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+});

package/dist/test/os/windows/skill-dir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/os/windows/skill-dir.test.js

@@ -0,0 +1,19 @@
+import { describe } from "node:test";
+import { assertCopyTarget } from "../../helpers/skill-dir.js";
+import { registerSharedSkillDirDeployScenarios, registerSharedSkillDirRevertScenarios, } from "../../helpers/skill-dir-scenarios.js";
+describe("skill-dir deploy and revert (Windows)", {
+    skip: process.platform !== "win32",
+}, () => {
+    registerSharedSkillDirDeployScenarios({
+        method: "copy",
+        async assertManagedTarget(target, _source, expectedSkillMd) {
+            await assertCopyTarget(target, expectedSkillMd);
+        },
+    });
+    registerSharedSkillDirRevertScenarios({
+        method: "copy",
+        async assertManagedTarget(target, _source, expectedSkillMd) {
+            await assertCopyTarget(target, expectedSkillMd);
+        },
+    });
+});

package/dist/test/unit/adapters.test.d.ts

@@ -0,0 +1 @@
+export {};