@kuznai/inception-engine 0.6.2 → 0.8.0

package/dist/schemas/manifest.js

@@ -10,6 +10,9 @@ const AGENT_IDS = [
 ];
 export { AGENT_IDS };
 const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+// Target templates must start with a known placeholder to prevent raw absolute
+// paths or directory traversal. e.g. "{home}/.claude/settings.json" is valid.
+const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config)\}/;
 // Standalone schema used for type derivation and single-ID validation (e.g. index.ts).
 export const AgentIdSchema = z.enum(AGENT_IDS);
 // Used inside SkillEntrySchema.agents so that enum failures embed the received
@@ -26,27 +29,62 @@ const agentIdElement = z
     }
 })
     .pipe(AgentIdSchema);
+const nameField = z
+    .string({ message: "name must be a non-empty string" })
+    .min(1, { message: "name must be a non-empty string" })
+    .regex(SAFE_NAME_RE, {
+    message: "name must contain only letters, digits, hyphens, underscores, and dots, and must not start with a dot",
+});
+const agentsField = z
+    .array(agentIdElement, { message: "agents must be a non-empty array" })
+    .min(1, { message: "agents must be a non-empty array" })
+    .transform((arr) => [...new Set(arr)]);
+const sourcePathField = z
+    .string({ message: "path must be a non-empty string" })
+    .min(1, { message: "path must be a non-empty string" })
+    .refine((p) => !nodePath.isAbsolute(p), {
+    message: "path must be a relative path",
+})
+    .refine((p) => !nodePath.normalize(p).startsWith(".."), {
+    message: "path must not escape the repository root",
+});
+const targetTemplateField = z
+    .string({ message: "target must be a non-empty string" })
+    .min(1, { message: "target must be a non-empty string" })
+    .refine((t) => TARGET_TEMPLATE_RE.test(t), {
+    message: "target must start with a known placeholder: {home}, {appdata}, or {xdg_config}",
+});
 export const SkillEntrySchema = z.object({
-    name: z
-        .string({ message: "name must be a non-empty string" })
-        .min(1, { message: "name must be a non-empty string" })
-        .regex(SAFE_NAME_RE, {
-        message: "name must contain only letters, digits, hyphens, underscores, and dots, and must not start with a dot",
-    }),
-    path: z
-        .string({ message: "path must be a non-empty string" })
-        .min(1, { message: "path must be a non-empty string" })
-        .refine((p) => !nodePath.isAbsolute(p), {
-        message: "path must be a relative path",
-    })
-        .refine((p) => !nodePath.normalize(p).startsWith(".."), {
-        message: "path must not escape the repository root",
-    }),
-    agents: z
-        .array(agentIdElement, { message: "agents must be a non-empty array" })
-        .min(1, { message: "agents must be a non-empty array" })
-        .transform((arr) => [...new Set(arr)]),
+    name: nameField,
+    path: sourcePathField,
+    agents: agentsField,
 });
