@kuznai/inception-engine 0.4.0 → 0.4.1

package/README.md

@@ -165,8 +165,6 @@ inception-engine writes a structured `.inception-totem` marker file during every
 
 - **Atomic redeploy**: When overwriting an existing managed target, the engine renames the old target to a backup, creates the new deployment, and only removes the backup on success. If the new deployment fails, the backup is restored.
 
-> **Note:** Skills deployed before `.inception-totem` was introduced must be re-deployed before `revert` can remove them.
-
 ## Running with Privilege Escalation
 
 The tool works without elevated privileges. If run with `sudo` on POSIX systems, it looks up the real user's home directory from the OS directory services (`getent passwd` on Linux, `dscl` on macOS, `/etc/passwd` as a universal fallback) so skills are deployed to the correct location regardless of where home directories are stored — standard `/home/<user>`, LDAP/NIS paths, enterprise layouts, or otherwise.

package/dist/config/manifest.js

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { AGENT_IDS } from "../types.js";
 import { UserError } from "../errors.js";
+import { AGENT_IDS } from "../types.js";
 export async function loadManifest(directory) {
     const manifestPath = path.join(directory, "inception.json");
     let raw;
@@ -28,44 +28,45 @@ function validateManifest(data, filePath) {
     if (!Array.isArray(obj.skills)) {
         throw new UserError("MANIFEST_INVALID", `${filePath}: "skills" must be an array`);
     }
-    const skills = obj.skills.map((entry, i) => {
-        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-            throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}] must be an object`);
-        }
-        const skill = entry;
-        if (typeof skill.name !== "string" || skill.name.length === 0) {
-            throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].name must be a non-empty string`);
-        }
-        const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-        if (!SAFE_NAME_RE.test(skill.name)) {
-            throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].name must contain only letters, digits, hyphens, underscores, and dots, and must not start with a dot`);
-        }
-        if (typeof skill.path !== "string" || skill.path.length === 0) {
-            throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].path must be a non-empty string`);
-        }
-        if (path.isAbsolute(skill.path)) {
-            throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].path must be a relative path`);
-        }
-        if (path.normalize(skill.path).startsWith("..")) {
-            throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].path must not escape the repository root`);
-        }
-        if (!Array.isArray(skill.agents) || skill.agents.length === 0) {
-            throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].agents must be a non-empty array`);
-        }
-        for (const agent of skill.agents) {
-            if (!AGENT_IDS.includes(agent)) {
-                throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].agents contains unknown agent "${agent}". Valid agents: ${AGENT_IDS.join(", ")}`);
-            }
-        }
-        return {
-            name: skill.name,
-            path: skill.path,
-            agents: skill.agents,
-        };
-    });
+    const skills = obj.skills.map((entry, i) => validateSkillEntry(entry, i, filePath));
     return {
         skills,
         mcpServers: Array.isArray(obj.mcpServers) ? obj.mcpServers : [],
         agentRules: Array.isArray(obj.agentRules) ? obj.agentRules : [],
     };
 }
