@kuznai/inception-engine 0.22.0 → 0.23.0

package/dist/test/unit/deploy.test.js

@@ -68,6 +68,32 @@ describe("planDeploy", () => {
             await rm(sourceDir, { recursive: true });
         }
     });
+    it("includes executionConfigs actions for supported detected agents", async () => {
+        const sourceDir = await makeTmpDir();
+        try {
+            const manifest = {
+                ...testManifest,
+                executionConfigs: [
+                    {
+                        name: "gemini-safety",
+                        agents: ["gemini-cli"],
+                        config: { safeMode: true },
+                    },
+                ],
+            };
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(manifest, sourceDir, ["gemini-cli"], "/home/test");
+            const executionAction = actions.find((action) => action.kind === "config-patch" &&
+                action.agent === "gemini-cli" &&
+                action.skill === "gemini-safety");
+            assert.ok(executionAction, "expected planDeploy to include the gemini executionConfigs patch");
+            assert.deepEqual(executionAction.patch, { safeMode: true });
+            assertPathEndsWith(executionAction.target, ".gemini/settings.json", `expected Gemini execution config target under .gemini/settings.json, got: ${executionAction.target}`);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true });
+        }
+    });
     it("throws when skill source path does not exist", async () => {
         const sourceDir = await makeTmpDir();
         try {

package/dist/test/unit/init-fixture.test.js

@@ -1,10 +1,13 @@
 import assert from "node:assert/strict";
-import { cp, readFile, rm } from "node:fs/promises";
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import path from "node:path";
 import { describe, it } from "node:test";
+import { runInit } from "../../src/core/init.js";
+import { logger } from "../../src/logger.js";
 import { makeTmpDir } from "../helpers/fs.js";
 import { assertPathEndsWith, normalizeSlashes } from "../helpers/path.js";
+logger.silence();
 const PROJECT_ROOT = path.resolve(import.meta.dirname, "..", "..");
 const FIXTURE_DIR = path.join(PROJECT_ROOT, "test", "fixtures", "readme-sample");
 function run(args, env) {
@@ -151,3 +154,84 @@ describe("init against readme-sample fixture", () => {
         }
     });
 });
+// ---------------------------------------------------------------------------
+// Block 3: init discovery of GitHub Copilot native instruction surfaces
+// ---------------------------------------------------------------------------
+describe("init Copilot native instruction discovery", () => {
+    it("runInit dryRun succeeds when .github/copilot-instructions.md is present", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github"), { recursive: true });
+            await writeFile(path.join(dir, ".github", "copilot-instructions.md"), "# Copilot instructions");
+            // Use dryRun to avoid writing inception.json
+            const result = await runInit({
+                directory: dir,
+                agents: null,
+                dryRun: true,
+                force: false,
+                verbose: false,
+            });
+            assert.equal(result, 0);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("init --plan output includes copilot-repo scope for .github/copilot-instructions.md", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github"), { recursive: true });
+            await writeFile(path.join(dir, ".github", "copilot-instructions.md"), "# Copilot instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const copilotEntry = manifest.agentRules.find((r) => r.scope === "copilot-repo");
+            assert.ok(copilotEntry, `expected a copilot-repo entry in agentRules, got: ${JSON.stringify(manifest.agentRules)}`);
+            assert.deepEqual(copilotEntry.agents, ["github-copilot"]);
+            assertPathEndsWith(copilotEntry.path, ".github/copilot-instructions.md", `copilot-repo entry path should end with .github/copilot-instructions.md`);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("init --plan output includes copilot-scoped scope for .github/instructions/*.instructions.md", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github", "instructions"), {
+                recursive: true,
+            });
+            await writeFile(path.join(dir, ".github", "instructions", "typescript.instructions.md"), "# TypeScript scoped instructions");
+            await writeFile(path.join(dir, ".github", "instructions", "python.instructions.md"), "# Python scoped instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const scopedEntries = manifest.agentRules.filter((r) => r.scope === "copilot-scoped");
+            assert.equal(scopedEntries.length, 2, `expected 2 copilot-scoped entries, got ${scopedEntries.length}: ${JSON.stringify(manifest.agentRules)}`);
+            for (const entry of scopedEntries) {
+                assert.deepEqual(entry.agents, ["github-copilot"]);
+            }
+            const names = scopedEntries.map((e) => e.name).sort();
+            assert.deepEqual(names, ["python", "typescript"]);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("non-.github/ copilot-instructions.md still maps to claude-code (backward compat)", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, "rules"), { recursive: true });
+            await writeFile(path.join(dir, "rules", "copilot-instructions.md"), "# Copilot instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const entry = manifest.agentRules.find((r) => r.path.endsWith("copilot-instructions.md"));
+            assert.ok(entry, `expected a copilot-instructions.md entry, got: ${JSON.stringify(manifest.agentRules)}`);
+            assert.ok(entry.agents.includes("claude-code"), `expected agents to include claude-code, got: ${JSON.stringify(entry.agents)}`);
+            assert.notEqual(entry.scope, "copilot-repo", "rules/ copilot-instructions.md should not use copilot-repo scope");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+});

package/dist/test/unit/manifest.test.js

@@ -554,6 +554,78 @@ describe("loadManifest", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("agentRules accepts targetDir with scope: 'repo'", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "inception.json"), JSON.stringify({
+                skills: [],
+                agentRules: [
+                    {
+                        name: "my-rule",
+                        agents: ["claude-code"],
+                        path: "rules/CLAUDE.md",
+                        scope: "repo",
+                        targetDir: "apps/frontend",
+                    },
+                ],
+            }));
+            const manifest = await loadManifest(dir);
+            assert.equal(manifest.agentRules[0]?.targetDir, "apps/frontend");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("agentRules rejects targetDir with scope: 'global'", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "inception.json"), JSON.stringify({
+                skills: [],
+                agentRules: [
+                    {
+                        name: "my-rule",
+                        agents: ["claude-code"],
+                        path: "rules/CLAUDE.md",
+                        scope: "global",
+                        targetDir: "apps/frontend",
+                    },
+                ],
+            }));
+            await assert.rejects(loadManifest(dir), (err) => {
+                assert.ok(err instanceof UserError);
+                assert.match(err.message, /targetDir is only supported for scope "repo" or "workspace"/);
+                return true;
+            });
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("throws when agentRules targetDir is absolute", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "inception.json"), JSON.stringify({
+                skills: [],
+                agentRules: [
+                    {
+                        name: "my-rule",
+                        agents: ["claude-code"],
+                        path: "rules/CLAUDE.md",
+                        scope: "repo",
+                        targetDir: "/absolute/path",
+                    },
+                ],
+            }));
+            await assert.rejects(loadManifest(dir), (err) => {
+                assert.ok(err instanceof UserError);
+                assert.match(err.message, /targetDir must be a relative path/);
+                return true;
+            });
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("defaults mcpServers and agentRules to [] when omitted", async () => {
         const dir = await makeTmpDir();
         try {

package/dist/test/unit/preflight.test.js

@@ -279,6 +279,92 @@ describe("instruction precedence warnings", () => {
             await rm(sourceDir, { recursive: true });
         }
     });
+    it("emits Copilot precedence warning when github-copilot has both shared-via (scope: repo) and native (scope: copilot-repo) entries", async () => {
+        const sourceDir = await makeTmpDir();
+        try {
+            await writeFile(path.join(sourceDir, "shared.md"), "# Shared rules");
+            await writeFile(path.join(sourceDir, "native.md"), "# Native rules");
+            const manifest = {
+                ...emptyManifest,
+                agentRules: [
+                    {
+                        name: "shared-rules",
+                        path: "shared.md",
+                        agents: ["claude-code", "github-copilot"],
+                        scope: "repo",
+                    },
+                    {
+                        name: "native-rules",
+                        path: "native.md",
+                        agents: ["github-copilot"],
+                        scope: "copilot-repo",
+                    },
+                ],
+            };
+            const warnings = await runPreflight({ ...baseOptions, directory: sourceDir }, manifest, "/home/test", ["github-copilot"]);
+            const precedenceWarnings = warnings.filter((w) => w.kind === "precedence");
+            assert.ok(precedenceWarnings.length > 0, "expected a precedence warning");
+            assert.ok(precedenceWarnings.some((w) => w.message.includes("github-copilot") &&
+                w.message.includes("CLAUDE.md-shared") &&
+                w.message.includes("native Copilot")), `expected Copilot precedence warning, got: ${JSON.stringify(precedenceWarnings)}`);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true });
+        }
+    });
+    it("emits Copilot precedence warning when github-copilot has both global (scope: global) and copilot-scoped entries", async () => {
+        const sourceDir = await makeTmpDir();
+        try {
+            await writeFile(path.join(sourceDir, "shared.md"), "# Shared rules");
+            await writeFile(path.join(sourceDir, "scoped.md"), "# Scoped rules");
+            const manifest = {
+                ...emptyManifest,
+                agentRules: [
+                    {
+                        name: "shared-rules",
+                        path: "shared.md",
+                        agents: ["claude-code", "github-copilot"],
+                        scope: "global",
+                    },
+                    {
+                        name: "typescript",
+                        path: "scoped.md",
+                        agents: ["github-copilot"],
+                        scope: "copilot-scoped",
+                    },
+                ],
+            };
+            const warnings = await runPreflight({ ...baseOptions, directory: sourceDir }, manifest, "/home/test", ["github-copilot"]);
+            const precedenceWarnings = warnings.filter((w) => w.kind === "precedence");
+            assert.ok(precedenceWarnings.some((w) => w.message.includes("github-copilot") &&
+                w.message.includes("native Copilot")), `expected Copilot precedence warning, got: ${JSON.stringify(precedenceWarnings)}`);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true });
+        }
+    });
+    it("emits no Copilot precedence warning when github-copilot only has native entries", async () => {
+        const sourceDir = await makeTmpDir();
+        try {
+            await writeFile(path.join(sourceDir, "native.md"), "# Native rules");
+            const manifest = {
+                ...emptyManifest,
+                agentRules: [
+                    {
+                        name: "native-rules",
+                        path: "native.md",
+                        agents: ["github-copilot"],
+                        scope: "copilot-repo",
+                    },
+                ],
+            };
+            const warnings = await runPreflight({ ...baseOptions, directory: sourceDir }, manifest, "/home/test", ["github-copilot"]);
+            assert.equal(warnings.filter((w) => w.kind === "precedence").length, 0);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true });
+        }
+    });
 });
 describe("instruction budget warnings", () => {
     it("emits budget warning for agentRules source file exceeding 50 KB", async () => {

package/dist/test/unit/revert.test.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,6 +122,36 @@ 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 () => {

package/package.json

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