@kuznai/inception-engine 0.14.0 → 0.14.1

package/dist/core/deploy.js

@@ -4,12 +4,10 @@ import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
-import { writeFrontmatterFile } from "./adapters/frontmatter.js";
 import { compileAdapterActions } from "./adapters/index.js";
-import { applyTomlMcpPatch } from "./adapters/toml.js";
 import { lookupDeployment, registerDeployment, verifyDeployment, } from "./ownership.js";
 import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
-import { getPathApi, resolveTargetTemplate } from "./runtime-paths.js";
+import { resolveTargetTemplate } from "./runtime-paths.js";
 import { sourceAccessError, validateSkillDefinitionFile, validateSourceFile, validateSourcePath, } from "./validation.js";
 function isPlainObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -82,28 +80,26 @@ function detectCollisions(actions) {
     }
     return warnings;
 }
-function detectAmbiguities(detectedAgents, actions, home) {
+function detectAmbiguities(detectedAgents, manifest) {
     const warnings = [];
-    const hasGeminiCli = detectedAgents.includes("gemini-cli");
-    const hasAntigravity = detectedAgents.includes("antigravity");
-    if (hasGeminiCli && hasAntigravity) {
-        const homePathApi = getPathApi(home);
-        const sharedGeminiMd = homePathApi.join(home, ".gemini", "GEMINI.md");
-        const sharedSettings = homePathApi.join(home, ".gemini", "settings.json");
-        // Normalize paths for comparison to handle case-insensitivity on Windows
-        const normalize = (pathStr) => homePathApi === path.win32
-            ? pathStr.toLowerCase()
-            : pathStr;
-        const normalizedGeminiMd = normalize(sharedGeminiMd);
-        const normalizedSettings = normalize(sharedSettings);
-        const targetsShared = actions.some((a) => {
-            const normalizedTarget = normalize(a.target);
-            return normalizedTarget === normalizedGeminiMd || normalizedTarget === normalizedSettings;
-        });
-        if (targetsShared) {
+    if (!(detectedAgents.includes("gemini-cli") &&
+        detectedAgents.includes("antigravity"))) {
+        return warnings;
+    }
+    const bothAgents = (agents) => agents.includes("gemini-cli") && agents.includes("antigravity");
+    for (const entry of manifest.agentRules ?? []) {
+        if (bothAgents(entry.agents)) {
+            warnings.push({
+                kind: "ambiguity",
+                message: `Both "gemini-cli" and "antigravity" are listed in agentRules entry "${entry.name}". They share a GEMINI.md-backed instruction shared surface — verify that deploying to both does not create conflicting behavior.`,
+            });
+        }
+    }
+    for (const entry of manifest.mcpServers ?? []) {
+        if (bothAgents(entry.agents)) {
             warnings.push({
                 kind: "ambiguity",
-                message: "Both 'gemini-cli' and 'antigravity' are active, and a deployment targets a shared surface (~/.gemini/GEMINI.md or settings.json). Because Antigravity treats GEMINI.md as an Agent Blueprint, changes intended for one runtime may unexpectedly affect the other.",
+                message: `Both "gemini-cli" and "antigravity" are listed in mcpServers entry "${entry.name}". "gemini-cli" writes to ~/.gemini/settings.json as a shared surface — verify that deploying to both does not produce conflicting MCP server behavior.`,
             });
         }
     }
@@ -161,7 +157,7 @@ async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, real
     }
     return actions;
 }
-function planConfigPatchActions(manifest, detectedAgents, home, repo) {
+function planConfigPatchActions(manifest, detectedAgents, home) {
     const actions = [];
     for (const configEntry of manifest.configs ?? []) {
         for (const agentId of configEntry.agents) {
@@ -174,7 +170,7 @@ function planConfigPatchActions(manifest, detectedAgents, home, repo) {
                 kind: "config-patch",
                 skill: configEntry.name,
                 agent: agentId,
-                target: resolveTargetTemplate(configEntry.target, home, repo),
+                target: resolveTargetTemplate(configEntry.target, home),
                 patch: configEntry.patch,
                 confidence: agent.provenance.skills,
             });
@@ -194,44 +190,56 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     const actions = [
         ...(await planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
         ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
-        ...planConfigPatchActions(manifest, detectedAgents, home, resolvedSourceDir),
+        ...planConfigPatchActions(manifest, detectedAgents, home),
     ];
-    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, resolvedSourceDir);
+    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home);
     actions.push(...adapterResult.actions);
     const warnings = [
-        ...detectAmbiguities(detectedAgents, actions, home),
+        ...detectAmbiguities(detectedAgents, manifest),
         ...detectCollisions(actions),
         ...adapterResult.warnings,
     ];
     return { actions, warnings };
 }
-async function dispatchDeployAction(action, dryRun, verbose, home, planned, deps) {
-    switch (action.kind) {
-        case "skill-dir":
-            return deploySkillDir(action, dryRun, verbose, home, planned, deps);
-        case "file-write":
-            return deployFileWrite(action, dryRun, verbose, home, planned, deps);
-        case "config-patch":
-            return deployConfigPatch(action, dryRun, verbose, home, planned, deps);
-        case "toml-patch":
-            return deployTomlPatch(action, dryRun, verbose, home, planned, deps);
-        case "frontmatter-emit":
-            return deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps);
-        default:
-            throw new Error(`Unhandled deploy action kind: ${action.kind}`);
-    }
-}
 export async function executeDeploy(actions, dryRun, verbose, home, deps = {}) {
     let succeeded = 0;
     const failed = [];
     const planned = [];
     for (const action of actions) {
-        const result = await dispatchDeployAction(action, dryRun, verbose, home, planned, deps);
-        if (result.error === null) {
-            succeeded++;
-        }
-        else {
-            failed.push({ action, error: result.error });
+        switch (action.kind) {
+            case "skill-dir": {
+                const result = await deploySkillDir(action, dryRun, verbose, home, planned, deps);
+                if (result.error === null) {
+                    succeeded++;
+                }
+                else {
+                    failed.push({ action, error: result.error });
+                }
+                break;
+            }
+            case "file-write": {
+                const result = await deployFileWrite(action, dryRun, verbose, home, planned, deps);
+                if (result.error === null) {
+                    succeeded++;
+                }
+                else {
+                    failed.push({ action, error: result.error });
+                }
+                break;
+            }
+            case "config-patch": {
+                const result = await deployConfigPatch(action, dryRun, verbose, home, planned, deps);
+                if (result.error === null) {
+                    succeeded++;
+                }
+                else {
+                    failed.push({ action, error: result.error });
+                }
+                break;
+            }
+            default: {
+                throw new Error(`Unhandled deploy action kind: ${action}`);
+            }
         }
     }
     return { succeeded, failed, planned };
@@ -599,87 +607,3 @@ async function backupExisting(targetPath, verbose, home, expected, deps) {
     await rename(targetPath, backupPath);
     return backupPath;
 }
-async function deployTomlPatch(action, dryRun, verbose, home, planned, deps) {
-    const label = `${action.skill} -> ${action.agent}`;
-    if (dryRun) {
-        planned.push({
-            verb: "patch-toml",
-            kind: "toml-patch",
-            skill: action.skill,
-            agent: action.agent,
-            target: action.target,
-            confidence: action.confidence,
-        });
-        return { error: null };
-    }
-    try {
-        // Guard against double-patching by a different skill/agent.
-        const existingEntry = await lookupDeployment(home, action.target, deps.registry);
-        if (existingEntry &&
-            (existingEntry.skill !== action.skill ||
-                existingEntry.agent !== action.agent)) {
-            throw new Error(`Config "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to double-patch`);
-        }
-        await applyTomlMcpPatch(action.target, action.skill, action.config);
-        await registerDeployment(home, action.target, {
-            kind: "config-patch",
-            patch: { mcpServers: { [action.skill]: action.config } },
-            undoPatch: { mcpServers: { [action.skill]: null } },
-            skill: action.skill,
-            agent: action.agent,
-        }, deps.registry);
-        logger.ok(label);
-        if (verbose) {
-            logger.detail(`patch-toml: wrote [mcpServers.${action.skill}] to ${action.target}`);
-        }
-        return { error: null };
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.fail(label, msg);
-        return { error: msg };
-    }
-}
-async function deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
-    const label = `${action.skill} -> ${action.agent}`;
-    if (dryRun) {
-        planned.push({
-            verb: "emit-frontmatter",
-            kind: "frontmatter-emit",
-            skill: action.skill,
-            agent: action.agent,
-            target: action.target,
-            frontmatter: action.frontmatter,
-            confidence: action.confidence,
-        });
-        return { error: null };
-    }
-    try {
-        // Guard against double-patching by a different skill/agent.
-        const existingEntry = await lookupDeployment(home, action.target, deps.registry);
-        if (existingEntry &&
-            (existingEntry.skill !== action.skill ||
-                existingEntry.agent !== action.agent)) {
-            throw new Error(`File "${action.target}" is already managed by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to overwrite`);
-        }
-        await writeFrontmatterFile(action.target, action.frontmatter, {
-            preserveBody: true,
-        });
-        await registerDeployment(home, action.target, {
-            kind: "file-write",
-            source: action.target,
-            skill: action.skill,
-            agent: action.agent,
-        }, deps.registry);
-        logger.ok(label);
-        if (verbose) {
-            logger.detail(`emit-frontmatter: wrote ${action.target}`);
-        }
-        return { error: null };
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        logger.fail(label, msg);
-        return { error: msg };
-    }
-}

package/package.json

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