@kuznai/inception-engine 0.6.0 → 0.6.2

package/dist/config/manifest.js

@@ -38,6 +38,11 @@ function validateManifest(data, filePath) {
         if (issuePath.length === 1 && issuePath[0] === "skills") {
             throw new UserError("MANIFEST_INVALID", `${filePath}: "skills" must be an array`);
         }
+        // Top-level "mcpServers" or "agentRules": wrong type → uniform message
+        if (issuePath.length === 1 &&
+            (issuePath[0] === "mcpServers" || issuePath[0] === "agentRules")) {
+            throw new UserError("MANIFEST_INVALID", `${filePath}: "${issuePath[0]}" must be an array`);
+        }
         throw new UserError("MANIFEST_INVALID", `${filePath}: ${formatZodPath(issuePath)}${issue.message}`);
     }
     return result.data;

package/dist/core/deploy.js

@@ -28,6 +28,7 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     for (const skill of manifest.skills) {
         const source = path.resolve(sourceDir, skill.path);
         await validateSourcePath(source, skill.path, resolvedSourceDir, realRoot);
+        await validateSkillContract(source, skill.path);
         for (const agentId of skill.agents) {
             if (!detectedAgents.includes(agentId))
                 continue;
@@ -36,6 +37,7 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
                 continue;
             const target = resolveAgentSkillPath(agent, skill.name, home);
             actions.push({
+                kind: "skill-dir",
                 skill: skill.name,
                 agent: agentId,
                 source,
@@ -50,36 +52,52 @@ export async function executeDeploy(actions, dryRun, verbose, home) {
     let succeeded = 0;
     const failed = [];
     for (const action of actions) {
-        const label = `${action.skill} -> ${action.agent}`;
-        try {
-            await access(action.source);
-        }
-        catch (err) {
-            const msg = sourceAccessError(err, action.source);
-            failed.push({ action, error: msg });
-            logger.fail(label, msg);
-            continue;
-        }
-        if (dryRun) {
-            logger.plan(label);
-            if (verbose) {
-                logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
+        switch (action.kind) {
+            case "skill-dir": {
+                const result = await deploySkillDir(action, dryRun, verbose, home);
+                if (result.error === null) {
+                    succeeded++;
+                }
+                else {
+                    failed.push({ action, error: result.error });
+                }
+                break;
+            }
+            default: {
+                const _ = action.kind;
+                throw new Error(`Unhandled deploy action kind: ${_}`);
             }
-            succeeded++;
-            continue;
-        }
-        try {
-            await executeDeployAction(action, verbose, home);
-            succeeded++;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            failed.push({ action, error: msg });
-            logger.fail(label, msg);
         }
     }
     return { succeeded, failed };
 }
+async function deploySkillDir(action, dryRun, verbose, home) {
+    const label = `${action.skill} -> ${action.agent}`;
+    try {
+        await access(action.source);
+    }
+    catch (err) {
+        const msg = sourceAccessError(err, action.source);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+    if (dryRun) {
+        logger.plan(label);
+        if (verbose) {
+            logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
+        }
+        return { error: null };
+    }
+    try {
+        await executeDeployAction(action, verbose, home);
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
 async function validateSourcePath(source, skillPath, resolvedSourceDir, realRoot) {
     if (!source.startsWith(resolvedSourceDir + path.sep)) {
         throw new UserError("DEPLOY_FAILED", `Skill path "${skillPath}" resolves outside the repository root: ${source}`);
@@ -97,6 +115,31 @@ async function validateSourcePath(source, skillPath, resolvedSourceDir, realRoot
         // Source doesn't exist yet — will be caught during execute
     }
 }
+async function validateSkillContract(source, skillPath) {
+    let stat;
+    try {
+        stat = await lstat(source);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            throw new UserError("DEPLOY_FAILED", `Skill "${skillPath}" source not found: ${source}`);
+        }
+        if (code === "EACCES" || code === "EPERM") {
+            throw new UserError("DEPLOY_FAILED", `Permission denied accessing skill "${skillPath}" source: ${source}`);
+        }
+        throw new UserError("DEPLOY_FAILED", `Cannot access skill "${skillPath}" source: ${source}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new UserError("DEPLOY_FAILED", `Skill "${skillPath}" source is not a directory: ${source}`);
+    }
+    try {
+        await access(path.join(source, "SKILL.md"));
+    }
+    catch {
+        throw new UserError("DEPLOY_FAILED", `Skill "${skillPath}" source is missing SKILL.md: ${source}`);
+    }
+}
 async function assertTargetAbsent(targetPath) {
     try {
         await lstat(targetPath);

package/dist/core/detect.d.ts

@@ -1,2 +1,7 @@
 import type { AgentId } from "../types.ts";
+export type ExecFn = (cmd: string, args: readonly string[]) => Promise<void>;
 export declare function detectInstalledAgents(home: string): Promise<AgentId[]>;
+export declare function isBinaryInPath(binary: string, execFn?: ExecFn): Promise<boolean>;
+export declare function isBinaryViaWhereExe(binary: string, execFn?: ExecFn): Promise<boolean>;
+export declare function isBinaryViaCommandV(binary: string): Promise<boolean>;
+export declare function isBinaryViaWhich(binary: string, execFn?: ExecFn): Promise<boolean>;

package/dist/core/detect.js

@@ -4,6 +4,9 @@ import { promisify } from "node:util";
 import { AGENT_REGISTRY } from "../config/agents.js";
 import { resolveAgentDetectPath } from "./resolve.js";
 const execFileAsync = promisify(execFile);
+const defaultExecFn = async (cmd, args) => {
+    await execFileAsync(cmd, args);
+};
 export async function detectInstalledAgents(home) {
     const detected = [];
     for (const agent of AGENT_REGISTRY) {
@@ -27,18 +30,12 @@ async function isAgentInstalled(agent, home) {
     }
     return false;
 }
-async function isBinaryInPath(binary) {
+export async function isBinaryInPath(binary, execFn = defaultExecFn) {
     if (process.platform === "win32") {
-        try {
-            await execFileAsync("where.exe", [binary]);
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return isBinaryViaWhereExe(binary, execFn);
     }
     try {
-        await execFileAsync("which", [binary]);
+        await execFn("which", [binary]);
         return true;
     }
     catch (err) {
@@ -49,9 +46,19 @@ async function isBinaryInPath(binary) {
         return false;
     }
 }
+// Windows-only: use where.exe to check if a binary is in PATH.
+export async function isBinaryViaWhereExe(binary, execFn = defaultExecFn) {
+    try {
+        await execFn("where.exe", [binary]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // Used only when `which` is absent (e.g. minimal Alpine containers).
 // `command -v` is a POSIX shell built-in available wherever /bin/sh is.
-async function isBinaryViaCommandV(binary) {
+export async function isBinaryViaCommandV(binary) {
     try {
         // Pass binary as a positional arg ($1) to avoid any shell-injection risk.
         await execFileAsync("sh", ["-c", 'command -v "$1"', "--", binary]);
@@ -61,6 +68,16 @@ async function isBinaryViaCommandV(binary) {
         return false;
     }
 }
+// POSIX: use `which` to check if a binary is in PATH.
+export async function isBinaryViaWhich(binary, execFn = defaultExecFn) {
+    try {
+        await execFn("which", [binary]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function isENOENT(err) {
     return (typeof err === "object" &&
         err !== null &&

package/dist/core/revert.js

@@ -13,7 +13,12 @@ export function planRevert(manifest, detectedAgents, home) {
             if (!agent)
                 continue;
             const target = resolveAgentSkillPath(agent, skill.name, home);
-            actions.push({ skill: skill.name, agent: agentId, target });
+            actions.push({
+                kind: "skill-dir",
+                skill: skill.name,
+                agent: agentId,
+                target,
+            });
         }
     }
     return actions;
@@ -26,7 +31,12 @@ export function planRevertAll(manifest, home) {
             if (!agent)
                 continue;
             const target = resolveAgentSkillPath(agent, skill.name, home);
-            actions.push({ skill: skill.name, agent: agentId, target });
+            actions.push({
+                kind: "skill-dir",
+                skill: skill.name,
+                agent: agentId,
+                target,
+            });
         }
     }
     return actions;
@@ -43,15 +53,24 @@ export async function executeRevert(actions, dryRun, verbose, home) {
     let skipped = 0;
     const failed = [];
     for (const action of actions) {
-        const result = await executeRevertAction(action, dryRun, verbose, home);
-        if (result.outcome === "fail") {
-            failed.push({ action, error: result.error });
-        }
-        else if (result.outcome === "skip") {
-            skipped++;
-        }
-        else {
-            succeeded++;
+        switch (action.kind) {
+            case "skill-dir": {
+                const result = await executeRevertAction(action, dryRun, verbose, home);
+                if (result.outcome === "fail") {
+                    failed.push({ action, error: result.error });
+                }
+                else if (result.outcome === "skip") {
+                    skipped++;
+                }
+                else {
+                    succeeded++;
+                }
+                break;
+            }
+            default: {
+                const _ = action.kind;
+                throw new Error(`Unhandled revert action kind: ${_}`);
+            }
         }
     }
     return { succeeded, skipped, failed };

package/dist/schemas/manifest.d.ts

@@ -13,30 +13,30 @@ export type AgentId = z.output<typeof AgentIdSchema>;
 export declare const SkillEntrySchema: z.ZodObject<{
     name: z.ZodString;
     path: z.ZodString;
-    agents: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
+    agents: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
         "claude-code": "claude-code";
         codex: "codex";
         "gemini-cli": "gemini-cli";
         antigravity: "antigravity";
         opencode: "opencode";
         "github-copilot": "github-copilot";
-    }>>>;
+    }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
 }, z.core.$strip>;
 export declare const ManifestSchema: z.ZodObject<{
     skills: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         path: z.ZodString;
-        agents: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
+        agents: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
             "claude-code": "claude-code";
             codex: "codex";
             "gemini-cli": "gemini-cli";
             antigravity: "antigravity";
             opencode: "opencode";
             "github-copilot": "github-copilot";
-        }>>>;
+        }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     }, z.core.$strip>>;
-    mcpServers: z.ZodCatch<z.ZodArray<z.ZodUnknown>>;
-    agentRules: z.ZodCatch<z.ZodArray<z.ZodUnknown>>;
+    mcpServers: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
+    agentRules: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
 }, z.core.$strip>;
 export type SkillEntry = z.infer<typeof SkillEntrySchema>;
 export type Manifest = z.infer<typeof ManifestSchema>;

package/dist/schemas/manifest.js

@@ -44,12 +44,25 @@ export const SkillEntrySchema = z.object({
     }),
     agents: z
         .array(agentIdElement, { message: "agents must be a non-empty array" })
-        .min(1, { message: "agents must be a non-empty array" }),
+        .min(1, { message: "agents must be a non-empty array" })
+        .transform((arr) => [...new Set(arr)]),
 });
 export const ManifestSchema = z.object({
-    skills: z.array(SkillEntrySchema),
-    mcpServers: z.array(z.unknown()).catch([]),
-    agentRules: z.array(z.unknown()).catch([]),
+    skills: z.array(SkillEntrySchema).superRefine((skills, ctx) => {
+        const seen = new Set();
+        for (const [i, skill] of skills.entries()) {
+            if (seen.has(skill.name)) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: [i, "name"],
+                    message: `duplicate skill name "${skill.name}"`,
+                });
+            }
+            seen.add(skill.name);
+        }
+    }),
+    mcpServers: z.array(z.unknown()).default([]),
+    agentRules: z.array(z.unknown()).default([]),
 });
 // Parses the --agents CLI flag: comma-separated agent IDs → AgentId[]
 export const AgentListSchema = z

package/dist/types.d.ts

@@ -18,18 +18,22 @@ export interface AgentConfig {
     detectBinary: string | null;
     provenance: AgentProvenance;
 }
-export interface DeployAction {
+export interface SkillDirDeployAction {
+    kind: "skill-dir";
     skill: string;
     agent: AgentId;
     source: string;
     target: string;
     method: "symlink" | "copy";
 }
-export interface RevertAction {
+export type DeployAction = SkillDirDeployAction;
+export interface SkillDirRevertAction {
+    kind: "skill-dir";
     skill: string;
     agent: AgentId;
     target: string;
 }
+export type RevertAction = SkillDirRevertAction;
 export interface CliOptions {
     command: "deploy" | "revert" | "help";
     directory: string;

package/package.json

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