@kuznai/inception-engine 0.19.0 → 0.21.0

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

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

package/dist/test/unit/toml.test.js

@@ -0,0 +1,55 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { applyTomlMcpPatch, revertTomlMcpPatch, } from "../../src/core/adapters/toml.js";
+describe("TOML Adapter", () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "inception-toml-test-"));
+    });
+    afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it("applies an MCP server patch to a new TOML file", async () => {
+        const target = path.join(tmpDir, "config.toml");
+        const config = { command: "npx", args: ["serve"] };
+        await applyTomlMcpPatch(target, "my-skill", config);
+        const content = await fs.readFile(target, "utf-8");
+        assert.match(content, /\[mcpServers\.my-skill\]/);
+        assert.match(content, /command = "npx"/);
+        assert.match(content, /args = \[ "serve" \]/);
+    });
+    it("applies an MCP server patch to an existing TOML file preserving other keys", async () => {
+        const target = path.join(tmpDir, "config.toml");
+        await fs.writeFile(target, 'title = "My App"\n\n[mcpServers.other]\ncommand = "ls"\n');
+        const config = { command: "npx", args: ["serve"] };
+        await applyTomlMcpPatch(target, "my-skill", config);
+        const content = await fs.readFile(target, "utf-8");
+        assert.match(content, /title = "My App"/);
+        assert.match(content, /\[mcpServers\.other\]/);
+        assert.match(content, /\[mcpServers\.my-skill\]/);
+        assert.match(content, /command = "npx"/);
+    });
+    it("reverts an MCP server patch", async () => {
+        const target = path.join(tmpDir, "config.toml");
+        await fs.writeFile(target, '[mcpServers.other]\ncommand = "ls"\n\n[mcpServers.my-skill]\ncommand = "npx"\n');
+        await revertTomlMcpPatch(target, "my-skill");
+        const content = await fs.readFile(target, "utf-8");
+        assert.match(content, /\[mcpServers\.other\]/);
+        assert.doesNotMatch(content, /my-skill/);
+    });
+    it("cleans up [mcpServers] table if it becomes empty after revert", async () => {
+        const target = path.join(tmpDir, "config.toml");
+        await fs.writeFile(target, '[mcpServers.my-skill]\ncommand = "npx"\n');
+        await revertTomlMcpPatch(target, "my-skill");
+        const content = await fs.readFile(target, "utf-8");
+        assert.strictEqual(content.trim(), "");
+    });
+    it("throws error if config.toml is invalid TOML", async () => {
+        const target = path.join(tmpDir, "config.toml");
+        await fs.writeFile(target, 'this is not = toml "bad"');
+        await assert.rejects(() => applyTomlMcpPatch(target, "any", {}), /Invalid TOML document/);
+    });
+});

package/package.json

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

package/dist/core/adapters/agent-definitions.js