+const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+function validateSkillEntry(entry, i, filePath) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+        throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}] must be an object`);
+    }
+    const skill = entry;
+    if (typeof skill.name !== "string" || skill.name.length === 0) {
+        throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].name must be a non-empty string`);
+    }
+    if (!SAFE_NAME_RE.test(skill.name)) {
+        throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].name must contain only letters, digits, hyphens, underscores, and dots, and must not start with a dot`);
+    }
+    if (typeof skill.path !== "string" || skill.path.length === 0) {
+        throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].path must be a non-empty string`);
+    }
+    if (path.isAbsolute(skill.path)) {
+        throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].path must be a relative path`);
+    }
+    if (path.normalize(skill.path).startsWith("..")) {
+        throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].path must not escape the repository root`);
+    }
+    if (!Array.isArray(skill.agents) || skill.agents.length === 0) {
+        throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].agents must be a non-empty array`);
+    }
+    for (const agent of skill.agents) {
+        if (!AGENT_IDS.includes(agent)) {
+            throw new UserError("MANIFEST_INVALID", `${filePath}: skills[${i}].agents contains unknown agent "${agent}". Valid agents: ${AGENT_IDS.join(", ")}`);
+        }
+    }
+    return {
+        name: skill.name,
+        path: skill.path,
+        agents: skill.agents,
+    };
+}

package/dist/core/deploy.js

@@ -1,10 +1,10 @@
-import { access, lstat, mkdir, symlink, cp, unlink, rm, rename, realpath } from "node:fs/promises";
+import { access, cp, lstat, mkdir, realpath, rename, rm, symlink, unlink, } from "node:fs/promises";
 import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
-import { resolveAgentSkillPath, getDeployMethod } from "./resolve.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
 import { isOwnedByInceptionEngine, writeTotem } from "./ownership.js";
+import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
 export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     const method = getDeployMethod();
     const actions = [];
@@ -18,20 +18,7 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     }
     for (const skill of manifest.skills) {
         const source = path.resolve(sourceDir, skill.path);
-        if (!source.startsWith(resolvedSourceDir + path.sep)) {
-            throw new UserError("DEPLOY_FAILED", `Skill path "${skill.path}" resolves outside the repository root: ${source}`);
-        }
-        try {
-            const realSource = await realpath(source);
-            if (realSource !== realRoot && !realSource.startsWith(realRoot + path.sep)) {
-                throw new UserError("DEPLOY_FAILED", `Skill path "${skill.path}" resolves outside the repository root via symlink: ${source} -> ${realSource}`);
-            }
-        }
-        catch (err) {
-            if (err instanceof UserError)
-                throw err;
-            // Source doesn't exist yet — will be caught during execute
-        }
+        await validateSourcePath(source, skill.path, resolvedSourceDir, realRoot);
         for (const agentId of skill.agents) {
             if (!detectedAgents.includes(agentId))
                 continue;
@@ -39,7 +26,13 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
             if (!agent)
                 continue;
             const target = resolveAgentSkillPath(agent, skill.name, home);
-            actions.push({ skill: skill.name, agent: agentId, source, target, method });
+            actions.push({
+                skill: skill.name,
+                agent: agentId,
+                source,
+                target,
+                method,
+            });
         }
     }
     return actions;
@@ -67,48 +60,7 @@ export async function executeDeploy(actions, dryRun, verbose) {
             continue;
         }
         try {
-            const backupPath = await backupExisting(action.target, verbose);
-            await mkdir(path.dirname(action.target), { recursive: true });
-            try {
-                // Final TOCTOU check: ensure nothing appeared at the target after backup
-                try {
-                    await lstat(action.target);
-                    throw new Error(`Target path appeared unexpectedly after backup: ${action.target}`);
-                }
-                catch (err) {
-                    if (err instanceof Error && err.message.startsWith("Target path appeared"))
-                        throw err;
-                    // ENOENT is expected — target should not exist after backup
-                }
-                if (action.method === "symlink") {
-                    await symlink(action.source, action.target, "dir");
-                    await writeTotem(action.source, { source: action.source, skill: action.skill, agent: action.agent });
-                }
-                else {
-                    await cp(action.source, action.target, { recursive: true });
-                    await writeTotem(action.target, { source: action.source, skill: action.skill, agent: action.agent });
-                }
-            }
-            catch (createErr) {
-                // Rollback: restore backup if creation failed
-                if (backupPath) {
-                    try {
-                        await rename(backupPath, action.target);
-                    }
-                    catch {
-                        // Best-effort rollback
-                    }
-                }
-                throw createErr;
-            }
-            // Success: remove backup
-            if (backupPath) {
-                await removeTarget(backupPath);
-            }
-            logger.ok(label);
-            if (verbose) {
-                logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
-            }
+            await executeDeployAction(action, verbose);
             succeeded++;
         }
         catch (err) {
@@ -119,6 +71,79 @@ export async function executeDeploy(actions, dryRun, verbose) {
     }
     return { succeeded, failed };
 }
+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}`);
+    }
+    try {
+        const realSource = await realpath(source);
+        if (realSource !== realRoot &&
+            !realSource.startsWith(realRoot + path.sep)) {
+            throw new UserError("DEPLOY_FAILED", `Skill path "${skillPath}" resolves outside the repository root via symlink: ${source} -> ${realSource}`);
+        }
+    }
+    catch (err) {
+        if (err instanceof UserError)
+            throw err;
+        // Source doesn't exist yet — will be caught during execute
+    }
+}
+async function assertTargetAbsent(targetPath) {
+    try {
+        await lstat(targetPath);
+        throw new Error(`Target path appeared unexpectedly after backup: ${targetPath}`);
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.startsWith("Target path appeared"))
+            throw err;
+        // ENOENT is expected — target should not exist after backup
+    }
+}
+async function createDeployTarget(action) {
+    if (action.method === "symlink") {
+        await symlink(action.source, action.target, "dir");
+        await writeTotem(action.source, {
+            source: action.source,
+            skill: action.skill,
+            agent: action.agent,
+        });
+    }
+    else {
+        await cp(action.source, action.target, { recursive: true });
+        await writeTotem(action.target, {
+            source: action.source,
+            skill: action.skill,
+            agent: action.agent,
+        });
+    }
+}
+async function executeDeployAction(action, verbose) {
+    const label = `${action.skill} -> ${action.agent}`;
+    const backupPath = await backupExisting(action.target, verbose);
+    await mkdir(path.dirname(action.target), { recursive: true });
+    try {
+        await assertTargetAbsent(action.target);
+        await createDeployTarget(action);
+    }
+    catch (createErr) {
+        if (backupPath) {
+            try {
+                await rename(backupPath, action.target);
+            }
+            catch {
+                // Best-effort rollback
+            }
+        }
+        throw createErr;
+    }
+    if (backupPath) {
+        await removeTarget(backupPath);
+    }
+    logger.ok(label);
+    if (verbose) {
+        logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
+    }
+}
 async function backupExisting(targetPath, verbose) {
     let stat;
     try {
@@ -130,7 +155,7 @@ async function backupExisting(targetPath, verbose) {
     if (!(await isOwnedByInceptionEngine(targetPath, stat))) {
         throw new Error(`Target "${targetPath}" exists but is not managed by inception-engine — refusing to overwrite`);
     }
-    const backupPath = targetPath + ".inception-backup";
+    const backupPath = `${targetPath}.inception-backup`;
     // Clean up any stale backup from a previous failed attempt
     try {
         await lstat(backupPath);

package/dist/core/detect.js

@@ -1,5 +1,5 @@
-import { access } from "node:fs/promises";
 import { execFile } from "node:child_process";
+import { access } from "node:fs/promises";
 import { promisify } from "node:util";
 import { AGENT_REGISTRY } from "../config/agents.js";
 import { resolveAgentDetectPath } from "./resolve.js";
@@ -19,7 +19,9 @@ async function isAgentInstalled(agent, home) {
         await access(detectPath);
         return true;
     }
-    catch { }
+    catch {
+        // path does not exist — fall through to binary detection
+    }
     if (agent.detectBinary) {
         return isBinaryInPath(agent.detectBinary);
     }

package/dist/core/ownership.js

@@ -1,4 +1,4 @@
-import { access, readlink, readFile, writeFile, chmod } from "node:fs/promises";
+import { access, chmod, readFile, readlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 const TOTEM_FILE = ".inception-totem";
 const TOTEM_HEADER = "inception-engine";
@@ -10,7 +10,7 @@ export function formatTotem(data) {
         `agent=${data.agent}`,
         `deployed=${new Date().toISOString()}`,
     ];
-    return lines.join("\n") + "\n";
+    return `${lines.join("\n")}\n`;
 }
 export async function writeTotem(directory, data) {
     const totemPath = path.join(directory, TOTEM_FILE);

package/dist/core/resolve.js

@@ -7,41 +7,58 @@ export function resolveHome() {
     if (process.platform === "win32") {
         return os.homedir();
     }
-    const sudoUser = process.env["SUDO_USER"];
+    const sudoUser = process.env.SUDO_USER;
     if (sudoUser) {
         return lookupHomeForUser(sudoUser);
     }
     return os.homedir();
 }
 export function lookupHomeForUserWith(username, platform, execFileFn, readFileFn) {
-    // Method 1: getent passwd (Linux/POSIX — handles LDAP, NIS, local via NSS)
     if (platform !== "darwin") {
-        try {
-            const out = execFileFn("getent", ["passwd", username], {
-                encoding: "utf8",
-                stdio: ["ignore", "pipe", "ignore"],
-            }).trim();
-            const home = out.split(":")[5];
-            if (typeof home === "string" && home.startsWith("/"))
-                return home;
-        }
-        catch {
-            // getent unavailable or user not found — try next method
-        }
+        const home = lookupViaGetent(username, execFileFn);
+        if (home)
+            return home;
     }
-    // Method 2: dscl (macOS directory services)
     if (platform === "darwin") {
-        try {
-            const out = execFileFn("dscl", [".", "-read", `/Users/${username}`, "NFSHomeDirectory"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-            const home = out.replace(/^NFSHomeDirectory:\s*/, "").trim();
-            if (home.startsWith("/"))
-                return home;
-        }
-        catch {
-            // dscl unavailable or user record not found — try next method
-        }
+        const home = lookupViaDscl(username, execFileFn);
+        if (home)
+            return home;
     }
-    // Method 3: parse /etc/passwd directly (universal POSIX fallback)
+    const home = lookupViaEtcPasswd(username, readFileFn);
+    if (home)
+        return home;
+    throw new UserError("RESOLVE_FAILED", `Cannot determine home directory for user "${username}". ` +
+        `Tried getent, dscl, and /etc/passwd. ` +
+        `Run without sudo, or set HOME to the correct path before invoking with sudo.`);
+}
+function lookupViaGetent(username, execFileFn) {
+    try {
+        const out = execFileFn("getent", ["passwd", username], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        const home = out.split(":")[5];
+        if (typeof home === "string" && home.startsWith("/"))
+            return home;
+    }
+    catch {
+        // getent unavailable or user not found
+    }
+    return null;
+}
+function lookupViaDscl(username, execFileFn) {
+    try {
+        const out = execFileFn("dscl", [".", "-read", `/Users/${username}`, "NFSHomeDirectory"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+        const home = out.replace(/^NFSHomeDirectory:\s*/, "").trim();
+        if (home.startsWith("/"))
+            return home;
+    }
+    catch {
+        // dscl unavailable or user record not found
+    }
+    return null;
+}
+function lookupViaEtcPasswd(username, readFileFn) {
     try {
         const passwd = readFileFn("/etc/passwd", "utf8");
         for (const line of passwd.split("\n")) {
@@ -54,11 +71,9 @@ export function lookupHomeForUserWith(username, platform, execFileFn, readFileFn
         }
     }
     catch {
-        // /etc/passwd unavailable — fall through to error
+        // /etc/passwd unavailable
     }
-    throw new UserError("RESOLVE_FAILED", `Cannot determine home directory for user "${username}". ` +
-        `Tried getent, dscl, and /etc/passwd. ` +
-        `Run without sudo, or set HOME to the correct path before invoking with sudo.`);
+    return null;
 }
 function lookupHomeForUser(username) {
     return lookupHomeForUserWith(username, process.platform, execFileSync, readFileSync);
@@ -82,7 +97,7 @@ export function resolveAgentDetectPath(agent, home) {
     return resolveAgentDetectPathFor(agent, home, getPlatformKey());
 }
 function resolvePlaceholders(segments, skillName, home) {
-    const appdata = process.env["APPDATA"] ?? path.join(home, "AppData", "Roaming");
+    const appdata = process.env.APPDATA ?? path.join(home, "AppData", "Roaming");
     const resolved = segments.map((seg) => seg
         .replace("{home}", home)
         .replace("{name}", skillName)

package/dist/core/revert.js

@@ -1,8 +1,8 @@
-import { lstat, unlink, rm } from "node:fs/promises";
-import { AGENT_REGISTRY, AGENT_REGISTRY_BY_ID } from "../config/agents.js";
-import { resolveAgentSkillPath } from "./resolve.js";
+import { lstat, rm, unlink } from "node:fs/promises";
+import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { logger } from "../logger.js";
 import { isOwnedByInceptionEngine } from "./ownership.js";
+import { resolveAgentSkillPath } from "./resolve.js";
 export function planRevert(manifest, detectedAgents, home) {
     const actions = [];
     for (const skill of manifest.skills) {
@@ -35,46 +35,53 @@ export async function executeRevert(actions, dryRun, verbose) {
     let succeeded = 0;
     let skipped = 0;
     for (const action of actions) {
-        const label = `${action.skill} -> ${action.agent}`;
-        let stat;
-        try {
-            stat = await lstat(action.target);
-        }
-        catch {
-            logger.skip(label, "(not found, skipping)");
-            skipped++;
-            continue;
-        }
-        if (!(await isOwnedByInceptionEngine(action.target, stat))) {
-            logger.warn(label, `skipping: ${action.target} does not have inception-engine ownership proof — not managed by inception-engine`);
+        const result = await executeRevertAction(action, dryRun, verbose);
+        if (result === "skip") {
             skipped++;
-            continue;
         }
-        if (dryRun) {
-            logger.plan(label);
-            if (verbose) {
-                logger.detail(`would remove: ${action.target}`);
-            }
+        else {
             succeeded++;
-            continue;
         }
-        try {
-            if (stat.isSymbolicLink()) {
-                await unlink(action.target);
-            }
-            else {
-                await rm(action.target, { recursive: true });
-            }
-            logger.ok(label);
-            if (verbose) {
-                logger.detail(`removed: ${action.target}`);
-            }
-            succeeded++;
+    }
+    return { succeeded, skipped };
+}
+async function executeRevertAction(action, dryRun, verbose) {
+    const label = `${action.skill} -> ${action.agent}`;
+    let stat;
+    try {
+        stat = await lstat(action.target);
+    }
+    catch {
+        logger.skip(label, "(not found, skipping)");
+        return "skip";
+    }
+    if (!(await isOwnedByInceptionEngine(action.target, stat))) {
+        logger.warn(label, `skipping: ${action.target} does not have inception-engine ownership proof — not managed by inception-engine`);
+        return "skip";
+    }
+    if (dryRun) {
+        logger.plan(label);
+        if (verbose) {
+            logger.detail(`would remove: ${action.target}`);
+        }
+        return "ok";
+    }
+    try {
+        if (stat.isSymbolicLink()) {
+            await unlink(action.target);
+        }
+        else {
+            await rm(action.target, { recursive: true });
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            logger.fail(label, msg);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`removed: ${action.target}`);
         }
+        return "ok";
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return "skip";
     }
-    return { succeeded, skipped };
 }

package/dist/index.js

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import path from "node:path";
 import { parseArgs } from "node:util";
-import { AGENT_IDS } from "./types.js";
-import { loadManifest } from "./config/manifest.js";
 import { AGENT_REGISTRY } from "./config/agents.js";
-import { resolveHome } from "./core/resolve.js";
+import { loadManifest } from "./config/manifest.js";
+import { executeDeploy, planDeploy } from "./core/deploy.js";
 import { detectInstalledAgents } from "./core/detect.js";
-import { planDeploy, executeDeploy } from "./core/deploy.js";
-import { planRevert, planRevertAll, executeRevert } from "./core/revert.js";
+import { resolveHome } from "./core/resolve.js";
+import { executeRevert, planRevert, planRevertAll } from "./core/revert.js";
 import { UserError } from "./errors.js";
-import { logger, dryRunPrefix } from "./logger.js";
+import { dryRunPrefix, logger } from "./logger.js";
+import { AGENT_IDS } from "./types.js";
 const USAGE = `
 inception-engine - Deploy AI agent skills
 
@@ -30,7 +30,14 @@ Supported agents:
 function parseCLI(argv) {
     const args = argv.slice(2);
     if (args.length === 0) {
-        return { command: "help", directory: "", dryRun: false, agents: null, verbose: false, debug: false };
+        return {
+            command: "help",
+            directory: "",
+            dryRun: false,
+            agents: null,
+            verbose: false,
+            debug: false,
+        };
     }
     let parsed;
     try {
@@ -39,10 +46,10 @@ function parseCLI(argv) {
             allowPositionals: true,
             options: {
                 "dry-run": { type: "boolean", default: false },
-                "verbose": { type: "boolean", default: false },
-                "debug": { type: "boolean", default: false },
-                "help": { type: "boolean", default: false },
-                "agents": { type: "string" },
+                verbose: { type: "boolean", default: false },
+                debug: { type: "boolean", default: false },
+                help: { type: "boolean", default: false },
+                agents: { type: "string" },
             },
         });
     }
@@ -51,7 +58,14 @@ function parseCLI(argv) {
     }
     const { values, positionals } = parsed;
     if (values.help) {
-        return { command: "help", directory: "", dryRun: false, agents: null, verbose: false, debug: false };
+        return {
+            command: "help",
+            directory: "",
+            dryRun: false,
+            agents: null,
+            verbose: false,
+            debug: false,
+        };
     }
     let command = "deploy";
     let pos = positionals;
@@ -94,56 +108,59 @@ async function main() {
     const manifest = await loadManifest(options.directory);
     const home = resolveHome();
     if (options.command === "deploy") {
-        let detectedAgents;
-        if (options.agents) {
-            detectedAgents = options.agents;
-            if (options.verbose) {
-                logger.info(`Using specified agents: ${detectedAgents.join(", ")}`);
-            }
-        }
-        else {
-            detectedAgents = await detectInstalledAgents(home);
-            if (detectedAgents.length === 0) {
-                logger.info("No supported AI agents detected on this system.");
-                logger.info(`Install one of: ${AGENT_REGISTRY.map((a) => a.displayName).join(", ")}`);
-                return 0;
-            }
-            if (options.verbose) {
-                logger.info(`Detected agents: ${detectedAgents.join(", ")}`);
-            }
-        }
-        const actions = await planDeploy(manifest, options.directory, detectedAgents, home);
-        if (actions.length === 0) {
-            logger.info("No skills to deploy for detected agents.");
-            return 0;
-        }
-        logger.info(`${dryRunPrefix(options.dryRun)}Deploying ${actions.length} skill(s):`);
-        const { succeeded, failed } = await executeDeploy(actions, options.dryRun, options.verbose);
-        logger.info("");
-        if (failed.length > 0) {
-            logger.info(`${succeeded} succeeded, ${failed.length} failed`);
-            return 1;
-        }
-        else {
-            logger.info(`${succeeded} skill(s) deployed${options.dryRun ? " (dry-run)" : ""}`);
+        return runDeploy(options, manifest, home);
+    }
+    return runRevert(options, manifest, home);
+}
+async function runDeploy(options, manifest, home) {
+    let detectedAgents;
+    if (options.agents) {
+        detectedAgents = options.agents;
+        if (options.verbose) {
+            logger.info(`Using specified agents: ${detectedAgents.join(", ")}`);
         }
     }
     else {
-        const actions = options.agents
-            ? planRevert(manifest, options.agents, home)
-            : planRevertAll(manifest, home);
-        if (actions.length === 0) {
-            logger.info("No skills to revert.");
+        detectedAgents = await detectInstalledAgents(home);
+        if (detectedAgents.length === 0) {
+            logger.info("No supported AI agents detected on this system.");
+            logger.info(`Install one of: ${AGENT_REGISTRY.map((a) => a.displayName).join(", ")}`);
             return 0;
         }
-        logger.info(`${dryRunPrefix(options.dryRun)}Reverting ${actions.length} skill(s):`);
-        const { succeeded, skipped } = await executeRevert(actions, options.dryRun, options.verbose);
-        logger.info("");
-        const parts = [`${succeeded} removed`];
-        if (skipped > 0)
-            parts.push(`${skipped} skipped`);
-        logger.info(`${parts.join(", ")}${options.dryRun ? " (dry-run)" : ""}`);
+        if (options.verbose) {
+            logger.info(`Detected agents: ${detectedAgents.join(", ")}`);
+        }
+    }
+    const actions = await planDeploy(manifest, options.directory, detectedAgents, home);
+    if (actions.length === 0) {
+        logger.info("No skills to deploy for detected agents.");
+        return 0;
+    }
+    logger.info(`${dryRunPrefix(options.dryRun)}Deploying ${actions.length} skill(s):`);
+    const { succeeded, failed } = await executeDeploy(actions, options.dryRun, options.verbose);
+    logger.info("");
+    if (failed.length > 0) {
+        logger.info(`${succeeded} succeeded, ${failed.length} failed`);
+        return 1;
+    }
+    logger.info(`${succeeded} skill(s) deployed${options.dryRun ? " (dry-run)" : ""}`);
+    return 0;
+}
+async function runRevert(options, manifest, home) {
+    const actions = options.agents
+        ? planRevert(manifest, options.agents, home)
+        : planRevertAll(manifest, home);
+    if (actions.length === 0) {
+        logger.info("No skills to revert.");
+        return 0;
     }
+    logger.info(`${dryRunPrefix(options.dryRun)}Reverting ${actions.length} skill(s):`);
+    const { succeeded, skipped } = await executeRevert(actions, options.dryRun, options.verbose);
+    logger.info("");
+    const parts = [`${succeeded} removed`];
+    if (skipped > 0)
+        parts.push(`${skipped} skipped`);
+    logger.info(`${parts.join(", ")}${options.dryRun ? " (dry-run)" : ""}`);
     return 0;
 }
 const USER_ERROR_EXIT = {

package/dist/logger.js

@@ -57,5 +57,5 @@ export const logger = createLogger();
 export function dryRunPrefix(dryRun) {
     if (!dryRun)
         return "";
-    return Boolean(process.stdout.isTTY) ? `\x1b[36m[dry-run]\x1b[0m ` : `[dry-run] `;
+    return process.stdout.isTTY ? `\x1b[36m[dry-run]\x1b[0m ` : `[dry-run] `;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuznai/inception-engine",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Deploy AI agent skills from a git repo to user home directories",
   "license": "MIT",
   "author": "Damian Piątkowski",
@@ -36,12 +36,15 @@
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
+    "format": "biome format --write .",
+    "lint": "biome lint . --max-diagnostics none",
     "dev": "node src/index.ts",
     "test": "node --test test/*.test.ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run typecheck && npm run lint && npm run build"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.8",
     "@types/node": "^25.5.0",
-    "typescript": "^5.8.0"
+    "typescript": "^6.0.2"
   }
 }