skiller 0.7.19 → 0.7.21

package/dist/agents/AiderAgent.js

@@ -96,7 +96,8 @@ class AiderAgent {
         };
     }
     getMcpServerKey() {
-        return this.agentsMdAgent.getMcpServerKey();
+        // Aider uses the standard `.mcp.json` schema key.
+        return 'mcpServers';
     }
     supportsMcpStdio() {
         return true;

package/dist/core/ClaudePluginSync.js

@@ -126,36 +126,11 @@ function parsePluginId(pluginId) {
         marketplaceId: pluginId.slice(at + 1),
     };
 }
-async function readKnownMarketplaceInstallLocations(claudeDir) {
-    const knownPath = path.join(claudeDir, 'plugins', 'known_marketplaces.json');
-    let raw;
-    try {
-        raw = JSON.parse(await fs.readFile(knownPath, 'utf8'));
-    }
-    catch {
-        return {};
-    }
-    if (!raw || typeof raw !== 'object')
-        return {};
-    const obj = raw;
-    const out = {};
-    for (const [marketplaceId, marketplace] of Object.entries(obj)) {
-        if (!marketplace || typeof marketplace !== 'object')
-            continue;
-        const installLocation = marketplace
-            .installLocation;
-        if (typeof installLocation !== 'string' || installLocation.trim() === '')
-            continue;
-        out[marketplaceId] = installLocation;
-    }
-    return out;
-}
-async function resolvePluginMarketplaceRoot(pluginId, claudeDir, knownMarketplaceInstallLocations) {
+async function resolvePluginMarketplaceRoot(pluginId, claudeDir) {
     const parsed = parsePluginId(pluginId);
     if (!parsed)
         return null;
-    const marketplaceRoot = knownMarketplaceInstallLocations[parsed.marketplaceId] ??
-        path.join(claudeDir, 'plugins', 'marketplaces', parsed.marketplaceId);
+    const marketplaceRoot = path.join(claudeDir, 'plugins', 'marketplaces', parsed.marketplaceId);
     const candidates = [
         path.join(marketplaceRoot, 'plugins', parsed.pluginName),
         path.join(marketplaceRoot, 'external_plugins', parsed.pluginName),
@@ -266,19 +241,31 @@ async function discoverPluginCommandFiles(installPath) {
     const commandsRoot = path.join(installPath, 'commands');
     if (!(await fileExists(commandsRoot)))
         return [];
-    let entries;
-    try {
-        entries = await fs.readdir(commandsRoot, { withFileTypes: true });
-    }
-    catch {
-        return [];
+    const results = [];
+    async function walk(current, depth) {
+        if (depth >= constants_1.MAX_RECURSION_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full, depth + 1);
+                continue;
+            }
+            if (!entry.isFile() || !entry.name.endsWith('.md'))
+                continue;
+            const rel = path.relative(commandsRoot, full).replace(/\\/g, '/');
+            results.push({ rel, file: full });
+        }
     }
-    return entries
-        .filter((e) => e.isFile() && e.name.endsWith('.md'))
-        .map((e) => ({
-        name: path.basename(e.name, '.md'),
-        file: path.join(commandsRoot, e.name),
-    }));
+    await walk(commandsRoot, 0);
+    return results;
 }
 async function discoverPluginAgentFiles(installPath) {
     const agentsRoot = path.join(installPath, 'agents');
@@ -328,8 +315,13 @@ function generateBaseNameFromRelId(relId) {
     const segments = normalized.split('/').filter(Boolean);
     return segments.map(sanitizeId).join('-');
 }
-function generateBaseNameFromCommand(commandName) {
-    return sanitizeId(commandName);
+function generateBaseNameFromCommandRelPath(commandRelPath) {
+    const normalized = commandRelPath.replace(/\\/g, '/');
+    const withoutExt = normalized.endsWith('.md')
+        ? normalized.slice(0, -'.md'.length)
+        : normalized;
+    const segments = withoutExt.split('/').filter(Boolean);
+    return segments.map(sanitizeId).join('-');
 }
 function pluginBaseNamespacePrefix(pluginId) {
     const parsed = parsePluginId(pluginId);
@@ -338,19 +330,25 @@ function pluginBaseNamespacePrefix(pluginId) {
     return sanitizeId(pluginId);
 }
 function computePluginNamespacePrefixes(pluginIds) {
-    const basePrefixByPluginId = new Map();
-    const counts = new Map();
-    for (const pluginId of pluginIds) {
-        const base = pluginBaseNamespacePrefix(pluginId);
-        basePrefixByPluginId.set(pluginId, base);
-        counts.set(base, (counts.get(base) ?? 0) + 1);
-    }
     const out = new Map();
+    const pluginIdsByBase = new Map();
     for (const pluginId of pluginIds) {
-        const base = basePrefixByPluginId.get(pluginId) ?? sanitizeId(pluginId);
-        // If multiple enabled plugins share the same pluginName, fall back to the
-        // full pluginId for uniqueness (includes marketplace).
-        out.set(pluginId, (counts.get(base) ?? 0) > 1 ? sanitizeId(pluginId) : base);
+        const base = pluginBaseNamespacePrefix(pluginId);
+        const bucket = pluginIdsByBase.get(base) ?? [];
+        bucket.push(pluginId);
+        pluginIdsByBase.set(base, bucket);
+    }
+    for (const [base, ids] of pluginIdsByBase.entries()) {
+        ids.sort((a, b) => a.localeCompare(b));
+        if (ids.length === 1) {
+            out.set(ids[0], base);
+            continue;
+        }
+        // If multiple enabled plugins share the same plugin name, disambiguate
+        // without including the marketplace in the folder name.
+        ids.forEach((id, idx) => {
+            out.set(id, idx === 0 ? base : `${base}-${idx + 1}`);
+        });
     }
     return out;
 }
@@ -395,8 +393,8 @@ async function removeLegacyMarkerFile(dir, dryRun) {
         // ignore
     }
 }
-async function loadManagedEntries(targetSkillsDir, dryRun) {
-    const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir);
+async function loadManagedEntries(projectRoot, targetSkillsDir, dryRun) {
+    const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir);
     const pluginEntries = [];
     const otherEntries = [];
     for (const entry of allEntries) {
@@ -501,7 +499,12 @@ async function discoverLocalCommandNames(projectRoot) {
             }
             if (!entry.isFile() || !entry.name.endsWith('.md'))
                 continue;
-            names.add(sanitizeId(path.basename(entry.name, '.md')));
+            const rel = path.relative(localCommandsDir, full).replace(/\\/g, '/');
+            const withoutExt = rel.endsWith('.md')
+                ? rel.slice(0, -'.md'.length)
+                : rel;
+            const segments = withoutExt.split('/').filter(Boolean);
+            names.add(segments.map(sanitizeId).join('-'));
         }
     }
     await walk(localCommandsDir, 0);
@@ -608,7 +611,6 @@ async function syncClaudePluginsToSkillsDirs(args) {
     }
     const claudeDir = path.join(getUserHomeDir(), '.claude');
     const index = await readInstalledPluginsIndex(claudeDir);
-    const knownMarketplaceInstallLocations = await readKnownMarketplaceInstallLocations(claudeDir);
     const localSkillNames = await discoverLocalSkillNames(projectRoot);
     const localCommandNames = await discoverLocalCommandNames(projectRoot);
     const localAgentNames = await discoverLocalAgentNames(projectRoot);
@@ -620,10 +622,16 @@ async function syncClaudePluginsToSkillsDirs(args) {
     const resolvedSources = [];
     const unresolvedEnabled = new Set();
     for (const pluginId of enabledPlugins) {
-        const pluginRoot = await resolvePluginMarketplaceRoot(pluginId, claudeDir, knownMarketplaceInstallLocations);
+        const pluginRoot = await resolvePluginMarketplaceRoot(pluginId, claudeDir);
         if (!pluginRoot) {
             unresolvedEnabled.add(pluginId);
-            (0, constants_1.logWarn)(`[plugins] Enabled plugin not installed: ${pluginId}`, dryRun);
+            const hasIndexEntry = Boolean(index?.plugins?.[pluginId]?.length);
+            if (hasIndexEntry) {
+                (0, constants_1.logVerboseInfo)(`[plugins] Enabled plugin has no marketplace content, skipping: ${pluginId}`, verbose, dryRun);
+            }
+            else {
+                (0, constants_1.logWarn)(`[plugins] Enabled plugin not installed: ${pluginId}`, dryRun);
+            }
             continue;
         }
         const resolved = index
@@ -653,8 +661,8 @@ async function syncClaudePluginsToSkillsDirs(args) {
         }
         const commandFiles = await discoverPluginCommandFiles(plugin.pluginRoot);
         for (const c of commandFiles) {
-            const baseName = generateBaseNameFromCommand(c.name);
-            const sourceRelPath = `commands/${path.basename(c.file)}`;
+            const baseName = generateBaseNameFromCommandRelPath(c.rel);
+            const sourceRelPath = `commands/${c.rel}`;
             expectedItems.push({
                 itemKey: makeItemKey(plugin.pluginId, 'command', sourceRelPath),
                 pluginId: plugin.pluginId,
@@ -696,7 +704,7 @@ async function syncClaudePluginsToSkillsDirs(args) {
         let managedEntries = [];
         let otherEntries = [];
         if (targetExists) {
-            const loaded = await loadManagedEntries(targetSkillsDir, dryRun);
+            const loaded = await loadManagedEntries(projectRoot, targetSkillsDir, dryRun);
             managedEntries = loaded.pluginEntries;
             otherEntries = loaded.otherEntries;
         }
@@ -859,6 +867,6 @@ async function syncClaudePluginsToSkillsDirs(args) {
                 destRelPath: item.destRelPath,
             });
         }
-        await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(projectRoot, targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
     }
 }

package/dist/core/ClaudeProjectSync.js

@@ -85,7 +85,14 @@ async function discoverCommandFiles(projectRoot) {
             }
             if (!entry.isFile() || !entry.name.endsWith('.md'))
                 continue;
-            const name = sanitizeId(path.basename(entry.name, '.md'));
+            const relFromCommands = path
+                .relative(commandsRoot, full)
+                .replace(/\\/g, '/');
+            const withoutExt = relFromCommands.endsWith('.md')
+                ? relFromCommands.slice(0, -'.md'.length)
+                : relFromCommands;
+            const segments = withoutExt.split('/').filter(Boolean);
+            const name = segments.map(sanitizeId).join('-');
             const rel = path.relative(projectRoot, full).replace(/\\/g, '/');
             results.push({ name, file: full, rel });
         }
@@ -164,9 +171,9 @@ async function writeMarkdownAsSkill(srcPath, destDir, generatedName, kindLabel,
         return;
     await fs.writeFile(path.join(destDir, 'SKILL.md'), next, 'utf8');
 }
-async function readPluginManagedDestNames(targetSkillsDir) {
+async function readPluginManagedDestNames(projectRoot, targetSkillsDir) {
     const names = new Set();
-    for (const entry of await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir)) {
+    for (const entry of await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir)) {
         if ((0, SkillsManifest_1.isPluginManifestEntry)(entry)) {
             names.add(entry.destRelPath);
         }
@@ -262,7 +269,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
         const managedEntries = [];
         const otherEntries = [];
         if (targetExists) {
-            const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(targetSkillsDir);
+            const allEntries = await (0, SkillsManifest_1.loadSkillsManifestEntries)(projectRoot, targetSkillsDir);
             for (const entry of allEntries) {
                 if ((0, SkillsManifest_1.isClaudeManifestEntry)(entry)) {
                     managedEntries.push(entry);
@@ -278,7 +285,7 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
         }
         const managedDest = new Set(managedEntries.map((e) => e.destRelPath));
         const pluginManagedDest = targetExists
-            ? await readPluginManagedDestNames(targetSkillsDir)
+            ? await readPluginManagedDestNames(projectRoot, targetSkillsDir)
             : new Set();
         const reserved = new Set(localSkillNames);
         if (targetExists) {
@@ -395,6 +402,6 @@ async function syncClaudeProjectCommandsAndAgentsToSkillsDirs(args) {
                 destRelPath: item.destRelPath,
             });
         }
-        await (0, SkillsManifest_1.writeSkillsManifestEntries)(targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
+        await (0, SkillsManifest_1.writeSkillsManifestEntries)(projectRoot, targetSkillsDir, [...otherEntries, ...nextEntries], dryRun);
     }
 }

package/dist/core/SkillsManifest.js

@@ -41,6 +41,8 @@ exports.writeSkillsManifestEntries = writeSkillsManifestEntries;
 exports.listSkillDirectories = listSkillDirectories;
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
+// Project-level manifest (stored in `.claude/.skiller.json`) that tracks what
+// Skiller installed into each target agent skills directory for this project.
 exports.SKILLS_MANIFEST_FILENAME = '.skiller.json';
 exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME = '.skiller-skills.json';
 exports.LEGACY_PLUGIN_MANIFEST_FILENAME = '.skiller-plugins.json';
@@ -137,6 +139,37 @@ function parseUnifiedEntries(raw) {
     }
     return entries;
 }
+function normalizePathForKey(p) {
+    return path.resolve(p).replace(/\\/g, '/');
+}
+function computeTargetKey(projectRoot, targetSkillsDir) {
+    const resolvedProjectRoot = path.resolve(projectRoot);
+    const resolvedTarget = path.resolve(targetSkillsDir);
+    if (resolvedTarget === resolvedProjectRoot)
+        return '.';
+    if (resolvedTarget.startsWith(resolvedProjectRoot + path.sep)) {
+        return path
+            .relative(resolvedProjectRoot, resolvedTarget)
+            .replace(/\\/g, '/');
+    }
+    return normalizePathForKey(resolvedTarget);
+}
+function parseProjectTargets(raw) {
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const obj = raw;
+    if (!obj.targets || typeof obj.targets !== 'object')
+        return {};
+    const targetsObj = obj.targets;
+    const out = {};
+    for (const [targetKey, rawEntries] of Object.entries(targetsObj)) {
+        // Stored as an array of entries per target.
+        if (!Array.isArray(rawEntries))
+            continue;
+        out[targetKey] = normalizeEntries(parseUnifiedEntries({ entries: rawEntries }));
+    }
+    return out;
+}
 function parseLegacyPluginEntries(raw) {
     if (!raw || typeof raw !== 'object')
         return [];
@@ -197,11 +230,11 @@ function parseLegacyClaudeEntries(raw) {
     }
     return entries;
 }
-async function loadSkillsManifestEntries(targetSkillsDir) {
-    const manifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
-    if (await fileExists(manifestPath)) {
+async function loadLegacyTargetSkillsManifestEntries(targetSkillsDir) {
+    const legacyManifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
+    if (await fileExists(legacyManifestPath)) {
         try {
-            const raw = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+            const raw = JSON.parse(await fs.readFile(legacyManifestPath, 'utf8'));
             return normalizeEntries(parseUnifiedEntries(raw));
         }
         catch {
@@ -243,32 +276,78 @@ async function loadSkillsManifestEntries(targetSkillsDir) {
     }
     return normalizeEntries(merged);
 }
-async function writeSkillsManifestEntries(targetSkillsDir, entries, dryRun) {
-    const manifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
-    const legacyUnifiedPath = path.join(targetSkillsDir, exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME);
-    const legacyPluginPath = path.join(targetSkillsDir, exports.LEGACY_PLUGIN_MANIFEST_FILENAME);
-    const legacyClaudePath = path.join(targetSkillsDir, exports.LEGACY_CLAUDE_MANIFEST_FILENAME);
+async function loadSkillsManifestEntries(projectRoot, targetSkillsDir) {
+    const projectClaudeDir = path.join(projectRoot, '.claude');
+    const projectManifestPath = path.join(projectClaudeDir, exports.SKILLS_MANIFEST_FILENAME);
+    const preferredTargetKey = computeTargetKey(projectRoot, targetSkillsDir);
+    const absoluteTargetKey = normalizePathForKey(targetSkillsDir);
+    if (await fileExists(projectManifestPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(projectManifestPath, 'utf8'));
+            const targets = parseProjectTargets(raw);
+            const entries = targets[preferredTargetKey] ?? targets[absoluteTargetKey] ?? [];
+            return normalizeEntries(entries);
+        }
+        catch {
+            return [];
+        }
+    }
+    // Legacy migration: prior versions stored manifests in the target skills dir.
+    return await loadLegacyTargetSkillsManifestEntries(targetSkillsDir);
+}
+async function writeSkillsManifestEntries(projectRoot, targetSkillsDir, entries, dryRun) {
     const normalized = normalizeEntries(entries);
+    const projectClaudeDir = path.join(projectRoot, '.claude');
+    const projectManifestPath = path.join(projectClaudeDir, exports.SKILLS_MANIFEST_FILENAME);
+    const preferredTargetKey = computeTargetKey(projectRoot, targetSkillsDir);
+    const absoluteTargetKey = normalizePathForKey(targetSkillsDir);
+    let existingTargets = {};
+    if (await fileExists(projectManifestPath)) {
+        try {
+            const raw = JSON.parse(await fs.readFile(projectManifestPath, 'utf8'));
+            existingTargets = parseProjectTargets(raw);
+        }
+        catch {
+            existingTargets = {};
+        }
+    }
     if (normalized.length === 0) {
-        if (dryRun)
-            return;
-        await Promise.allSettled([
-            fs.unlink(manifestPath),
-            fs.unlink(legacyUnifiedPath),
-            fs.unlink(legacyPluginPath),
-            fs.unlink(legacyClaudePath),
-        ]);
-        return;
+        delete existingTargets[preferredTargetKey];
+        if (preferredTargetKey !== absoluteTargetKey) {
+            delete existingTargets[absoluteTargetKey];
+        }
+    }
+    else {
+        existingTargets[preferredTargetKey] = normalized;
+        if (preferredTargetKey !== absoluteTargetKey) {
+            delete existingTargets[absoluteTargetKey];
+        }
     }
-    const manifest = {
-        version: exports.SKILLS_MANIFEST_VERSION,
-        entries: normalized,
-    };
     if (dryRun)
         return;
-    await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
-    // Clean up legacy manifests once unified is written.
+    // Ensure `.claude` exists since the manifest lives there.
+    await fs.mkdir(projectClaudeDir, { recursive: true });
+    const targetKeys = Object.keys(existingTargets).sort((a, b) => a.localeCompare(b));
+    if (targetKeys.length === 0) {
+        await Promise.allSettled([fs.unlink(projectManifestPath)]);
+    }
+    else {
+        const nextTargets = {};
+        for (const key of targetKeys)
+            nextTargets[key] = existingTargets[key];
+        const manifest = {
+            version: exports.SKILLS_MANIFEST_VERSION,
+            targets: nextTargets,
+        };
+        await fs.writeFile(projectManifestPath, JSON.stringify(manifest, null, 2) + '\n');
+    }
+    // Remove legacy per-target manifests so users see a single `.claude/.skiller.json`.
+    const legacyManifestPath = path.join(targetSkillsDir, exports.SKILLS_MANIFEST_FILENAME);
+    const legacyUnifiedPath = path.join(targetSkillsDir, exports.LEGACY_UNIFIED_SKILLS_MANIFEST_FILENAME);
+    const legacyPluginPath = path.join(targetSkillsDir, exports.LEGACY_PLUGIN_MANIFEST_FILENAME);
+    const legacyClaudePath = path.join(targetSkillsDir, exports.LEGACY_CLAUDE_MANIFEST_FILENAME);
     await Promise.allSettled([
+        fs.unlink(legacyManifestPath),
         fs.unlink(legacyUnifiedPath),
         fs.unlink(legacyPluginPath),
         fs.unlink(legacyClaudePath),

package/dist/core/apply-engine.js

@@ -512,9 +512,13 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
         (0, constants_1.logVerbose)(`DRY RUN: Would apply MCP config to: ${dest}`, verbose);
     }
     else {
-        // Transform MCP config for agent-specific compatibility
+        // Transform MCP config for compatibility.
+        //
+        // `.mcp.json` is shared (Claude Code + others). Keep it Claude-compatible
+        // so later agents don't overwrite `http|sse` back to legacy `remote`.
         let mcpToMerge = filteredMcpJson;
-        if (agent.getIdentifier() === 'claude') {
+        if (agent.getIdentifier() === 'claude' ||
+            path.basename(dest) === '.mcp.json') {
             mcpToMerge = transformMcpForClaude(filteredMcpJson);
         }
         else if (agent.getIdentifier() === 'kilocode') {

package/package.json

@@ -1,79 +1,78 @@
 {
-  "name": "skiller",
-  "version": "0.7.19",
-  "description": "Skiller — apply the same rules to all coding agents",
-  "main": "dist/lib.js",
-  "publishConfig": {
-    "access": "public"
-  },
-  "scripts": {
-    "postinstall": "[ -n \"$CI\" ] || npx skiller@latest apply",
-    "lint": "eslint \"src/**/*.{ts,tsx}\"",
-    "lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
-    "format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:integration": "jest tests/e2e/skiller.integration.test.ts --verbose",
-    "build": "tsc",
-    "release": "pnpm build && pnpm changeset publish"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/udecode/skiller.git"
-  },
-  "keywords": [
-    "ai",
-    "developer-tools",
-    "copilot",
-    "codex",
-    "claude",
-    "cursor",
-    "aider",
-    "config",
-    "rules",
-    "automation"
-  ],
-  "author": "Eleanor Berger",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/udecode/skiller/issues"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE"
-  ],
-  "bin": {
-    "skiller": "dist/cli/index.js"
-  },
-  "devDependencies": {
-    "@changesets/changelog-github": "^0.5.2",
-    "@changesets/cli": "2.29.8",
-    "@eslint/js": "^9.39.1",
-    "@types/iarna__toml": "^2.0.5",
-    "@types/jest": "^29.5.14",
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^24.9.2",
-    "@types/yargs": "^17.0.34",
-    "@typescript-eslint/eslint-plugin": "^8.46.2",
-    "@typescript-eslint/parser": "^8.46.2",
-    "eslint": "^9.38.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
-    "jest": "^29.7.0",
-    "prettier": "^3.6.2",
-    "ts-jest": "^29.4.5",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.2"
-  },
-  "dependencies": {
-    "@iarna/toml": "^2.2.5",
-    "js-yaml": "^4.1.0",
-    "yargs": "^18.0.0",
-    "zod": "^4.1.12"
-  }
+	"name": "skiller",
+	"version": "0.7.21",
+	"description": "Skiller — apply the same rules to all coding agents",
+	"main": "dist/lib.js",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"lint": "eslint \"src/**/*.{ts,tsx}\"",
+		"lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
+		"format": "prettier --write \"src/**/*.{ts,tsx,json,md}\"",
+		"test": "jest",
+		"test:watch": "jest --watch",
+		"test:coverage": "jest --coverage",
+		"test:integration": "jest tests/e2e/skiller.integration.test.ts --verbose",
+		"build": "tsc",
+		"release": "pnpm build && pnpm changeset publish"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/udecode/skiller.git"
+	},
+	"keywords": [
+		"ai",
+		"developer-tools",
+		"copilot",
+		"codex",
+		"claude",
+		"cursor",
+		"aider",
+		"config",
+		"rules",
+		"automation"
+	],
+	"author": "Eleanor Berger",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/udecode/skiller/issues"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"bin": {
+		"skiller": "dist/cli/index.js"
+	},
+	"devDependencies": {
+		"@changesets/changelog-github": "^0.5.2",
+		"@changesets/cli": "2.29.8",
+		"@eslint/js": "^9.39.1",
+		"@types/iarna__toml": "^2.0.5",
+		"@types/jest": "^29.5.14",
+		"@types/js-yaml": "^4.0.9",
+		"@types/node": "^24.9.2",
+		"@types/yargs": "^17.0.34",
+		"@typescript-eslint/eslint-plugin": "^8.46.2",
+		"@typescript-eslint/parser": "^8.46.2",
+		"eslint": "^9.38.0",
+		"eslint-config-prettier": "^10.1.8",
+		"eslint-plugin-prettier": "^5.5.4",
+		"jest": "^29.7.0",
+		"prettier": "^3.6.2",
+		"ts-jest": "^29.4.5",
+		"typescript": "^5.9.3",
+		"typescript-eslint": "^8.46.2"
+	},
+	"dependencies": {
+		"@iarna/toml": "^2.2.5",
+		"js-yaml": "^4.1.0",
+		"yargs": "^18.0.0",
+		"zod": "^4.1.12"
+	}
 }