@@ -1,91 +0,0 @@
-import path from "node:path";
-import { AGENT_REGISTRY_BY_ID } from "../../config/agents.js";
-import { getPlatformKey, resolvePlaceholders } from "../resolve.js";
-import { validateAgentRuleMarkdownPath, validateInstructionFileRequirements, validateSourceFile, validateSourcePath, } from "../validation.js";
-/**
- * Compiles deploy actions for agentDefinitions manifest entries.
- *
- * Agent definition files are Markdown files (typically with YAML frontmatter)
- * that define custom agents or subagents for a given platform. Unlike
- * agentRules (which target a single shared global file per agent), each
- * definition entry produces a separate file named after the entry in the
- * agent's dedicated agent-definitions directory (repo-local).
- *
- * Target paths use the `{repo}` placeholder so definitions land in the
- * repository being deployed, not the user's home directory.
- */
-export async function compileAgentDefinitionActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace) {
-    const actions = [];
-    const warnings = [];
-    const platform = getPlatformKey();
-    const targetAgents = entry.agents.filter((agentId) => detectedAgents.includes(agentId));
-    const supportedTargets = [];
-    if (targetAgents.length === 0) {
-        return { actions, warnings };
-    }
-    for (const agentId of targetAgents) {
-        const agent = AGENT_REGISTRY_BY_ID[agentId];
-        const support = agent?.agentDefinitionsSupport;
-        if (!support || support.status === "unsupported") {
-            warnings.push({
-                kind: "confidence",
-                message: `agentDefinitions: agent "${agentId}" uses ${support?.schemaLabel ?? "an unsupported agent-definition schema"} and ${support?.status === "unsupported" ? support.reason : "does not expose a supported agent-definitions adapter"} — skipping "${entry.name}"`,
-            });
-            continue;
-        }
-        if (support.status === "planned") {
-            warnings.push({
-                kind: "confidence",
-                message: `agentDefinitions: agent "${agentId}" agent-definitions support is planned via ${support.plannedSurface} — skipping "${entry.name}" until that surface is implemented`,
-            });
-            continue;
-        }
-        supportedTargets.push({
-            agentId,
-            confidence: agent.provenance.agentDefinitions ?? "provisional",
-            target: resolvePlaceholders(support.path[platform], entry.name, home, repo, workspace),
-        });
-    }
-    if (supportedTargets.length === 0) {
-        return { actions, warnings };
-    }
-    // Validate the shared source file only when at least one target is active.
-    const source = path.resolve(sourceDir, entry.path);
-    await validateSourcePath(source, entry.path, resolvedSourceDir, realRoot);
-    await validateSourceFile(source, entry.path);
-    for (const target of supportedTargets) {
-        validateAgentRuleMarkdownPath(entry.path, target.agentId);
-        await validateInstructionFileRequirements(source, entry.path, target.agentId);
-        actions.push({
-            kind: "file-write",
-            skill: entry.name,
-            agent: target.agentId,
-            source,
-            target: target.target,
-            confidence: target.confidence,
-        });
-    }
-    return { actions, warnings };
-}
-export function compileAgentDefinitionReverts(entry, agentFilter, home, repo, workspace) {
-    const actions = [];
-    const platform = getPlatformKey();
-    for (const agentId of entry.agents) {
-        if (agentFilter && !agentFilter.includes(agentId))
-            continue;
-        const agent = AGENT_REGISTRY_BY_ID[agentId];
-        const support = agent?.agentDefinitionsSupport;
-        if (!support ||
-            support.status === "unsupported" ||
-            support.status === "planned")
-            continue;
-        const target = resolvePlaceholders(support.path[platform], entry.name, home, repo, workspace);
-        actions.push({
-            kind: "file-write",
-            skill: entry.name,
-            agent: agentId,
-            target,
-        });
-    }
-    return actions;
-}

package/dist/core/adapters/index.js

@@ -1,30 +0,0 @@
-import { compileAgentDefinitionActions, compileAgentDefinitionReverts, } from "./agent-definitions.js";
-import { compileMcpServerActions, compileMcpServerReverts } from "./mcp.js";
-import { compilePermissionsActions, compilePermissionsReverts, } from "./permissions.js";
-import { compileAgentRuleActions, compileAgentRuleReverts } from "./rules.js";
-export { compileAgentDefinitionReverts, compileAgentRuleReverts, compileMcpServerReverts, compilePermissionsReverts, };
-export async function compileAdapterActions(mcpServers, agentRules, permissions, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, agentDefinitions, workspace) {
-    const actions = [];
-    const warnings = [];
-    for (const entry of mcpServers) {
-        const r = compileMcpServerActions(entry, detectedAgents, home, repo, workspace);
-        actions.push(...r.actions);
-        warnings.push(...r.warnings);
-    }
-    for (const entry of agentRules) {
-        const r = await compileAgentRuleActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace);
-        actions.push(...r.actions);
-        warnings.push(...r.warnings);
-    }
-    for (const entry of permissions) {
-        const r = compilePermissionsActions(entry, detectedAgents, home);
-        actions.push(...r.actions);
-        warnings.push(...r.warnings);
-    }
-    for (const entry of agentDefinitions ?? []) {
-        const r = await compileAgentDefinitionActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace);
-        actions.push(...r.actions);
-        warnings.push(...r.warnings);
-    }
-    return { actions, warnings };
-}

