@kuznai/inception-engine 0.22.0 → 0.24.0

package/dist/test/unit/revert.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { chmod, mkdir, readFile, rm, symlink, writeFile, } from "node:fs/promises";
+import { chmod, 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";
@@ -29,6 +29,41 @@ describe("planRevert", () => {
         const actions = planRevert(testManifest, ["codex"], "/home/test");
         assert.equal(actions.length, 0);
     });
+    it("includes hook and execution-config reverts for detected agents", () => {
+        const manifest = {
+            ...testManifest,
+            hooks: [
+                {
+                    name: "pre-exec-check",
+                    agents: ["claude-code"],
+                    config: {
+                        hooks: {
+                            PreToolUse: [
+                                {
+                                    matcher: "Bash",
+                                    hooks: [{ type: "command", command: "scripts/check.sh" }],
+                                },
+                            ],
+                        },
+                    },
+                },
+            ],
+            executionConfigs: [
+                {
+                    name: "gemini-safety",
+                    agents: ["gemini-cli"],
+                    config: { safeMode: true },
+                },
+            ],
+        };
+        const actions = planRevert(manifest, ["claude-code", "gemini-cli"], "/home/test");
+        assert.ok(actions.some((action) => action.kind === "config-patch" &&
+            action.agent === "claude-code" &&
+            action.skill === "pre-exec-check"), "expected hook revert action for Claude Code");
+        assert.ok(actions.some((action) => action.kind === "config-patch" &&
+            action.agent === "gemini-cli" &&
+            action.skill === "gemini-safety"), "expected execution config revert action for Gemini CLI");
+    });
 });
 describe("planRevertAll", () => {
     it("creates revert actions for all agents in manifest regardless of detection", () => {
@@ -87,193 +122,59 @@ describe("planRevertAll", () => {
         assert.match(targets.get("antigravity") ?? "", /\.gemini[\\/]antigravity[\\/]skills[\\/]test-skill$/);
         assert.match(targets.get("opencode") ?? "", /opencode[\\/]skills[\\/]test-skill$/);
     });
+    it("includes hook and execution-config reverts for all manifest agents", () => {
+        const manifest = {
+            ...testManifest,
+            hooks: [
+                {
+                    name: "pre-exec-check",
+                    agents: ["claude-code"],
+                    config: {
+                        hooks: {
+                            Stop: [{ hooks: [{ type: "command", command: "notify.sh" }] }],
+                        },
+                    },
+                },
+            ],
+            executionConfigs: [
+                {
+                    name: "gemini-safety",
+                    agents: ["gemini-cli"],
+                    config: { safeMode: true },
+                },
+            ],
+        };
+        const actions = planRevertAll(manifest, "/home/test");
+        assert.ok(actions.some((action) => action.kind === "config-patch" &&
+            action.agent === "claude-code" &&
+            action.skill === "pre-exec-check"), "expected planRevertAll to include Claude hook revert action");
+        assert.ok(actions.some((action) => action.kind === "config-patch" &&
+            action.agent === "gemini-cli" &&
+            action.skill === "gemini-safety"), "expected planRevertAll to include Gemini execution config revert action");
+    });
 });
-describe("executeRevert", { skip: process.platform === "win32" }, () => {
-    it("removes a symlink registered in the deployment registry", async () => {
+describe("executeRevert reserved state protections", () => {
+    it("refuses to modify inception-engine state paths from manifest-managed actions", async () => {
         const home = await makeTmpDir();
-        const sourceDir = await makeTmpDir();
         try {
-            const actions = planRevert(testManifest, ["claude-code"], home);
-            const target = actions[0]?.target;
-            // Create symlink and register in registry
+            const target = path.join(home, ".inception-engine", "registry.json");
             await mkdir(path.dirname(target), { recursive: true });
-            await symlink(sourceDir, target, "dir");
-            await registerDeployment(home, target, {
-                kind: "skill-dir",
-                source: sourceDir,
-                skill: "test-skill",
-                agent: "claude-code",
-                method: "symlink",
-            });
-            assert.ok(await exists(target));
-            const { succeeded, skipped } = await executeRevert(actions, false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(skipped, 0);
-            assert.ok(!(await exists(target)));
-            // Registry entry should be removed
-            const entry = await lookupDeployment(home, target);
-            assert.equal(entry, null);
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(sourceDir, { recursive: true });
-        }
-    });
-    it("removes a copied directory registered in the deployment registry", async () => {
-        const home = await makeTmpDir();
-        try {
-            const actions = planRevert(testManifest, ["claude-code"], home);
-            const target = actions[0]?.target;
-            await mkdir(target, { recursive: true });
-            await writeFile(path.join(target, "SKILL.md"), "test");
-            await registerDeployment(home, target, {
-                kind: "skill-dir",
-                source: "/original/source",
-                skill: "test-skill",
-                agent: "claude-code",
-                method: "copy",
-            });
-            const { succeeded, skipped } = await executeRevert(actions, false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(skipped, 0);
-            assert.ok(!(await exists(target)));
-            // Registry entry should be removed
-            const entry = await lookupDeployment(home, target);
-            assert.equal(entry, null);
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-        }
-    });
-    it("skips missing targets", async () => {
-        const home = await makeTmpDir();
-        try {
-            const actions = planRevert(testManifest, ["claude-code"], home);
-            const { succeeded, skipped } = await executeRevert(actions, false, false, home);
-            assert.equal(succeeded, 0);
-            assert.equal(skipped, 1);
-        }
-        finally {
-            await rm(home, { recursive: true });
-        }
-    });
-    it("records a failure when removal is blocked by permissions", async () => {
-        const home = await makeTmpDir();
-        const sourceDir = await makeTmpDir();
-        const actions = planRevert(testManifest, ["claude-code"], home);
-        const target = actions[0]?.target ?? "";
-        const targetParent = path.dirname(target);
-        try {
-            // Create the target directory and register it
-            await mkdir(target, { recursive: true });
-            await writeFile(path.join(target, "SKILL.md"), "test");
-            await registerDeployment(home, target, {
-                kind: "skill-dir",
-                source: sourceDir,
-                skill: "test-skill",
-                agent: "claude-code",
-                method: "copy",
-            });
-            // Make the parent directory non-writable so rm() fails
-            await chmod(targetParent, 0o555);
-            const { succeeded, skipped, failed } = await executeRevert(actions, false, false, home);
+            await writeFile(target, "{}");
+            const { failed, succeeded } = await executeRevert([
+                {
+                    kind: "file-write",
+                    skill: "state-target",
+                    agent: "claude-code",
+                    target,
+                },
+            ], false, false, home);
             assert.equal(succeeded, 0);
-            assert.equal(skipped, 0);
             assert.equal(failed.length, 1);
-        }
-        finally {
-            await chmod(targetParent, 0o755);
-            await rm(home, { recursive: true, force: true });
-            await rm(sourceDir, { recursive: true, force: true });
-        }
-    });
-    it("does not remove in dry-run mode", async () => {
-        const home = await makeTmpDir();
-        const sourceDir = await makeTmpDir();
-        try {
-            const actions = planRevert(testManifest, ["claude-code"], home);
-            const target = actions[0]?.target;
-            await mkdir(path.dirname(target), { recursive: true });
-            await symlink(sourceDir, target, "dir");
-            await registerDeployment(home, target, {
-                kind: "skill-dir",
-                source: sourceDir,
-                skill: "test-skill",
-                agent: "claude-code",
-                method: "symlink",
-            });
-            const { succeeded } = await executeRevert(actions, true, false, home);
-            assert.equal(succeeded, 1);
-            assert.ok(await exists(target), "symlink should still exist after dry-run");
-            // Registry entry should still exist after dry-run
-            const entry = await lookupDeployment(home, target);
-            assert.ok(entry, "registry entry should still exist after dry-run");
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(sourceDir, { recursive: true });
-        }
-    });
-    it("skips target that exists but is not in registry", async () => {
-        const home = await makeTmpDir();
-        const sourceDir = await makeTmpDir();
-        try {
-            const actions = planRevert(testManifest, ["claude-code"], home);
-            const target = actions[0]?.target;
-            // Create symlink but do NOT register — should be treated as unmanaged
-            await writeFile(path.join(sourceDir, "SKILL.md"), "---");
-            await mkdir(path.dirname(target), { recursive: true });
-            await symlink(sourceDir, target, "dir");
-            const { succeeded, skipped } = await executeRevert(actions, false, false, home);
-            assert.equal(succeeded, 0);
-            assert.equal(skipped, 1);
-            assert.ok(await exists(target), "symlink should still exist — not managed");
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(sourceDir, { recursive: true });
-        }
-    });
-    it("skips directory that exists but is not in registry", async () => {
-        const home = await makeTmpDir();
-        try {
-            const actions = planRevert(testManifest, ["claude-code"], home);
-            const target = actions[0]?.target;
-            await mkdir(target, { recursive: true });
-            await writeFile(path.join(target, "SKILL.md"), "user content");
-            const { succeeded, skipped } = await executeRevert(actions, false, false, home);
-            assert.equal(succeeded, 0);
-            assert.equal(skipped, 1);
-            assert.ok(await exists(target), "directory should still exist — not in registry");
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-        }
-    });
-    it("skips target whose registry entry has mismatched skill or agent", async () => {
-        const home = await makeTmpDir();
-        const sourceDir = await makeTmpDir();
-        try {
-            const actions = planRevert(testManifest, ["claude-code"], home);
-            const target = actions[0]?.target;
-            // Create symlink and register under a different skill/agent
-            await mkdir(path.dirname(target), { recursive: true });
-            await symlink(sourceDir, target, "dir");
-            await registerDeployment(home, target, {
-                kind: "skill-dir",
-                source: sourceDir,
-                skill: "different-skill",
-                agent: "codex",
-                method: "symlink",
-            });
-            const { succeeded, skipped } = await executeRevert(actions, false, false, home);
-            assert.equal(succeeded, 0);
-            assert.equal(skipped, 1);
-            assert.ok(await exists(target), "symlink should still exist — registry entry does not match");
+            assert.match(failed[0]?.error ?? "", /Refusing to modify inception-engine state directory/);
+            assert.equal(await readFile(target, "utf-8"), "{}");
         }
         finally {
             await rm(home, { recursive: true, force: true });
-            await rm(sourceDir, { recursive: true });
         }
     });
 });
@@ -840,9 +741,7 @@ describe("planRevertAll — mcpServers and agentRules", () => {
         assert.ok(agents.includes("codex"));
     });
 });
-describe("executeRevert — mcpServer and agentRule integration", {
-    skip: process.platform === "win32",
-}, () => {
+describe("executeRevert — mcpServer and agentRule integration", () => {
     it("reverts a deployed mcpServer config-patch and unregisters it", async () => {
         const home = await makeTmpDir();
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuznai/inception-engine",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Deploy AI agent skills from a git repo to user home directories",
   "license": "MIT",
   "author": "Damian Piątkowski",

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

@@ -1,245 +0,0 @@
-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 { executeDeploy } from "../../../src/core/deploy.js";
-import { lookupDeployment, registerDeployment, } from "../../../src/core/ownership.js";
-import { executeRevert } from "../../../src/core/revert.js";
-import { exists, makeTmpDir } from "../../helpers/fs.js";
-describe("agentRules repo/workspace file-write (Windows)", {
-    skip: process.platform !== "win32",
-}, () => {
-    it("deploys agentRules with scope repo and registers it", async () => {
-        const home = await makeTmpDir("ie-rules-home");
-        const repo = await makeTmpDir("ie-rules-repo");
-        const sourceDir = await makeTmpDir("ie-rules-source");
-        try {
-            const source = path.join(sourceDir, "CLAUDE.md");
-            await writeFile(source, "# My Rules\n");
-            const target = path.join(repo, "CLAUDE.md");
-            const action = {
-                kind: "file-write",
-                skill: "my-rules",
-                agent: "claude-code",
-                source,
-                target,
-            };
-            const { succeeded, failed } = await executeDeploy([action], false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(failed.length, 0);
-            assert.ok(await exists(target));
-            const entry = await lookupDeployment(home, target);
-            assert.ok(entry !== null);
-            assert.equal(entry?.kind, "file-write");
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(repo, { recursive: true, force: true });
-            await rm(sourceDir, { recursive: true, force: true });
-        }
-    });
-    it("reverts agentRules with scope repo and unregisters it", async () => {
-        const home = await makeTmpDir("ie-rules-home");
-        const repo = await makeTmpDir("ie-rules-repo");
-        try {
-            const source = path.join(repo, "source-CLAUDE.md");
-            const target = path.join(repo, "CLAUDE.md");
-            await writeFile(target, "# My Rules\n");
-            await registerDeployment(home, target, {
-                kind: "file-write",
-                source,
-                skill: "my-rules",
-                agent: "claude-code",
-            });
-            const action = {
-                kind: "file-write",
-                skill: "my-rules",
-                agent: "claude-code",
-                target,
-            };
-            const { succeeded, failed } = await executeRevert([action], false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(failed.length, 0);
-            assert.ok(!(await exists(target)));
-            assert.equal(await lookupDeployment(home, target), null);
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(repo, { recursive: true, force: true });
-        }
-    });
-    it("deploys agentRules with scope workspace and registers it", async () => {
-        const home = await makeTmpDir("ie-rules-home");
-        const workspace = await makeTmpDir("ie-rules-workspace");
-        const sourceDir = await makeTmpDir("ie-rules-source");
-        try {
-            const source = path.join(sourceDir, "CLAUDE.md");
-            await writeFile(source, "# Workspace Rules\n");
-            const target = path.join(workspace, "CLAUDE.md");
-            const action = {
-                kind: "file-write",
-                skill: "my-rules",
-                agent: "claude-code",
-                source,
-                target,
-            };
-            const { succeeded, failed } = await executeDeploy([action], false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(failed.length, 0);
-            assert.ok(await exists(target));
-            const entry = await lookupDeployment(home, target);
-            assert.ok(entry !== null);
-            assert.equal(entry?.kind, "file-write");
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(workspace, { recursive: true, force: true });
-            await rm(sourceDir, { recursive: true, force: true });
-        }
-    });
-    it("reverts agentRules with scope workspace and unregisters it", async () => {
-        const home = await makeTmpDir("ie-rules-home");
-        const workspace = await makeTmpDir("ie-rules-workspace");
-        try {
-            const source = path.join(workspace, "source-CLAUDE.md");
-            const target = path.join(workspace, "CLAUDE.md");
-            await writeFile(target, "# Workspace Rules\n");
-            await registerDeployment(home, target, {
-                kind: "file-write",
-                source,
-                skill: "my-rules",
-                agent: "claude-code",
-            });
-            const action = {
-                kind: "file-write",
-                skill: "my-rules",
-                agent: "claude-code",
-                target,
-            };
-            const { succeeded, failed } = await executeRevert([action], false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(failed.length, 0);
-            assert.ok(!(await exists(target)));
-            assert.equal(await lookupDeployment(home, target), null);
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(workspace, { recursive: true, force: true });
-        }
-    });
-});
-describe("Antigravity frontmatter-emit (Windows)", {
-    skip: process.platform !== "win32",
-}, () => {
-    it("deploys frontmatter-emit for Antigravity and registers it", async () => {
-        const home = await makeTmpDir("ie-fm-home");
-        const repo = await makeTmpDir("ie-fm-repo");
-        try {
-            const target = path.join(repo, ".agents", "rules", "my-mcp.md");
-            const frontmatter = {
-                "mcp-servers": {
-                    "my-mcp": { command: "npx", args: ["-y", "my-mcp-server"] },
-                },
-            };
-            const action = {
-                kind: "frontmatter-emit",
-                skill: "my-mcp",
-                agent: "antigravity",
-                target,
-                frontmatter,
-            };
-            const { succeeded, failed } = await executeDeploy([action], false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(failed.length, 0);
-            assert.ok(await exists(target));
-            const content = await readFile(target, "utf-8");
-            assert.ok(content.includes("mcp-servers:"));
-            const entry = await lookupDeployment(home, target);
-            assert.ok(entry !== null);
-            assert.equal(entry?.kind, "frontmatter-emit");
-            assert.equal(entry.created, true);
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(repo, { recursive: true, force: true });
-        }
-    });
-    it("reverts frontmatter-emit for Antigravity and removes file when no body", async () => {
-        const home = await makeTmpDir("ie-fm-home");
-        const repo = await makeTmpDir("ie-fm-repo");
-        try {
-            const target = path.join(repo, ".agents", "rules", "my-mcp.md");
-            const frontmatter = {
-                "mcp-servers": {
-                    "my-mcp": { command: "npx", args: ["-y", "my-mcp-server"] },
-                },
-            };
-            // Deploy first so the file and registry entry are created.
-            const deployAction = {
-                kind: "frontmatter-emit",
-                skill: "my-mcp",
-                agent: "antigravity",
-                target,
-                frontmatter,
-            };
-            await executeDeploy([deployAction], false, false, home);
-            const action = {
-                kind: "frontmatter-emit",
-                skill: "my-mcp",
-                agent: "antigravity",
-                target,
-            };
-            const { succeeded, failed } = await executeRevert([action], false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(failed.length, 0);
-            assert.ok(!(await exists(target)));
-            assert.equal(await lookupDeployment(home, target), null);
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(repo, { recursive: true, force: true });
-        }
-    });
-    it("reverts frontmatter-emit for Antigravity preserving body when file had prior content", async () => {
-        const home = await makeTmpDir("ie-fm-home");
-        const repo = await makeTmpDir("ie-fm-repo");
-        try {
-            const target = path.join(repo, ".agents", "rules", "my-mcp.md");
-            await mkdir(path.dirname(target), { recursive: true });
-            await writeFile(target, "# My Rules\n");
-            const undoPatch = { "mcp-servers": null };
-            await registerDeployment(home, target, {
-                kind: "frontmatter-emit",
-                patch: {
-                    "mcp-servers": {
-                        "my-mcp": { command: "npx", args: ["-y", "my-mcp-server"] },
-                    },
-                },
-                undoPatch,
-                created: false,
-                hadFrontmatter: false,
-                skill: "my-mcp",
-                agent: "antigravity",
-            });
-            const action = {
-                kind: "frontmatter-emit",
-                skill: "my-mcp",
-                agent: "antigravity",
-                target,
-            };
-            const { succeeded, failed } = await executeRevert([action], false, false, home);
-            assert.equal(succeeded, 1);
-            assert.equal(failed.length, 0);
-            // File should still exist because it had body content.
-            assert.ok(await exists(target));
-            const content = await readFile(target, "utf-8");
-            assert.ok(!content.includes("mcp-servers:"));
-            assert.ok(content.includes("My Rules"));
-            assert.equal(await lookupDeployment(home, target), null);
-        }
-        finally {
-            await rm(home, { recursive: true, force: true });
-            await rm(repo, { recursive: true, force: true });
-        }
-    });
-});

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

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