@kuznai/inception-engine 0.13.0 → 0.14.0

package/dist/core/deploy.js

@@ -9,7 +9,7 @@ import { compileAdapterActions } from "./adapters/index.js";
 import { applyTomlMcpPatch } from "./adapters/toml.js";
 import { lookupDeployment, registerDeployment, verifyDeployment, } from "./ownership.js";
 import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
-import { resolveTargetTemplate } from "./runtime-paths.js";
+import { getPathApi, resolveTargetTemplate } from "./runtime-paths.js";
 import { sourceAccessError, validateSkillDefinitionFile, validateSourceFile, validateSourcePath, } from "./validation.js";
 function isPlainObject(v) {
     return typeof v === "object" && v !== null && !Array.isArray(v);
@@ -87,9 +87,19 @@ function detectAmbiguities(detectedAgents, actions, home) {
     const hasGeminiCli = detectedAgents.includes("gemini-cli");
     const hasAntigravity = detectedAgents.includes("antigravity");
     if (hasGeminiCli && hasAntigravity) {
-        const sharedGeminiMd = path.resolve(home, ".gemini", "GEMINI.md");
-        const sharedSettings = path.resolve(home, ".gemini", "settings.json");
-        const targetsShared = actions.some((a) => a.target === sharedGeminiMd || a.target === sharedSettings);
+        const homePathApi = getPathApi(home);
+        const sharedGeminiMd = homePathApi.join(home, ".gemini", "GEMINI.md");
+        const sharedSettings = homePathApi.join(home, ".gemini", "settings.json");
+        // Normalize paths for comparison to handle case-insensitivity on Windows
+        const normalize = (pathStr) => homePathApi === path.win32
+            ? pathStr.toLowerCase()
+            : pathStr;
+        const normalizedGeminiMd = normalize(sharedGeminiMd);
+        const normalizedSettings = normalize(sharedSettings);
+        const targetsShared = actions.some((a) => {
+            const normalizedTarget = normalize(a.target);
+            return normalizedTarget === normalizedGeminiMd || normalizedTarget === normalizedSettings;
+        });
         if (targetsShared) {
             warnings.push({
                 kind: "ambiguity",

package/dist/core/init.js

@@ -3,6 +3,29 @@ import path from "node:path";
 import { dryRunPrefix, logger } from "../logger.js";
 import { AGENT_IDS } from "../schemas/manifest.js";
 const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+// Ordered list: first match wins. Catch-all is applied at call site.
+const AGENT_RULES_FILE_PATTERNS = [
+    {
+        fileNames: ["claude.md", "claude-instructions.md"],
+        agents: ["claude-code"],
+    },
+    {
+        fileNames: ["agents.md", "agents-instructions.md"],
+        agents: ["codex", "opencode"],
+    },
+    {
+        fileNames: ["gemini.md", "gemini-instructions.md"],
+        agents: ["gemini-cli", "antigravity"],
+    },
+    { fileNames: ["copilot-instructions.md"], agents: ["github-copilot"] },
+];
+// Conventional subdirectory names to scan one level deep for .md files.
+const AGENT_RULES_SUBDIRS = [
+    "rules",
+    "instructions",
+    ".github",
+    ".agents/rules",
+];
 async function findSkillDirs(baseDir, dir, found) {
     let entries;
     try {
@@ -52,6 +75,91 @@ function buildSkills(found, agents) {
     }
     return skills;
 }
+function defaultAgentsForFile(fileName, fallback) {
+    const lower = fileName.toLowerCase();
+    for (const { fileNames, agents } of AGENT_RULES_FILE_PATTERNS) {
+        if (fileNames.includes(lower))
+            return agents;
+    }
+    return fallback;
+}
+function isInsideSkillDir(relPath, skillDirRelPaths) {
+    const parentRelPath = path.dirname(relPath).split(path.sep).join("/");
+    if (skillDirRelPaths.has(parentRelPath))
+        return true;
+    return [...skillDirRelPaths].some((sp) => parentRelPath === sp || parentRelPath.startsWith(`${sp}/`));
+}
+function deriveAgentRulesName(relPath, fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    const baseName = path.basename(fileName, ext);
+    const rawName = baseName.toLowerCase().replace(/[^a-zA-Z0-9._-]/g, "-");
+    if (!SAFE_NAME_RE.test(rawName)) {
+        logger.warn("init", `Skipping "${relPath}": could not derive a valid agentRules name`);
+        return null;
+    }
+    return rawName;
+}
+async function scanDirForMarkdown(dir, baseDir, skillDirRelPaths, seen, candidates) {
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true, encoding: "utf-8" });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const ext = path.extname(entry.name).toLowerCase();
+        if (ext !== ".md" && ext !== ".markdown")
+            continue;
+        const absPath = path.join(dir, entry.name);
+        const relPath = path.relative(baseDir, absPath).split(path.sep).join("/");
+        if (seen.has(relPath) || isInsideSkillDir(relPath, skillDirRelPaths))
+            continue;
+        const name = deriveAgentRulesName(relPath, entry.name);
+        if (name === null)
+            continue;
+        seen.add(relPath);
+        candidates.push({ relPath, name, defaultAgents: [] });
+    }
+}
+async function findAgentRulesCandidates(baseDir, skillDirRelPaths) {
+    const candidates = [];
+    const seen = new Set();
+    await scanDirForMarkdown(baseDir, baseDir, skillDirRelPaths, seen, candidates);
+    for (const subdir of AGENT_RULES_SUBDIRS) {
+        await scanDirForMarkdown(path.join(baseDir, subdir), baseDir, skillDirRelPaths, seen, candidates);
+    }
+    return candidates;
+}
+function buildAgentRules(candidates, activeAgents, skillNamesSeen) {
+    const rules = [];
+    const namesSeen = new Set(skillNamesSeen);
+    for (const { relPath, name: rawName } of candidates) {
+        const fileName = path.basename(relPath);
+        const defaultAgents = defaultAgentsForFile(fileName, activeAgents);
+        // Intersect with active agents; fall back to full active list if empty
+        const intersection = defaultAgents.filter((a) => activeAgents.includes(a));
+        const agents = intersection.length > 0 ? intersection : activeAgents;
+        // Resolve name collision with skill names
+        let name = rawName;
+        if (namesSeen.has(name)) {
+            const candidate = `${name}-rules`;
+            if (SAFE_NAME_RE.test(candidate)) {
+                logger.warn("init", `agentRules name "${name}" collides with a skill name; using "${candidate}"`);
+                name = candidate;
+            }
+            else {
+                logger.warn("init", `Skipping "${relPath}": name "${name}" collides with a skill name and fallback is invalid`);
+                continue;
+            }
+        }
+        namesSeen.add(name);
+        rules.push({ name, path: relPath, agents });
+    }
+    return rules;
+}
 async function manifestExists(manifestPath) {
     try {
         await access(manifestPath);
@@ -73,27 +181,38 @@ export async function runInit(options) {
     await findSkillDirs(directory, directory, found);
     if (found.length === 0) {
         logger.info("No skill directories found (looking for directories containing SKILL.md).");
-        return 0;
     }
     const skills = buildSkills(found, agents);
-    if (skills.length === 0) {
-        logger.info("No skills could be added to the manifest.");
-        return 0;
-    }
-    const manifest = { skills, mcpServers: [], agentRules: [] };
+    const skillNamesSeen = new Set(skills.map((s) => s.name));
+    const skillDirRelPaths = new Set(found.map((f) => f.relPath));
+    const agentRulesCandidates = await findAgentRulesCandidates(directory, skillDirRelPaths);
+    const agentRules = buildAgentRules(agentRulesCandidates, agents, skillNamesSeen);
+    const manifest = {
+        skills,
+        files: [],
+        configs: [],
+        mcpServers: [],
+        agentRules,
+    };
     const json = `${JSON.stringify(manifest, null, 2)}\n`;
     if (dryRun) {
-        logger.info(`${dryRunPrefix(true)}Would write ${manifestPath} with ${skills.length} skill(s):`);
+        logger.info(`${dryRunPrefix(true)}Would write ${manifestPath} with ${skills.length} skill(s) and ${agentRules.length} agentRule(s):`);
         logger.info("");
         logger.info(json);
         return 0;
     }
     await writeFile(manifestPath, json, "utf-8");
-    logger.info(`Generated ${manifestPath} with ${skills.length} skill(s).`);
+    logger.info(`Generated ${manifestPath} with ${skills.length} skill(s) and ${agentRules.length} agentRule(s).`);
     if (verbose) {
         for (const s of skills) {
             logger.detail(`${s.name}  →  ${s.path}`);
         }
+        if (agentRules.length > 0) {
+            logger.detail("agentRules:");
+            for (const r of agentRules) {
+                logger.detail(`  ${r.name}  →  ${r.path}  [${r.agents.join(", ")}]`);
+            }
+        }
     }
     return 0;
 }

package/package.json

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