+export const FileEntrySchema = z.object({
+    name: nameField,
+    path: sourcePathField,
+    target: targetTemplateField,
+    agents: agentsField,
+});
+export const ConfigEntrySchema = z.object({
+    name: nameField,
+    target: targetTemplateField,
+    patch: z.record(z.string(), z.unknown()),
+    agents: agentsField,
+});
+export const McpServerEntrySchema = z
+    .object({
+    name: z
+        .string({ message: "mcpServers entry name must be a non-empty string" })
+        .min(1, { message: "mcpServers entry name must be a non-empty string" }),
+})
+    .passthrough();
+export const AgentRuleEntrySchema = z
+    .object({
+    name: z
+        .string({ message: "agentRules entry name must be a non-empty string" })
+        .min(1, { message: "agentRules entry name must be a non-empty string" }),
+})
+    .passthrough();
 export const ManifestSchema = z.object({
     skills: z.array(SkillEntrySchema).superRefine((skills, ctx) => {
         const seen = new Set();
@@ -61,8 +99,10 @@ export const ManifestSchema = z.object({
             seen.add(skill.name);
         }
     }),
-    mcpServers: z.array(z.unknown()).default([]),
-    agentRules: z.array(z.unknown()).default([]),
+    files: z.array(FileEntrySchema).default([]),
+    configs: z.array(ConfigEntrySchema).default([]),
+    mcpServers: z.array(McpServerEntrySchema).default([]),
+    agentRules: z.array(AgentRuleEntrySchema).default([]),
 });
 // Parses the --agents CLI flag: comma-separated agent IDs → AgentId[]
 export const AgentListSchema = z

package/dist/schemas/registry.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
-export declare const RegistryEntrySchema: z.ZodObject<{
+declare const SkillDirRegistryEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"skill-dir">;
     source: z.ZodString;
     skill: z.ZodString;
     agent: z.ZodEnum<{
@@ -10,15 +11,90 @@ export declare const RegistryEntrySchema: z.ZodObject<{
         opencode: "opencode";
         "github-copilot": "github-copilot";
     }>;
-    method: z.ZodEnum<{
+    method: z.ZodOptional<z.ZodEnum<{
         symlink: "symlink";
         copy: "copy";
+    }>>;
+    deployed: z.ZodString;
+}, z.core.$strip>;
+declare const FileWriteRegistryEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"file-write">;
+    source: z.ZodString;
+    skill: z.ZodString;
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
+    }>;
+    deployed: z.ZodString;
+}, z.core.$strip>;
+declare const ConfigPatchRegistryEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"config-patch">;
+    patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    skill: z.ZodString;
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
     }>;
     deployed: z.ZodString;
 }, z.core.$strip>;
+export declare const RegistryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"skill-dir">;
+    source: z.ZodString;
+    skill: z.ZodString;
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
+    }>;
+    method: z.ZodOptional<z.ZodEnum<{
+        symlink: "symlink";
+        copy: "copy";
+    }>>;
+    deployed: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"file-write">;
+    source: z.ZodString;
+    skill: z.ZodString;
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
+    }>;
+    deployed: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"config-patch">;
+    patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    skill: z.ZodString;
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
+    }>;
+    deployed: z.ZodString;
+}, z.core.$strip>], "kind">;
 export declare const RegistrySchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
-    deployments: z.ZodRecord<z.ZodString, z.ZodObject<{
+    deployments: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"skill-dir">;
         source: z.ZodString;
         skill: z.ZodString;
         agent: z.ZodEnum<{
@@ -29,12 +105,43 @@ export declare const RegistrySchema: z.ZodObject<{
             opencode: "opencode";
             "github-copilot": "github-copilot";
         }>;
-        method: z.ZodEnum<{
+        method: z.ZodOptional<z.ZodEnum<{
             symlink: "symlink";
             copy: "copy";
+        }>>;
+        deployed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file-write">;
+        source: z.ZodString;
+        skill: z.ZodString;
+        agent: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            "gemini-cli": "gemini-cli";
+            antigravity: "antigravity";
+            opencode: "opencode";
+            "github-copilot": "github-copilot";
+        }>;
+        deployed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"config-patch">;
+        patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        skill: z.ZodString;
+        agent: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            "gemini-cli": "gemini-cli";
+            antigravity: "antigravity";
+            opencode: "opencode";
+            "github-copilot": "github-copilot";
         }>;
         deployed: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>], "kind">>;
 }, z.core.$strip>;
+export type SkillDirRegistryEntry = z.infer<typeof SkillDirRegistryEntrySchema>;
+export type FileWriteRegistryEntry = z.infer<typeof FileWriteRegistryEntrySchema>;
+export type ConfigPatchRegistryEntry = z.infer<typeof ConfigPatchRegistryEntrySchema>;
 export type RegistryEntry = z.infer<typeof RegistryEntrySchema>;
 export type Registry = z.infer<typeof RegistrySchema>;
+export {};

package/dist/schemas/registry.js

@@ -1,12 +1,33 @@
 import { z } from "zod";
 import { AgentIdSchema } from "./manifest.js";
