@kuznai/inception-engine 0.22.0 → 0.24.0

package/dist/test/unit/adapters.test.js

@@ -2,9 +2,10 @@ import assert from "node:assert/strict";
 import { realpath, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { describe, it } from "node:test";
+import { compileHookActions } from "../../src/core/adapters/hooks.js";
 import { compileMcpServerActions } from "../../src/core/adapters/mcp.js";
-import { compilePermissionsActions } from "../../src/core/adapters/permissions.js";
-import { compileAgentRuleActions } from "../../src/core/adapters/rules.js";
+import { compilePermissionsActions, compilePermissionsReverts, } from "../../src/core/adapters/permissions.js";
+import { compileAgentRuleActions, compileAgentRuleReverts, } from "../../src/core/adapters/rules.js";
 import { makeTmpDir } from "../helpers/fs.js";
 import { assertPathEndsWith, normalizeSlashes } from "../helpers/path.js";
 describe("compileMcpServerActions", () => {
@@ -354,6 +355,115 @@ describe("compileAgentRuleActions", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("scope copilot-repo: returns file-write action targeting {repo}/.github/copilot-instructions.md", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "copilot.md"), "# Copilot rules");
+            const repo = "/repo/myproject";
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "copilot-main",
+                agents: ["github-copilot"],
+                path: "copilot.md",
+                scope: "copilot-repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", repo);
+            assert.equal(actions.length, 1);
+            assert.equal(warnings.length, 0);
+            const action = actions[0];
+            assert.equal(action.kind, "file-write");
+            assert.equal(action.agent, "github-copilot");
+            assert.equal(normalizeSlashes(action.target), `${repo}/.github/copilot-instructions.md`, `expected target at {repo}/.github/copilot-instructions.md, got: ${action.target}`);
+            assert.equal(action.confidence, "documented");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("scope copilot-scoped: returns file-write action with {name} substituted in path", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "typescript.md"), "# TypeScript rules");
+            const repo = "/repo/myproject";
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "typescript",
+                agents: ["github-copilot"],
+                path: "typescript.md",
+                scope: "copilot-scoped",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", repo);
+            assert.equal(actions.length, 1);
+            assert.equal(warnings.length, 0);
+            const action = actions[0];
+            assert.equal(action.kind, "file-write");
+            assert.equal(action.agent, "github-copilot");
+            assert.equal(normalizeSlashes(action.target), `${repo}/.github/instructions/typescript.instructions.md`, `expected target at {repo}/.github/instructions/typescript.instructions.md, got: ${action.target}`);
+            assert.equal(action.confidence, "documented");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("scope copilot-repo: returns warning when no repo path provided", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "copilot.md"), "# Copilot rules");
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "copilot-main",
+                agents: ["github-copilot"],
+                path: "copilot.md",
+                scope: "copilot-repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test");
+            assert.equal(actions.length, 0);
+            assert.equal(warnings.length, 1);
+            assert.equal(warnings[0]?.kind, "confidence");
+            assert.match(warnings[0]?.message ?? "", /copilot-repo/);
+            assert.match(warnings[0]?.message ?? "", /repository path/);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("scope copilot-repo: non-github-copilot agents get unsupported warning", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "copilot.md"), "# Copilot rules");
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "copilot-main",
+                agents: ["claude-code"],
+                path: "copilot.md",
+                scope: "copilot-repo",
+            }, dir, dir, realRoot, ["claude-code"], "/home/test", "/repo/test");
+            assert.equal(actions.length, 0);
+            assert.equal(warnings.length, 1);
+            assert.equal(warnings[0]?.kind, "confidence");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("scope copilot-repo: plain markdown without frontmatter succeeds (no instructionFrontmatterRequired check)", async () => {
+        const dir = await makeTmpDir();
+        try {
+            // Plain markdown with no frontmatter — should NOT throw despite github-copilot
+            // having instructionFrontmatterRequired: true (native agentRules scopes skip that check)
+            await writeFile(path.join(dir, "plain.md"), "# Plain rules\n\nNo frontmatter.");
+            const repo = "/repo/myproject";
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "plain-rules",
+                agents: ["github-copilot"],
+                path: "plain.md",
+                scope: "copilot-repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", repo);
+            assert.equal(actions.length, 1);
+            assert.equal(warnings.length, 0);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("throws when rules source file does not exist", async () => {
         const dir = await makeTmpDir();
         try {
@@ -469,6 +579,29 @@ describe("compileAgentRuleActions", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("scope repo with targetDir: injects targetDir into path for claude-code", async () => {
+        const dir = await makeTmpDir();
+        try {
+            const rulesFile = path.join(dir, "CLAUDE.md");
+            await writeFile(rulesFile, "# Rules");
+            const repo = "/repo/myproject";
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "my-rule",
+                agents: ["claude-code"],
+                path: "CLAUDE.md",
+                scope: "repo",
+                targetDir: "apps/frontend",
+            }, dir, dir, realRoot, ["claude-code"], "/home/test", repo);
+            assert.equal(actions.length, 1);
+            assert.equal(warnings.length, 0);
+            const action = actions[0];
+            assert.equal(normalizeSlashes(action.target), `${repo}/apps/frontend/CLAUDE.md`, `expected target at {repo}/apps/frontend/CLAUDE.md, got: ${action.target}`);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("scope repo: emits a warning and skips when repo path is not provided", async () => {
         const dir = await makeTmpDir();
         try {
@@ -552,6 +685,21 @@ describe("compileAgentRuleActions", () => {
         }
     });
 });
+describe("compileAgentRuleReverts", () => {
+    it("injects targetDir into revert path", () => {
+        const home = "/home/test";
+        const repo = "/repo/test";
+        const actions = compileAgentRuleReverts({
+            name: "my-rule",
+            agents: ["claude-code"],
+            path: "CLAUDE.md",
+            scope: "repo",
+            targetDir: "apps/frontend",
+        }, ["claude-code"], home, repo);
+        assert.equal(actions.length, 1);
+        assert.equal(normalizeSlashes(actions[0]?.target ?? ""), `${repo}/apps/frontend/CLAUDE.md`);
+    });
+});
 describe("compilePermissionsActions", () => {
     it("returns zero actions and warnings when no detected agents overlap", () => {
         const { actions, warnings } = compilePermissionsActions({
@@ -683,6 +831,149 @@ describe("compilePermissionsActions", () => {
         assert.ok(agents.includes("codex"));
     });
 });
+describe("compilePermissionsReverts", () => {
+    it("returns config and toml revert actions for supported agents", () => {
+        const actions = compilePermissionsReverts({
+            name: "multi",
+            agents: ["claude-code", "codex", "opencode"],
+            config: {},
+        }, null, "/home/test");
+        assert.equal(actions.length, 3);
+        assert.deepEqual(actions.map((action) => [action.agent, action.kind]), [
+            ["claude-code", "config-patch"],
+            ["codex", "toml-patch"],
+            ["opencode", "config-patch"],
+        ]);
+        assertPathEndsWith(actions[0]?.target ?? "", ".claude/settings.json", `expected claude-code target under .claude/settings.json, got: ${actions[0]?.target}`);
+        assertPathEndsWith(actions[1]?.target ?? "", ".codex/config.toml", `expected codex target under .codex/config.toml, got: ${actions[1]?.target}`);
+        assertPathEndsWith(actions[2]?.target ?? "", "opencode/opencode.json", `expected opencode target under opencode/opencode.json, got: ${actions[2]?.target}`);
+    });
+    it("skips unsupported agents and respects agentFilter", () => {
+        const actions = compilePermissionsReverts({
+            name: "filtered",
+            agents: ["claude-code", "gemini-cli", "codex"],
+            config: {},
+        }, ["codex"], "/home/test");
+        assert.equal(actions.length, 1);
+        assert.equal(actions[0]?.agent, "codex");
+        assert.equal(actions[0]?.kind, "toml-patch");
+    });
+});
+describe("compileHookActions", () => {
+    const validClaudeHookConfig = {
+        hooks: {
+            PreToolUse: [
+                {
+                    matcher: "Bash",
+                    hooks: [{ type: "command", command: "scripts/check.sh" }],
+                },
+            ],
+        },
+    };
+    it("returns zero actions and warnings when no detected agents overlap", () => {
+        const { actions, warnings } = compileHookActions({ name: "check", agents: ["claude-code"], config: validClaudeHookConfig }, ["codex"], "/home/test");
+        assert.equal(actions.length, 0);
+        assert.equal(warnings.length, 0);
+    });
+    it("returns a config-patch action for claude-code targeting settings.json", () => {
+        const home = "/home/test";
+        const { actions, warnings } = compileHookActions({ name: "check", agents: ["claude-code"], config: validClaudeHookConfig }, ["claude-code"], home);
+        assert.equal(warnings.length, 0);
+        assert.equal(actions.length, 1);
+        const action = actions[0];
+        assert.equal(action.kind, "config-patch");
+        assert.ok(action.target.endsWith(".claude/settings.json".replace("/", path.sep)));
+        assert.equal(action.agent, "claude-code");
+        assert.equal(action.confidence, "documented");
+    });
+    it("accepts a hooks entry with no matcher property on the matcher object", () => {
+        const { actions, warnings } = compileHookActions({
+            name: "check",
+            agents: ["claude-code"],
+            config: {
+                hooks: {
+                    Stop: [{ hooks: [{ type: "command", command: "notify.sh" }] }],
+                },
+            },
+        }, ["claude-code"], "/home/test");
+        assert.equal(warnings.length, 0);
+        assert.equal(actions.length, 1);
+    });
+    it("emits a warning and skips for agents without a hooks surface", () => {
+        const { actions, warnings } = compileHookActions({ name: "check", agents: ["gemini-cli"], config: {} }, ["gemini-cli"], "/home/test");
+        assert.equal(actions.length, 0);
+        assert.equal(warnings.length, 1);
+    });
+    it("throws on unknown top-level key in config for claude-code", () => {
+        assert.throws(() => compileHookActions({ name: "bad", agents: ["claude-code"], config: { bad_key: {} } }, ["claude-code"], "/home/test"), /unrecognized keys/);
+    });
+    it("throws when hooks value is not an object for claude-code", () => {
+        assert.throws(() => compileHookActions({ name: "bad", agents: ["claude-code"], config: { hooks: "string" } }, ["claude-code"], "/home/test"), /must define "hooks" as an object/);
+    });
+    it("throws when an event value is not an array", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: { hooks: { PreToolUse: "not-array" } },
+        }, ["claude-code"], "/home/test"), /must be an array/);
+    });
+    it("throws when a matcher element is not an object", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: { hooks: { PreToolUse: ["string"] } },
+        }, ["claude-code"], "/home/test"), /must be an object/);
+    });
+    it("throws when matcher.hooks is missing", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: { hooks: { PreToolUse: [{ matcher: "Bash" }] } },
+        }, ["claude-code"], "/home/test"), /must be an array/);
+    });
+    it("throws when a hook command type is not 'command'", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: {
+                hooks: {
+                    PreToolUse: [
+                        {
+                            hooks: [{ type: "script", command: "check.sh" }],
+                        },
+                    ],
+                },
+            },
+        }, ["claude-code"], "/home/test"), /must be "command"/);
+    });
+    it("throws when a hook command is not a string", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: {
+                hooks: {
+                    PreToolUse: [{ hooks: [{ type: "command", command: 123 }] }],
+                },
+            },
+        }, ["claude-code"], "/home/test"), /must be a string/);
+    });
+    it("throws when matcher.matcher is not a string", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: {
+                hooks: {
+                    PreToolUse: [
+                        {
+                            matcher: 42,
+                            hooks: [{ type: "command", command: "check.sh" }],
+                        },
+                    ],
+                },
+            },
+        }, ["claude-code"], "/home/test"), /must be a string when present/);
+    });
+});
 describe("compileAgentDefinitionActions", () => {
     // Import is added inline to avoid modifying the top-level imports block
     // (the function is async so we do a dynamic import once and reuse).
@@ -752,6 +1043,68 @@ describe("compileAgentDefinitionActions", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("emits a warning and skips repo-scoped definitions when repo is missing", async () => {
+        const compile = await getAdapter();
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "my-agent.md"), "---\nname: test-agent\ndescription: test\ntools: []\n---\n# Agent");
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compile({
+                name: "my-agent",
+                agents: ["claude-code"],
+                path: "my-agent.md",
+                scope: "repo",
+            }, dir, dir, realRoot, ["claude-code"], "/home/test");
+            assert.equal(actions.length, 0);
+            assert.equal(warnings.length, 1);
+            assert.equal(warnings[0]?.kind, "confidence");
+            assert.match(warnings[0]?.message ?? "", /scope "repo" requires a repository path/);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("uses the repo path as a workspace fallback for workspace-scoped definitions", async () => {
+        const compile = await getAdapter();
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "my-agent.md"), "---\nname: test-agent\ndescription: test\ntools: []\n---\n# Agent");
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compile({
+                name: "my-agent",
+                agents: ["gemini-cli"],
+                path: "my-agent.md",
+                scope: "workspace",
+            }, dir, dir, realRoot, ["gemini-cli"], "/home/test", "/repo/test");
+            assert.equal(warnings.length, 0);
+            assert.equal(actions.length, 1);
+            assert.equal(normalizeSlashes(actions[0]?.target ?? ""), "/repo/test/.gemini/agents/my-agent.md");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("emits a warning and skips workspace-scoped definitions when repo and workspace are missing", async () => {
+        const compile = await getAdapter();
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "my-agent.md"), "---\nname: test-agent\ndescription: test\ntools: []\n---\n# Agent");
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compile({
+                name: "my-agent",
+                agents: ["gemini-cli"],
+                path: "my-agent.md",
+                scope: "workspace",
+            }, dir, dir, realRoot, ["gemini-cli"], "/home/test");
+            assert.equal(actions.length, 0);
+            assert.equal(warnings.length, 1);
+            assert.equal(warnings[0]?.kind, "confidence");
+            assert.match(warnings[0]?.message ?? "", /scope "workspace" requires a workspace or repository path/);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("returns a file-write action for opencode with correct target", async () => {
         const compile = await getAdapter();
         const dir = await makeTmpDir();
@@ -1029,3 +1382,50 @@ describe("compileAgentDefinitionActions", () => {
         }
     });
 });
+describe("compileAgentDefinitionReverts", () => {
+    async function getAdapter() {
+        const { compileAgentDefinitionReverts } = await import("../../src/core/adapters/agent-definitions.js");
+        return compileAgentDefinitionReverts;
+    }
+    it("returns revert actions for supported markdown and toml targets", async () => {
+        const compile = await getAdapter();
+        const actions = compile({
+            name: "my-agent",
+            agents: ["claude-code", "gemini-cli", "github-copilot"],
+            path: "my-agent.md",
+            scope: "repo",
+        }, null, "/home/test", "/repo/test");
+        assert.equal(actions.length, 3);
+        assert.deepEqual(actions.map((action) => action.agent), ["claude-code", "gemini-cli", "github-copilot"]);
+        assert.equal(normalizeSlashes(actions[0]?.target ?? ""), "/repo/test/.claude/agents/my-agent.md");
+        assert.equal(normalizeSlashes(actions[1]?.target ?? ""), "/repo/test/.gemini/agents/my-agent.md");
+        assert.equal(normalizeSlashes(actions[2]?.target ?? ""), "/repo/test/.github/copilot/agents/my-agent.md");
+    });
+    it("returns a global toml revert for gemini-cli", async () => {
+        const compile = await getAdapter();
+        const actions = compile({
+            name: "my-agent",
+            agents: ["gemini-cli"],
+            path: "my-agent.toml",
+            scope: "global",
+        }, null, "/home/test");
+        assert.equal(actions.length, 1);
+        assert.equal(actions[0]?.agent, "gemini-cli");
+        assert.equal(normalizeSlashes(actions[0]?.target ?? ""), "/home/test/.gemini/agents/my-agent.toml");
+    });
+    it("skips unsupported targets and missing workspace or repo requirements", async () => {
+        const compile = await getAdapter();
+        assert.deepEqual(compile({
+            name: "my-agent",
+            agents: ["codex"],
+            path: "my-agent.md",
+            scope: "repo",
+        }, null, "/home/test", "/repo/test"), []);
+        assert.deepEqual(compile({
+            name: "my-agent",
+            agents: ["gemini-cli"],
+            path: "my-agent.md",
+            scope: "workspace",
+        }, null, "/home/test"), []);
+    });
+});

package/dist/test/unit/capabilities.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { describeCapabilityConfidence, planCapabilityForDeploy, shouldInitIncludeAgent, } from "../../src/core/capabilities.js";
+import { describeCapabilityConfidence, planCapabilityForDeploy, resolveCapabilitySurface, shouldInitIncludeAgent, } from "../../src/core/capabilities.js";
 describe("capabilities planner", () => {
     it("treats antigravity agentRules as deployable but not init-default", () => {
         const plan = planCapabilityForDeploy({
@@ -68,4 +68,47 @@ describe("capabilities planner", () => {
         assert.equal(confidence.confidence, "documented");
         assert.equal(confidence.message, null);
     });
+    it("treats antigravity agentRules as shared-via gemini-cli but directly deployable when the primary is absent", () => {
+        const plan = planCapabilityForDeploy({
+            agentId: "antigravity",
+            capability: "agentRules",
+            entryName: "gemini-compatible-rules",
+            targetAgentIds: ["antigravity"],
+            scope: "repo",
+        });
+        assert.equal(plan.outcome, "action");
+        const confidence = describeCapabilityConfidence("antigravity", "agentRules", "repo");
+        assert.match(confidence.message ?? "", /shared through "gemini-cli"/);
+        assert.doesNotMatch(confidence.message ?? "", /requires the primary target to deploy/);
+    });
+    it("marks gemini-cli hooks as planned and excludes them from init defaults", () => {
+        const surface = resolveCapabilitySurface("gemini-cli", "hooks");
+        assert.equal(surface.supportStatus, "planned");
+        assert.equal(surface.plannedSurface, "settings.json hooks field");
+        const plan = planCapabilityForDeploy({
+            agentId: "gemini-cli",
+            capability: "hooks",
+            entryName: "future-hooks",
+            targetAgentIds: ["gemini-cli"],
+        });
+        assert.equal(plan.outcome, "warn");
+        if (plan.outcome !== "warn")
+            return;
+        assert.match(plan.warning.message, /planned via settings\.json hooks field/);
+        assert.equal(shouldInitIncludeAgent("gemini-cli", "hooks"), false);
+    });
+    it("reports unsupported confidence for codex hooks and opencode workspace rules", () => {
+        const codexHooks = describeCapabilityConfidence("codex", "hooks");
+        assert.match(codexHooks.message ?? "", /hooks surface is unsupported/);
+        const workspaceRules = describeCapabilityConfidence("opencode", "agentRules", "workspace");
+        assert.match(workspaceRules.message ?? "", /workspace-local instruction surface distinct from repo-local AGENTS\.md/);
+    });
+    it("resolves executionConfigs support records for supported and unsupported agents", () => {
+        const gemini = resolveCapabilitySurface("gemini-cli", "executionConfigs");
+        assert.equal(gemini.supportStatus, "supported");
+        assert.equal(gemini.schemaLabel, "Settings execution config");
+        const claude = resolveCapabilitySurface("claude-code", "executionConfigs");
+        assert.equal(claude.supportStatus, "unsupported");
+        assert.equal(claude.schemaLabel, "an unsupported surface");
+    });
 });