@kuznai/inception-engine 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Damian Piątkowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,166 @@
+# inception-engine
+
+Plant skills directly into the minds of your installed AI coding agents — Claude Code, Codex, Gemini CLI, Antigravity, OpenCode, and GitHub Copilot. One command. They'll think they thought of it themselves.
+
+## Quick Start
+
+```bash
+npx inception-engine <directory>
+```
+
+Where `<directory>` is a repo (or subdirectory) containing an `inception.json` manifest and skill files.
+
+## How It Works
+
+inception-engine reads a manifest file (`inception.json`) from the target directory, detects which AI coding agents are installed on the system, and deploys skills to each agent's expected location.
+
+- **POSIX (macOS, Linux)**: creates symlinks from the source skill directory to each agent's skill path
+- **Windows**: copies skill directories to each agent's skill path
+
+Skills always overwrite their previous version. On POSIX systems, symlinks mean updates to the source repo are reflected immediately.
+
+## Agent Compatibility Matrix
+
+| Agent | ID | Skills | macOS | Linux | Windows |
+|---|---|---|---|---|---|
+| Claude Code | `claude-code` | `~/.claude/skills/` | Yes | Yes | Yes |
+| OpenAI Codex | `codex` | `~/.codex/skills/` | Yes | Yes | Yes |
+| Gemini CLI | `gemini-cli` | `~/.gemini/skills/` | Yes | Yes | Yes |
+| Antigravity | `antigravity` | `~/.gemini/antigravity/skills/` | Yes | Yes | Yes |
+| OpenCode | `opencode` | `~/.config/opencode/skills/` | Yes | Yes | Yes* |
+| GitHub Copilot | `github-copilot` | `~/.copilot/skills/` | Yes | Yes | Yes |
+
+\* OpenCode on Windows uses `%APPDATA%\opencode\skills\`.
+
+### Feature Support
+
+| Feature | Status |
+|---|---|
+| Skills (SKILL.md) | Supported |
+| MCP Servers | Planned |
+| Agent Rules | Planned |
+
+## Manifest Format
+
+Create an `inception.json` file at the root of your skills directory:
+
+```json
+{
+  "skills": [
+    {
+      "name": "my-skill",
+      "path": "skills/my-skill",
+      "agents": ["claude-code", "codex", "gemini-cli", "antigravity", "opencode", "github-copilot"]
+    }
+  ],
+  "mcpServers": [],
+  "agentRules": []
+}
+```
+
+Each skill entry has:
+
+- **name** - Unique skill identifier (lowercase, hyphens allowed)
+- **path** - Relative path to the skill directory within the repo
+- **agents** - Array of agent IDs to deploy this skill to. If an agent isn't installed, it's skipped.
+
+## Creating Skills
+
+Each skill is a directory containing at minimum a `SKILL.md` file with YAML frontmatter:
+
+```markdown
+---
+name: my-skill
+description: What this skill does and when to use it
+---
+
+# My Skill
+
+Instructions for the AI agent...
+```
+
+The `name` and `description` fields in the frontmatter are required by most agents. The description determines when the agent activates the skill.
+
+## CLI Reference
+
+```
+inception-engine <directory> [options]
+inception-engine revert <directory> [options]
+```
+
+### Commands
+
+| Command | Description |
+|---|---|
+| `<directory>` | Deploy skills from the manifest in the given directory |
+| `revert <directory>` | Remove all skills declared in the manifest |
+
+### Options
+
+| Option | Description |
+|---|---|
+| `--dry-run` | Show what would be done without making changes |
+| `--agents <list>` | Comma-separated list of agent IDs to target (skips detection) |
+| `--verbose` | Show detailed output including file paths |
+| `--debug` | Show full error stack traces |
+| `--help` | Show help message |
+
+### Examples
+
+```bash
+# Deploy all skills to all detected agents
+npx inception-engine ./my-skills-repo
+
+# Preview what would be deployed
+npx inception-engine ./my-skills-repo --dry-run
+
+# Deploy only to Claude Code and Codex
+npx inception-engine ./my-skills-repo --agents claude-code,codex
+
+# Remove deployed skills
+npx inception-engine revert ./my-skills-repo
+
+# Preview what would be removed
+npx inception-engine revert ./my-skills-repo --dry-run
+```
+
+## Sample Skills
+
+The `limbo/` directory contains exceptional sample skills for testing purposes only.
+
+Try them out:
+
+```bash
+npx inception-engine limbo --dry-run
+```
+
+## Agent Detection
+
+inception-engine automatically detects which agents are installed by checking:
+
+1. Whether the agent's config directory exists (e.g., `~/.claude/` for Claude Code)
+2. Whether the agent's binary is in your PATH (e.g., `claude`, `codex`, `gemini`)
+
+If an agent isn't detected, its skills are skipped. Use `--agents` to override detection.
+
+## Cross-Platform Behavior
+
+| Platform | Deploy Method | Behavior |
+|---|---|---|
+| macOS | Symlink | Source changes are reflected immediately |
+| Linux | Symlink | Source changes are reflected immediately |
+| Windows | Copy | Source must be re-deployed after changes |
+
+## Running with Privilege Escalation
+
+The tool works without elevated privileges. If run with `sudo` on POSIX systems, it resolves the real user's home directory via `SUDO_USER` so skills are deployed to the correct location (not `/root/`).
+
+On Windows, `os.homedir()` correctly resolves even in elevated PowerShell or cmd.
+
+## Requirements
+
+- Node.js >= 23.6.0
+
+## License
+
+MIT

package/dist/config/agents.d.ts

@@ -0,0 +1,2 @@
+import type { AgentConfig } from "../types.ts";
+export declare const AGENT_REGISTRY: readonly AgentConfig[];

package/dist/config/agents.js

@@ -0,0 +1,80 @@
+export const AGENT_REGISTRY = [
+    {
+        id: "claude-code",
+        displayName: "Claude Code",
+        skills: {
+            posix: "{home}/.claude/skills/{name}",
+            windows: "{home}\\.claude\\skills\\{name}",
+        },
+        detectPaths: {
+            posix: "{home}/.claude",
+            windows: "{home}\\.claude",
+        },
+        detectBinary: "claude",
+    },
+    {
+        id: "codex",
+        displayName: "OpenAI Codex",
+        skills: {
+            posix: "{home}/.codex/skills/{name}",
+            windows: "{home}\\.codex\\skills\\{name}",
+        },
+        detectPaths: {
+            posix: "{home}/.codex",
+            windows: "{home}\\.codex",
+        },
+        detectBinary: "codex",
+    },
+    {
+        id: "gemini-cli",
+        displayName: "Gemini CLI",
+        skills: {
+            posix: "{home}/.gemini/skills/{name}",
+            windows: "{home}\\.gemini\\skills\\{name}",
+        },
+        detectPaths: {
+            posix: "{home}/.gemini",
+            windows: "{home}\\.gemini",
+        },
+        detectBinary: "gemini",
+    },
+    {
+        id: "antigravity",
+        displayName: "Antigravity",
+        skills: {
+            posix: "{home}/.gemini/antigravity/skills/{name}",
+            windows: "{home}\\.gemini\\antigravity\\skills\\{name}",
+        },
+        detectPaths: {
+            posix: "{home}/.gemini/antigravity",
+            windows: "{home}\\.gemini\\antigravity",
+        },
+        detectBinary: null,
+    },
+    {
+        id: "opencode",
+        displayName: "OpenCode",
+        skills: {
+            posix: "{home}/.config/opencode/skills/{name}",
+            windows: "{appdata}\\opencode\\skills\\{name}",
+        },
+        detectPaths: {
+            posix: "{home}/.config/opencode",
+            windows: "{appdata}\\opencode",
+        },
+        detectBinary: "opencode",
+    },
+    {
+        id: "github-copilot",
+        displayName: "GitHub Copilot",
+        skills: {
+            posix: "{home}/.copilot/skills/{name}",
+            windows: "{home}\\.copilot\\skills\\{name}",
+        },
+        detectPaths: {
+            posix: "{home}/.copilot",
+            windows: "{home}\\.copilot",
+        },
+        detectBinary: "github-copilot",
+    },
+];

package/dist/config/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { Manifest } from "../types.ts";
+export declare function loadManifest(directory: string): Manifest;

package/dist/config/manifest.js

@@ -0,0 +1,61 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { AGENT_IDS } from "../types.js";
+import { UserError } from "../errors.js";
+export function loadManifest(directory) {
+    const manifestPath = path.join(directory, "inception.json");
+    let raw;
+    try {
+        raw = readFileSync(manifestPath, "utf-8");
+    }
+    catch {
+        throw new UserError(`No inception.json found in ${directory}. Are you pointing to the right repo?`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new UserError(`Invalid JSON in ${manifestPath}`);
+    }
+    return validateManifest(parsed, manifestPath);
+}
+function validateManifest(data, filePath) {
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+        throw new UserError(`${filePath}: manifest must be a JSON object`);
+    }
+    const obj = data;
+    if (!Array.isArray(obj.skills)) {
+        throw new UserError(`${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(`${filePath}: skills[${i}] must be an object`);
+        }
+        const skill = entry;
+        if (typeof skill.name !== "string" || skill.name.length === 0) {
+            throw new UserError(`${filePath}: skills[${i}].name must be a non-empty string`);
+        }
+        if (typeof skill.path !== "string" || skill.path.length === 0) {
+            throw new UserError(`${filePath}: skills[${i}].path must be a non-empty string`);
+        }
+        if (!Array.isArray(skill.agents) || skill.agents.length === 0) {
+            throw new UserError(`${filePath}: skills[${i}].agents must be a non-empty array`);
+        }
+        for (const agent of skill.agents) {
+            if (!AGENT_IDS.includes(agent)) {
+                throw new UserError(`${filePath}: skills[${i}].agents contains unknown agent "${agent}". Valid agents: ${AGENT_IDS.join(", ")}`);
+            }
+        }
+        return {
+            name: skill.name,
+            path: skill.path,
+            agents: skill.agents,
+        };
+    });
+    return {
+        skills,
+        mcpServers: Array.isArray(obj.mcpServers) ? obj.mcpServers : [],
+        agentRules: Array.isArray(obj.agentRules) ? obj.agentRules : [],
+    };
+}