-export const RegistryEntrySchema = z.object({
+const SkillDirRegistryEntrySchema = z.object({
+    kind: z.literal("skill-dir"),
     source: z.string(),
     skill: z.string(),
     agent: AgentIdSchema,
-    method: z.enum(["symlink", "copy"]),
+    method: z.enum(["symlink", "copy"]).optional(),
     deployed: z.string(),
 });
+const FileWriteRegistryEntrySchema = z.object({
+    kind: z.literal("file-write"),
+    source: z.string(),
+    skill: z.string(),
+    agent: AgentIdSchema,
+    deployed: z.string(),
+});
+const ConfigPatchRegistryEntrySchema = z.object({
+    kind: z.literal("config-patch"),
+    patch: z.record(z.string(), z.unknown()),
+    undoPatch: z.record(z.string(), z.unknown()),
+    skill: z.string(),
+    agent: AgentIdSchema,
+    deployed: z.string(),
+});
+export const RegistryEntrySchema = z.discriminatedUnion("kind", [
+    SkillDirRegistryEntrySchema,
+    FileWriteRegistryEntrySchema,
+    ConfigPatchRegistryEntrySchema,
+]);
 export const RegistrySchema = z.object({
     version: z.literal(1),
     deployments: z.record(z.string(), RegistryEntrySchema),

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { AgentId } from "./schemas/manifest.ts";
-export type { AgentId, Manifest, SkillEntry } from "./schemas/manifest.ts";
+export type { AgentId, ConfigEntry, FileEntry, Manifest, SkillEntry, } from "./schemas/manifest.ts";
 export interface AgentPaths {
     posix: string[];
     windows: string[];
@@ -17,6 +17,11 @@ export interface AgentConfig {
     detectPaths: AgentPaths;
     detectBinary: string | null;
     provenance: AgentProvenance;
+    policyNote?: string;
+}
+export interface PlanWarning {
+    kind: "confidence" | "collision" | "ambiguity";
+    message: string;
 }
 export interface SkillDirDeployAction {
     kind: "skill-dir";
@@ -25,15 +30,56 @@ export interface SkillDirDeployAction {
     source: string;
     target: string;
     method: "symlink" | "copy";
+    confidence: Confidence;
+}
+export interface FileWriteDeployAction {
+    kind: "file-write";
+    skill: string;
+    agent: AgentId;
+    source: string;
+    target: string;
+    confidence?: Confidence;
 }
-export type DeployAction = SkillDirDeployAction;
+export interface ConfigPatchDeployAction {
+    kind: "config-patch";
+    skill: string;
+    agent: AgentId;
+    target: string;
+    patch: unknown;
+    confidence?: Confidence;
+}
+export type DeployAction = SkillDirDeployAction | FileWriteDeployAction | ConfigPatchDeployAction;
 export interface SkillDirRevertAction {
     kind: "skill-dir";
     skill: string;
     agent: AgentId;
     target: string;
 }
-export type RevertAction = SkillDirRevertAction;
+export interface FileWriteRevertAction {
+    kind: "file-write";
+    skill: string;
+    agent: AgentId;
+    target: string;
+}
+export interface ConfigPatchRevertAction {
+    kind: "config-patch";
+    skill: string;
+    agent: AgentId;
+    target: string;
+}
+export type RevertAction = SkillDirRevertAction | FileWriteRevertAction | ConfigPatchRevertAction;
+export type PlannedChangeVerb = "create-symlink" | "copy-dir" | "write-file" | "patch-config" | "remove" | "unapply-patch";
+export interface PlannedChange {
+    verb: PlannedChangeVerb;
+    kind: "skill-dir" | "file-write" | "config-patch";
+    skill: string;
+    agent: AgentId;
+    source?: string;
+    target: string;
+    method?: "symlink" | "copy";
+    patch?: Record<string, unknown>;
+    confidence?: Confidence;
+}
 export interface CliOptions {
     command: "deploy" | "revert" | "help";
     directory: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuznai/inception-engine",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "Deploy AI agent skills from a git repo to user home directories",
   "license": "MIT",
   "author": "Damian Piątkowski",
@@ -31,14 +31,16 @@
     "dist"
   ],
   "engines": {
-    "node": ">=23.6.0"
+    "node": ">=22.3.0"
   },
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "fmt": "biome format --write .",
     "lint": "biome lint . --max-diagnostics none",
+    "predev": "node scripts/assert-direct-ts-node.mjs",
     "dev": "node src/index.ts",
+    "pretest": "node scripts/assert-direct-ts-node.mjs",
     "test": "node --test test/*.test.ts",
     "prepublishOnly": "npm run typecheck && npm run lint && npm run build"
   },