skiller 0.9.10 → 0.9.11

package/dist/cli/handlers.js

@@ -79,6 +79,46 @@ async function applyAfterSkillsLifecycleStep(projectRoot, verbose) {
         verbose,
     });
 }
+async function pruneSkillOutputs(projectRoot, skillNames) {
+    const normalizedNames = [...new Set(skillNames.filter(Boolean))];
+    if (normalizedNames.length === 0)
+        return;
+    const skillDirs = new Set([(0, SkillOwnership_1.getCanonicalSkillsDir)(projectRoot)]);
+    for (const agent of agents_2.allAgents) {
+        if (!agent.supportsNativeSkills?.() || !agent.getSkillsPath)
+            continue;
+        const skillsPath = agent.getSkillsPath(projectRoot);
+        if (skillsPath) {
+            skillDirs.add(skillsPath);
+        }
+    }
+    for (const skillName of normalizedNames) {
+        for (const skillsDir of skillDirs) {
+            await fs.rm(path.join(skillsDir, skillName), {
+                force: true,
+                recursive: true,
+            });
+        }
+    }
+}
+async function pruneStaleLockBackedSkills(projectRoot) {
+    const [nativePrune, agentPrune] = await Promise.all([
+        (0, AgentSourceCompatibility_1.pruneMissingNativeSkillsFromLock)(projectRoot),
+        (0, AgentSourceCompatibility_1.pruneMissingAgentSkillsFromLock)(projectRoot),
+    ]);
+    if (nativePrune.prunedOutputNames.length > 0) {
+        await pruneSkillOutputs(projectRoot, nativePrune.prunedOutputNames);
+        console.log(`[skiller] Pruned ${nativePrune.prunedKeys.length} stale upstream skill(s): ${nativePrune.prunedKeys.join(', ')}`);
+    }
+    if (agentPrune.prunedOutputNames.length > 0) {
+        await pruneSkillOutputs(projectRoot, agentPrune.prunedOutputNames);
+        console.log(`[skiller] Pruned ${agentPrune.prunedKeys.length} stale agent-derived skill(s): ${agentPrune.prunedKeys.join(', ')}`);
+    }
+    const warnings = [...nativePrune.warnings, ...agentPrune.warnings];
+    if (warnings.length > 0) {
+        console.log(warnings.map((warning) => `[skiller] ${warning}`).join('\n'));
+    }
+}
 function normalizeRequestedSkillNames(args) {
     if (!args || args.length === 0)
         return [];
@@ -681,6 +721,7 @@ async function addHandler(argv) {
     await applyAfterSkillsLifecycleStep(projectRoot, argv.verbose ?? false);
 }
 async function installHandler(argv) {
+    await pruneStaleLockBackedSkills(argv['project-root']);
     await executeSkillsWrapper(argv['project-root'], [
         'experimental_install',
         ...(argv.args ?? []),
@@ -733,6 +774,7 @@ async function checkHandler(argv) {
     ]);
 }
 async function updateHandler(argv) {
+    await pruneStaleLockBackedSkills(argv['project-root']);
     await executeSkillsWrapper(argv['project-root'], [
         'update',
         ...(argv.args ?? []),

package/dist/core/AgentSourceCompatibility.js

@@ -44,6 +44,8 @@ exports.restoreAgentSkillsFromLock = restoreAgentSkillsFromLock;
 exports.getOutdatedAgentSkills = getOutdatedAgentSkills;
 exports.updateAgentSkillsFromLock = updateAgentSkillsFromLock;
 exports.removeAgentManagedSkills = removeAgentManagedSkills;
+exports.pruneMissingNativeSkillsFromLock = pruneMissingNativeSkillsFromLock;
+exports.pruneMissingAgentSkillsFromLock = pruneMissingAgentSkillsFromLock;
 const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs/promises"));
 const path = __importStar(require("path"));
@@ -67,12 +69,43 @@ const SKIP_DIRS = new Set([
     'tmp',
     'tmp-fixtures',
 ]);
+const NATIVE_SKILLS_LOCK_VERSION = 1;
 function hashContent(content) {
     return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
 }
 function normalizeSkillNameForFilesystem(name) {
     return name.trim().replace(/:/g, '-');
 }
+function createEmptyNativeSkillsLock() {
+    return {
+        version: NATIVE_SKILLS_LOCK_VERSION,
+        skills: {},
+    };
+}
+async function readNativeSkillsLock(projectRoot) {
+    try {
+        const raw = JSON.parse(await fs.readFile(path.join(projectRoot, 'skills-lock.json'), 'utf8'));
+        if (raw.version !== NATIVE_SKILLS_LOCK_VERSION ||
+            !raw.skills ||
+            typeof raw.skills !== 'object') {
+            return createEmptyNativeSkillsLock();
+        }
+        return raw;
+    }
+    catch {
+        return createEmptyNativeSkillsLock();
+    }
+}
+async function writeNativeSkillsLock(projectRoot, lock) {
+    const sortedSkills = {};
+    for (const key of Object.keys(lock.skills).sort((a, b) => a.localeCompare(b))) {
+        sortedSkills[key] = lock.skills[key];
+    }
+    await fs.writeFile(path.join(projectRoot, 'skills-lock.json'), JSON.stringify({
+        version: NATIVE_SKILLS_LOCK_VERSION,
+        skills: sortedSkills,
+    }, null, 2) + '\n', 'utf8');
+}
 function isLocalPath(input) {
     return (path.isAbsolute(input) ||
         input.startsWith('./') ||
@@ -708,3 +741,84 @@ async function removeAgentManagedSkills(projectRoot, skillNames) {
     }
     return removed;
 }
+async function pruneMissingNativeSkillsFromLock(projectRoot) {
+    const lock = await readNativeSkillsLock(projectRoot);
+    const prunedKeys = [];
+    const prunedOutputNames = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        if (entry.sourceType === 'node_modules' ||
+            entry.sourceType === 'well-known') {
+            continue;
+        }
+        let workspace = null;
+        try {
+            workspace = await withSourceWorkspace(entry.source);
+            const availableSkillNames = new Set(await discoverSkillNames(workspace.searchPath));
+            for (const [skillName] of entries) {
+                const installName = normalizeSkillNameForFilesystem(skillName);
+                if (availableSkillNames.has(installName))
+                    continue;
+                prunedKeys.push(skillName);
+                prunedOutputNames.push(installName);
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not inspect '${entry.source}' for stale skills: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (workspace) {
+                await workspace.cleanup();
+            }
+        }
+    }
+    if (prunedKeys.length > 0) {
+        for (const skillName of prunedKeys) {
+            delete lock.skills[skillName];
+        }
+        await writeNativeSkillsLock(projectRoot, lock);
+    }
+    return {
+        prunedKeys: prunedKeys.sort((a, b) => a.localeCompare(b)),
+        prunedOutputNames: prunedOutputNames.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}
+async function pruneMissingAgentSkillsFromLock(projectRoot) {
+    const lock = await (0, SkillerLock_1.readSkillerLock)(projectRoot);
+    const prunedKeys = [];
+    const prunedOutputNames = [];
+    const warnings = [];
+    for (const entries of groupLockEntriesBySource(lock.skills).values()) {
+        const [, entry] = entries[0];
+        let workspace = null;
+        try {
+            workspace = await withParsedSourceWorkspace(parseSourceFromLockEntry(entry));
+            const agentSkills = await discoverAgentSkillCandidates(workspace.searchPath, workspace.rootPath);
+            const candidates = new Set(agentSkills.map((candidate) => candidate.sourceRelPath));
+            for (const [skillName, lockEntry] of entries) {
+                if (candidates.has(lockEntry.sourceRelPath))
+                    continue;
+                prunedKeys.push(skillName);
+                prunedOutputNames.push(normalizeSkillNameForFilesystem(skillName));
+            }
+        }
+        catch (error) {
+            warnings.push(`Could not inspect '${entry.source}' for stale agent-derived skills: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (workspace) {
+                await workspace.cleanup();
+            }
+        }
+    }
+    if (prunedKeys.length > 0) {
+        await (0, SkillerLock_1.removeSkillerLockEntries)(projectRoot, prunedKeys);
+    }
+    return {
+        prunedKeys: prunedKeys.sort((a, b) => a.localeCompare(b)),
+        prunedOutputNames: prunedOutputNames.sort((a, b) => a.localeCompare(b)),
+        warnings,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skiller",
-  "version": "0.9.10",
+  "version": "0.9.11",
   "description": "Skiller — apply the same rules to all coding agents",
   "main": "dist/lib.js",
   "publishConfig": {