package/dist/core/deploy.d.ts

@@ -0,0 +1,9 @@
+import type { AgentId, DeployAction, Manifest } from "../types.ts";
+export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string): DeployAction[];
+export declare function executeDeploy(actions: DeployAction[], dryRun: boolean, verbose: boolean): {
+    succeeded: number;
+    failed: Array<{
+        action: DeployAction;
+        error: string;
+    }>;
+};

package/dist/core/deploy.js

@@ -0,0 +1,87 @@
+import { existsSync, lstatSync, mkdirSync, rmSync, symlinkSync, cpSync, unlinkSync, } from "node:fs";
+import path from "node:path";
+import { AGENT_REGISTRY } from "../config/agents.js";
+import { resolveAgentSkillPath, getDeployMethod } from "./resolve.js";
+export function planDeploy(manifest, sourceDir, detectedAgents, home) {
+    const method = getDeployMethod();
+    const actions = [];
+    for (const skill of manifest.skills) {
+        const source = path.resolve(sourceDir, skill.path);
+        for (const agentId of skill.agents) {
+            if (!detectedAgents.includes(agentId))
+                continue;
+            const agent = AGENT_REGISTRY.find((a) => a.id === agentId);
+            if (!agent)
+                continue;
+            const target = resolveAgentSkillPath(agent, skill.name, home);
+            actions.push({ skill: skill.name, agent: agentId, source, target, method });
+        }
+    }
+    return actions;
+}
+export function executeDeploy(actions, dryRun, verbose) {
+    let succeeded = 0;
+    const failed = [];
+    for (const action of actions) {
+        const label = `${action.skill} -> ${action.agent}`;
+        if (!existsSync(action.source)) {
+            const msg = `Source not found: ${action.source}`;
+            failed.push({ action, error: msg });
+            console.error(`  \x1b[31m✗\x1b[0m ${label}: ${msg}`);
+            continue;
+        }
+        if (dryRun) {
+            console.log(`  \x1b[36m○\x1b[0m ${label}`);
+            if (verbose) {
+                console.log(`    ${action.method}: ${action.source} -> ${action.target}`);
+            }
+            succeeded++;
+            continue;
+        }
+        try {
+            removeExisting(action.target, verbose);
+            mkdirSync(path.dirname(action.target), { recursive: true });
+            if (action.method === "symlink") {
+                symlinkSync(action.source, action.target, "dir");
+            }
+            else {
+                cpSync(action.source, action.target, { recursive: true });
+            }
+            console.log(`  \x1b[32m✓\x1b[0m ${label}`);
+            if (verbose) {
+                console.log(`    ${action.method}: ${action.source} -> ${action.target}`);
+            }
+            succeeded++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            failed.push({ action, error: msg });
+            console.error(`  \x1b[31m✗\x1b[0m ${label}: ${msg}`);
+        }
+    }
+    return { succeeded, failed };
+}
+function removeExisting(targetPath, verbose) {
+    if (!existsSync(targetPath) && !isSymlink(targetPath))
+        return;
+    if (isSymlink(targetPath)) {
+        if (verbose) {
+            console.log(`    removing existing symlink: ${targetPath}`);
+        }
+        unlinkSync(targetPath);
+    }
+    else {
+        if (verbose) {
+            console.log(`    \x1b[33m!\x1b[0m replacing existing directory: ${targetPath}`);
+        }
+        rmSync(targetPath, { recursive: true });
+    }
+}
+function isSymlink(p) {
+    try {
+        return lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/detect.d.ts

@@ -0,0 +1,2 @@
+import type { AgentId } from "../types.ts";
+export declare function detectInstalledAgents(home: string): AgentId[];

package/dist/core/detect.js

@@ -0,0 +1,33 @@
+import { existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { AGENT_REGISTRY } from "../config/agents.js";
+import { resolveAgentDetectPath } from "./resolve.js";
+export function detectInstalledAgents(home) {
+    const detected = [];
+    for (const agent of AGENT_REGISTRY) {
+        if (isAgentInstalled(agent, home)) {
+            detected.push(agent.id);
+        }
+    }
+    return detected;
+}
+function isAgentInstalled(agent, home) {
+    const detectPath = resolveAgentDetectPath(agent, home);
+    if (existsSync(detectPath)) {
+        return true;
+    }
+    if (agent.detectBinary) {
+        return isBinaryInPath(agent.detectBinary);
+    }
+    return false;
+}
+function isBinaryInPath(binary) {
+    const command = process.platform === "win32" ? "where.exe" : "which";
+    try {
+        execFileSync(command, [binary], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/resolve.d.ts

@@ -0,0 +1,6 @@
+import type { AgentConfig } from "../types.ts";
+export declare function resolveHome(): string;
+export declare function getPlatformKey(): "posix" | "windows";
+export declare function getDeployMethod(): "symlink" | "copy";
+export declare function resolveAgentSkillPath(agent: AgentConfig, skillName: string, home: string): string;
+export declare function resolveAgentDetectPath(agent: AgentConfig, home: string): string;

package/dist/core/resolve.js

@@ -0,0 +1,38 @@
+import os from "node:os";
+import path from "node:path";
+export function resolveHome() {
+    if (process.platform === "win32") {
+        return os.homedir();
+    }
+    const sudoUser = process.env["SUDO_USER"];
+    if (sudoUser) {
+        const base = process.platform === "darwin" ? "/Users" : "/home";
+        return path.join(base, sudoUser);
+    }
+    return os.homedir();
+}
+export function getPlatformKey() {
+    return process.platform === "win32" ? "windows" : "posix";
+}
+export function getDeployMethod() {
+    return process.platform === "win32" ? "copy" : "symlink";
+}
+export function resolveAgentSkillPath(agent, skillName, home) {
+    const platform = getPlatformKey();
+    const template = agent.skills[platform];
+    return resolvePlaceholders(template, skillName, home);
+}
+export function resolveAgentDetectPath(agent, home) {
+    const platform = getPlatformKey();
+    const template = agent.detectPaths[platform];
+    return resolvePlaceholders(template, "", home);
+}
+function resolvePlaceholders(template, skillName, home) {
+    let result = template.replace("{home}", home);
+    result = result.replace("{name}", skillName);
+    if (result.includes("{appdata}")) {
+        const appdata = process.env["APPDATA"] ?? path.join(home, "AppData", "Roaming");
+        result = result.replace("{appdata}", appdata);
+    }
+    return result;
+}

package/dist/core/revert.d.ts

@@ -0,0 +1,6 @@
+import type { AgentId, Manifest, RevertAction } from "../types.ts";
+export declare function planRevert(manifest: Manifest, detectedAgents: AgentId[], home: string): RevertAction[];
+export declare function executeRevert(actions: RevertAction[], dryRun: boolean, verbose: boolean): {
+    succeeded: number;
+    skipped: number;
+};

package/dist/core/revert.js

@@ -0,0 +1,64 @@
+import { existsSync, lstatSync, unlinkSync, rmSync } from "node:fs";
+import { AGENT_REGISTRY } from "../config/agents.js";
+import { resolveAgentSkillPath } from "./resolve.js";
+export function planRevert(manifest, detectedAgents, home) {
+    const actions = [];
+    for (const skill of manifest.skills) {
+        for (const agentId of skill.agents) {
+            if (!detectedAgents.includes(agentId))
+                continue;
+            const agent = AGENT_REGISTRY.find((a) => a.id === agentId);
+            if (!agent)
+                continue;
+            const target = resolveAgentSkillPath(agent, skill.name, home);
+            actions.push({ skill: skill.name, agent: agentId, target });
+        }
+    }
+    return actions;
+}
+export function executeRevert(actions, dryRun, verbose) {
+    let succeeded = 0;
+    let skipped = 0;
+    for (const action of actions) {
+        const label = `${action.skill} -> ${action.agent}`;
+        if (!existsSync(action.target) && !isSymlink(action.target)) {
+            console.log(`  \x1b[33m-\x1b[0m ${label} (not found, skipping)`);
+            skipped++;
+            continue;
+        }
+        if (dryRun) {
+            console.log(`  \x1b[36m○\x1b[0m ${label}`);
+            if (verbose) {
+                console.log(`    would remove: ${action.target}`);
+            }
+            succeeded++;
+            continue;
+        }
+        try {
+            if (isSymlink(action.target)) {
+                unlinkSync(action.target);
+            }
+            else {
+                rmSync(action.target, { recursive: true });
+            }
+            console.log(`  \x1b[32m✓\x1b[0m ${label}`);
+            if (verbose) {
+                console.log(`    removed: ${action.target}`);
+            }
+            succeeded++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`  \x1b[31m✗\x1b[0m ${label}: ${msg}`);
+        }
+    }
+    return { succeeded, skipped };
+}
+function isSymlink(p) {
+    try {
+        return lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class UserError extends Error {
+    constructor(message: string);
+}

package/dist/errors.js

@@ -0,0 +1,6 @@
+export class UserError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "UserError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import path from "node:path";
+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 { detectInstalledAgents } from "./core/detect.js";
+import { planDeploy, executeDeploy } from "./core/deploy.js";
+import { planRevert, executeRevert } from "./core/revert.js";
+import { UserError } from "./errors.js";
+const USAGE = `
+inception-engine - Deploy AI agent skills
+
+Usage:
+  inception-engine <directory> [options]
+  inception-engine revert <directory> [options]
+
+Options:
+  --dry-run        Show what would be done without doing it
+  --agents <list>  Comma-separated list of agent IDs to target
+  --verbose        Show detailed output
+  --debug          Show full error stack traces
+  --help           Show this help message
+
+Supported agents:
+  ${AGENT_REGISTRY.map((a) => `${a.id} (${a.displayName})`).join(", ")}
+`.trim();
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    if (args.length === 0 || args.includes("--help")) {
+        return { command: "help", directory: "", dryRun: false, agents: null, verbose: false, debug: false };
+    }
+    let command = "deploy";
+    let directory = "";
+    let dryRun = false;
+    let agents = null;
+    let verbose = false;
+    let debug = false;
+    let i = 0;
+    if (args[0] === "revert") {
+        command = "revert";
+        i = 1;
+    }
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === "--dry-run") {
+            dryRun = true;
+        }
+        else if (arg === "--verbose") {
+            verbose = true;
+        }
+        else if (arg === "--debug") {
+            debug = true;
+        }
+        else if (arg === "--agents") {
+            i++;
+            const next = args[i];
+            if (!next) {
+                console.error("--agents requires a comma-separated list");
+                process.exit(1);
+            }
+            const ids = next.split(",").map((s) => s.trim());
+            for (const id of ids) {
+                if (!AGENT_IDS.includes(id)) {
+                    console.error(`Unknown agent: "${id}". Valid agents: ${AGENT_IDS.join(", ")}`);
+                    process.exit(1);
+                }
+            }
+            agents = ids;
+        }
+        else if (arg.startsWith("--")) {
+            console.error(`Unknown option: ${arg}`);
+            process.exit(1);
+        }
+        else if (!directory) {
+            directory = arg;
+        }
+        else {
+            console.error(`Unexpected argument: ${arg}`);
+            process.exit(1);
+        }
+        i++;
+    }
+    if (!directory) {
+        console.error("Missing required <directory> argument");
+        process.exit(1);
+    }
+    return { command, directory: path.resolve(directory), dryRun, agents, verbose, debug };
+}
+function main() {
+    const options = parseArgs(process.argv);
+    if (options.command === "help") {
+        console.log(USAGE);
+        process.exit(0);
+    }
+    const manifest = loadManifest(options.directory);
+    const home = resolveHome();
+    let detectedAgents;
+    if (options.agents) {
+        detectedAgents = options.agents;
+        if (options.verbose) {
+            console.log(`Using specified agents: ${detectedAgents.join(", ")}`);
+        }
+    }
+    else {
+        detectedAgents = detectInstalledAgents(home);
+        if (detectedAgents.length === 0) {
+            console.log("No supported AI agents detected on this system.");
+            console.log(`Install one of: ${AGENT_REGISTRY.map((a) => a.displayName).join(", ")}`);
+            process.exit(0);
+        }
+        if (options.verbose) {
+            console.log(`Detected agents: ${detectedAgents.join(", ")}`);
+        }
+    }
+    const prefix = options.dryRun ? "\x1b[36m[dry-run]\x1b[0m " : "";
+    if (options.command === "deploy") {
+        const actions = planDeploy(manifest, options.directory, detectedAgents, home);
+        if (actions.length === 0) {
+            console.log("No skills to deploy for detected agents.");
+            return;
+        }
+        console.log(`${prefix}Deploying ${actions.length} skill(s):`);
+        const { succeeded, failed } = executeDeploy(actions, options.dryRun, options.verbose);
+        console.log();
+        if (failed.length > 0) {
+            console.log(`${succeeded} succeeded, ${failed.length} failed`);
+            process.exit(1);
+        }
+        else {
+            console.log(`${succeeded} skill(s) deployed${options.dryRun ? " (dry-run)" : ""}`);
+        }
+    }
+    else {
+        const actions = planRevert(manifest, detectedAgents, home);
+        if (actions.length === 0) {
+            console.log("No skills to revert for detected agents.");
+            return;
+        }
+        console.log(`${prefix}Reverting ${actions.length} skill(s):`);
+        const { succeeded, skipped } = executeRevert(actions, options.dryRun, options.verbose);
+        console.log();
+        const parts = [`${succeeded} removed`];
+        if (skipped > 0)
+            parts.push(`${skipped} skipped`);
+        console.log(`${parts.join(", ")}${options.dryRun ? " (dry-run)" : ""}`);
+    }
+}
+const debugMode = process.argv.includes("--debug");
+try {
+    main();
+}
+catch (err) {
+    if (err instanceof UserError) {
+        console.error(`Error: ${err.message}`);
+    }
+    else {
+        console.error("Unexpected error. Run with --debug for details.");
+    }
+    if (debugMode) {
+        console.error(err);
+    }
+    process.exit(1);
+}

package/dist/types.d.ts

@@ -0,0 +1,43 @@
+export type AgentId = "claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot";
+export declare const AGENT_IDS: readonly AgentId[];
+export interface SkillEntry {
+    name: string;
+    path: string;
+    agents: AgentId[];
+}
+export interface Manifest {
+    skills: SkillEntry[];
+    mcpServers: unknown[];
+    agentRules: unknown[];
+}
+export interface AgentPaths {
+    posix: string;
+    windows: string;
+}
+export interface AgentConfig {
+    id: AgentId;
+    displayName: string;
+    skills: AgentPaths;
+    detectPaths: AgentPaths;
+    detectBinary: string | null;
+}
+export interface DeployAction {
+    skill: string;
+    agent: AgentId;
+    source: string;
+    target: string;
+    method: "symlink" | "copy";
+}
+export interface RevertAction {
+    skill: string;
+    agent: AgentId;
+    target: string;
+}
+export interface CliOptions {
+    command: "deploy" | "revert" | "help";
+    directory: string;
+    dryRun: boolean;
+    agents: AgentId[] | null;
+    verbose: boolean;
+    debug: boolean;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+export const AGENT_IDS = [
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "antigravity",
+    "opencode",
+    "github-copilot",
+];

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@kuznai/inception-engine",
+  "version": "0.1.0",
+  "description": "Deploy AI agent skills from a git repo to user home directories",
+  "license": "MIT",
+  "author": "Damian Piatkowski",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/KuzniAI/inception-engine.git"
+  },
+  "homepage": "https://github.com/KuzniAI/inception-engine#readme",
+  "bugs": {
+    "url": "https://github.com/KuzniAI/inception-engine/issues"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "agent",
+    "skills",
+    "claude",
+    "copilot",
+    "gemini",
+    "deployment",
+    "npx"
+  ],
+  "type": "module",
+  "bin": {
+    "inception-engine": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=23.6.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "dev": "node src/index.ts",
+    "test": "node --test test/*.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "typescript": "^5.8.0"
+  }
+}