package/dist/core/preflight.js

@@ -1,168 +0,0 @@
-import { readFile, stat } from "node:fs/promises";
-import path from "node:path";
-import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
-import { resolveRuntimePaths } from "./runtime-paths.js";
-const BUDGET_WARN_BYTES = 50 * 1024; // 50 KB
-async function detectEnterpriseManagement(agentId, home) {
-    if (!AGENT_REGISTRY_BY_ID[agentId]?.enterprisePolicyDetection)
-        return null;
-    // Check for common GitHub Enterprise environment variables
-    if (process.env.GITHUB_ENTERPRISE_URL ||
-        process.env.GH_ENTERPRISE_TOKEN ||
-        process.env.GITHUB_TOKEN_TYPE === "enterprise") {
-        return "GitHub Enterprise environment variables detected. Enterprise policies may override local configurations.";
-    }
-    const { xdgConfig, localAppdata } = resolveRuntimePaths(home);
-    const configPath = process.platform === "win32"
-        ? path.join(localAppdata, "github-copilot", "hosts.json")
-        : path.join(xdgConfig, "github-copilot", "hosts.json");
-    try {
-        const content = await readFile(configPath, "utf8");
-        const hosts = JSON.parse(content);
-        const hostNames = Object.keys(hosts);
-        const enterpriseHosts = hostNames.filter((h) => h !== "github.com" && h !== "localhost");
-        if (enterpriseHosts.length > 0) {
-            return `GitHub Copilot is authenticated against enterprise host(s): ${enterpriseHosts.join(", ")}. Enterprise policies may override local configurations.`;
-        }
-    }
-    catch (err) {
-        const code = err.code;
-        if (code !== "ENOENT" &&
-            code !== "EACCES" &&
-            code !== "EPERM" &&
-            code !== undefined) {
-            throw err;
-        }
-    }
-    return null;
-}
-function groupRulesByPath(rulesForAgent) {
-    const entriesByPath = new Map();
-    for (const entry of rulesForAgent ?? []) {
-        const list = entriesByPath.get(entry.path) ?? [];
-        list.push({ name: entry.name, scope: entry.scope });
-        entriesByPath.set(entry.path, list);
-    }
-    return entriesByPath;
-}
-function detectScopeOverlaps(agentId, rulesForAgent) {
-    const warnings = [];
-    const entriesByPath = groupRulesByPath(rulesForAgent);
-    for (const [path, list] of entriesByPath) {
-        const scopes = new Set(list.map((l) => l.scope));
-        if (scopes.size < 2)
-            continue;
-        const scopeList = Array.from(scopes).sort();
-        for (let i = 0; i < scopeList.length; i++) {
-            for (let j = i + 1; j < scopeList.length; j++) {
-                const entryB = list.find((l) => l.scope === scopeList[j]);
-                if (entryB) {
-                    warnings.push({
-                        kind: "precedence",
-                        message: `Agent "${agentId}" has agentRules entry "${entryB.name}" deployed to both ${scopeList[i]} and ${scopeList[j]} scope from the same source path "${path}". The file will be written to two distinct targets — verify this is intentional and not a copy-paste mistake.`,
-                    });
-                }
-            }
-        }
-    }
-    return warnings;
-}
-function detectMultipleActiveInstructionScopes(agentId, rulesForAgent) {
-    const activeScopes = Array.from(new Set((rulesForAgent ?? []).map((e) => e.scope))).sort();
-    if (activeScopes.length <= 1)
-        return [];
-    const scopeDescriptions = activeScopes
-        .map((s) => {
-        const entries = (rulesForAgent ?? []).filter((e) => e.scope === s);
-        return `${s} [${entries.map((e) => `"${e.name}"`).join(", ")}]`;
-    })
-        .join(" and ");
-    return [
-        {
-            kind: "precedence",
-            message: `Agent "${agentId}" will have multiple instruction files active simultaneously across ${activeScopes.length} scopes: ${scopeDescriptions}. All will be loaded by the agent — ensure the content is intended to stack and does not conflict.`,
-        },
-    ];
-}
-function detectInstructionPrecedence(detectedAgents, manifest) {
-    const warnings = [];
-    for (const agentId of detectedAgents) {
-        const rulesForAgent = (manifest.agentRules ?? []).filter((e) => e.agents.includes(agentId));
-        warnings.push(...detectScopeOverlaps(agentId, rulesForAgent));
-        warnings.push(...detectMultipleActiveInstructionScopes(agentId, rulesForAgent));
-    }
-    return warnings;
-}
-async function detectInstructionBudgetRisk(detectedAgents, manifest, sourceDir) {
-    const warnings = [];
-    const checkedPaths = new Set();
-    async function checkEntry(entryPath, label, agentIds) {
-        if (!agentIds.some((id) => detectedAgents.includes(id)))
-            return;
-        const sourcePath = path.resolve(sourceDir, entryPath);
-        if (checkedPaths.has(sourcePath))
-            return;
-        checkedPaths.add(sourcePath);
-        try {
-            const fileStat = await stat(sourcePath);
-            if (fileStat.size > BUDGET_WARN_BYTES) {
-                const sizeKb = (fileStat.size / 1024).toFixed(1);
-                warnings.push({
-                    kind: "budget",
-                    message: `${label} source "${entryPath}" is ${sizeKb} KB — large instruction files risk crowding out code context in the agent's context window. Consider splitting into smaller focused files.`,
-                });
-            }
-        }
-        catch (err) {
-            const code = err.code;
-            if (code !== "ENOENT" && code !== "EACCES" && code !== "EPERM")
-                throw err;
-            // Missing/unreadable files are silently skipped; compileAgentRuleActions
-            // will produce the proper UserError during action compilation.
-        }
-    }
-    for (const entry of manifest.agentRules ?? []) {
-        await checkEntry(entry.path, "agentRules", entry.agents);
-    }
-    for (const entry of manifest.agentDefinitions ?? []) {
-        await checkEntry(entry.path, "agentDefinitions", entry.agents);
-    }
-    return warnings;
-}
-export async function runPreflight(options, manifest, home, detectedAgents) {
-    const warnings = [];
-    for (const agentId of detectedAgents) {
-        const agent = AGENT_REGISTRY_BY_ID[agentId];
-        if (!agent)
-            continue;
-        if (agent.provenance.skills === "implementation-only") {
-            warnings.push({
-                kind: "config-authority",
-                message: `Agent "${agentId}" skill support is implementation-only: paths are derived from source inspection, not published documentation.`,
-            });
-        }
-        else if (agent.provenance.skills === "provisional") {
-            warnings.push({
-                kind: "config-authority",
-                message: `Agent "${agentId}" skill support is provisional: behavior has not been independently verified.`,
-            });
-        }
-        const enterpriseWarning = await detectEnterpriseManagement(agentId, home);
-        if (enterpriseWarning) {
-            warnings.push({
-                kind: "policy",
-                message: `Agent "${agentId}": ${enterpriseWarning}`,
-            });
-        }
-        else if (agent.policyNote &&
-            !agent.policyNote.includes("Organization policies may override")) {
-            warnings.push({
-                kind: "policy",
-                message: `Agent "${agentId}": ${agent.policyNote}`,
-            });
-        }
-    }
-    warnings.push(...detectInstructionPrecedence(detectedAgents, manifest));
-    warnings.push(...(await detectInstructionBudgetRisk(detectedAgents, manifest, options.directory)));
-    return warnings;
-}