skiller 0.8.2 → 0.9.0

package/dist/core/RulesToSkillsMigration.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRulesReplacementInstallArgs = buildRulesReplacementInstallArgs;
+exports.removeLocalRuleReplacementState = removeLocalRuleReplacementState;
+exports.planRulesToSkillsMigration = planRulesToSkillsMigration;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const SkillsManifest_1 = require("./SkillsManifest");
+const project_paths_1 = require("./project-paths");
+const SEARCH_API_BASE = process.env.SKILLS_API_URL || 'https://skills.sh';
+function normalizeRuleName(value) {
+    return value.endsWith('.mdc') ? path.basename(value, '.mdc') : value;
+}
+function normalizeInstalledSkillName(value) {
+    return value.replace(/:/g, '-');
+}
+function getRulesDir(projectRoot) {
+    return path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, 'rules');
+}
+async function listRuleNames(projectRoot) {
+    const rulesDir = getRulesDir(projectRoot);
+    try {
+        const entries = await fs.readdir(rulesDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.mdc'))
+            .map((entry) => path.basename(entry.name, '.mdc'))
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}
+async function loadInstalledSkillNames(projectRoot) {
+    const skillsLockPath = path.join(projectRoot, 'skills-lock.json');
+    try {
+        const raw = JSON.parse(await fs.readFile(skillsLockPath, 'utf8'));
+        return new Set(Object.keys(raw.skills ?? {}).map(normalizeInstalledSkillName));
+    }
+    catch {
+        return new Set();
+    }
+}
+function mapRegistrySkill(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const record = raw;
+    if (typeof record.name !== 'string' ||
+        typeof record.id !== 'string' ||
+        (record.source !== undefined && typeof record.source !== 'string') ||
+        (record.installs !== undefined && typeof record.installs !== 'number')) {
+        return null;
+    }
+    return {
+        installs: typeof record.installs === 'number' ? record.installs : 0,
+        name: record.name,
+        slug: record.id,
+        source: typeof record.source === 'string' ? record.source : '',
+    };
+}
+async function searchSkillsApi(query) {
+    try {
+        const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=10`;
+        const response = await fetch(url);
+        if (!response.ok)
+            return [];
+        const payload = (await response.json());
+        return (payload.skills ?? [])
+            .map(mapRegistrySkill)
+            .filter((skill) => skill !== null)
+            .sort((a, b) => b.installs - a.installs);
+    }
+    catch {
+        return [];
+    }
+}
+function isExactRuleMatch(ruleName, match) {
+    const normalizedRuleName = ruleName.toLowerCase();
+    const normalizedSkillName = match.name.toLowerCase();
+    const slugParts = match.slug.split('/').filter(Boolean);
+    const normalizedSlugName = (slugParts.length > 0 ? slugParts[slugParts.length - 1] : '').toLowerCase();
+    return (normalizedSkillName === normalizedRuleName ||
+        normalizedSlugName === normalizedRuleName);
+}
+function dedupeNames(values) {
+    return [...new Set(values.map(normalizeRuleName))].sort((a, b) => a.localeCompare(b));
+}
+function sourceFromSlug(slug) {
+    const parts = slug.split('/').filter(Boolean);
+    if (parts.length >= 2) {
+        return `${parts[0]}/${parts[1]}`;
+    }
+    return slug;
+}
+function buildRulesReplacementInstallArgs(match) {
+    const source = match.source || sourceFromSlug(match.slug);
+    return ['add', source, '--agent', 'universal', '--skill', match.name, '-y'];
+}
+async function removeLocalRuleReplacementState(projectRoot, ruleName, dryRun) {
+    const rulesDir = getRulesDir(projectRoot);
+    const rulePath = path.join(rulesDir, `${ruleName}.mdc`);
+    if (!dryRun) {
+        await fs.rm(rulePath, { force: true });
+    }
+    const localSkillNames = await (0, SkillsManifest_1.loadLocalSkillNames)(projectRoot);
+    if (!localSkillNames.includes(ruleName)) {
+        return;
+    }
+    await (0, SkillsManifest_1.writeLocalSkillNames)(projectRoot, localSkillNames.filter((name) => name !== ruleName), dryRun);
+}
+async function planRulesToSkillsMigration(projectRoot, requestedRuleNames) {
+    const availableRuleNames = await listRuleNames(projectRoot);
+    const selectedRuleNames = requestedRuleNames && requestedRuleNames.length > 0
+        ? dedupeNames(requestedRuleNames)
+        : availableRuleNames;
+    const availableRuleSet = new Set(availableRuleNames);
+    const missingRequested = selectedRuleNames.filter((ruleName) => !availableRuleSet.has(ruleName));
+    const installedSkillNames = await loadInstalledSkillNames(projectRoot);
+    const candidates = [];
+    const unmatched = [];
+    for (const ruleName of selectedRuleNames) {
+        if (!availableRuleSet.has(ruleName))
+            continue;
+        const exactMatches = (await searchSkillsApi(ruleName)).filter((match) => isExactRuleMatch(ruleName, match));
+        if (exactMatches.length === 0) {
+            unmatched.push(ruleName);
+            continue;
+        }
+        candidates.push({
+            alreadyInstalled: installedSkillNames.has(ruleName),
+            matches: exactMatches,
+            ruleName,
+        });
+    }
+    return {
+        candidates,
+        missingRequested,
+        scannedRules: selectedRuleNames.filter((ruleName) => availableRuleSet.has(ruleName)),
+        unmatched,
+    };
+}

package/dist/core/SkillOwnership.js

@@ -0,0 +1,397 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCanonicalSkillsDir = getCanonicalSkillsDir;
+exports.getCanonicalRulesDir = getCanonicalRulesDir;
+exports.readUpstreamOwnedSkillNames = readUpstreamOwnedSkillNames;
+exports.resolveSkillOwnership = resolveSkillOwnership;
+exports.adoptSkillerOwnedSkillNames = adoptSkillerOwnedSkillNames;
+exports.migrateLegacyProjectState = migrateLegacyProjectState;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const project_paths_1 = require("./project-paths");
+const SkillsManifest_1 = require("./SkillsManifest");
+const FrontmatterParser_1 = require("./FrontmatterParser");
+function normalizeSkillNameForFilesystem(name) {
+    return name.replace(/:/g, '-');
+}
+function getSkillsLockPath(projectRoot) {
+    return path.join(projectRoot, 'skills-lock.json');
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buffersEqual(a, b) {
+    return a.length === b.length && a.equals(b);
+}
+const LEGACY_AGENT_ID_MAP = {
+    claude: 'claude-code',
+    copilot: 'github-copilot',
+    augmentcode: 'augment',
+    kilocode: 'kilo',
+    kiro: 'kiro-cli',
+    qwen: 'qwen-code',
+};
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function rewriteLegacyAgentIdsInToml(content) {
+    let rewritten = content;
+    rewritten = rewritten.replace(/^(default_agents\s*=\s*\[)([\s\S]*?)(\])/m, (_match, prefix, body, suffix) => {
+        const rewrittenBody = body.replace(/"([^"]+)"/g, (quoted, id) => {
+            const mapped = LEGACY_AGENT_ID_MAP[id];
+            return mapped ? `"${mapped}"` : quoted;
+        });
+        return `${prefix}${rewrittenBody}${suffix}`;
+    });
+    for (const [legacyId, canonicalId] of Object.entries(LEGACY_AGENT_ID_MAP)) {
+        const pattern = new RegExp(`^(\\[agents\\.)${escapeRegExp(legacyId)}(?=(?:\\.|\\]))`, 'gm');
+        rewritten = rewritten.replace(pattern, `$1${canonicalId}`);
+    }
+    return rewritten;
+}
+function isReferenceBody(body) {
+    const lines = body.split('\n').filter((line) => line.trim().length > 0);
+    if (lines.length !== 1)
+        return null;
+    const line = lines[0].trim();
+    return line.startsWith('@') ? line.slice(1) : null;
+}
+function inferProjectRootFromSkillFile(filePath) {
+    let current = path.dirname(filePath);
+    while (true) {
+        const base = path.basename(current);
+        if (base === project_paths_1.CANONICAL_SKILLER_DIR || base === project_paths_1.LEGACY_SKILLER_DIR) {
+            return path.dirname(current);
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return path.dirname(path.dirname(filePath));
+        }
+        current = parent;
+    }
+}
+async function normalizeSkillDocumentContent(filePath, content) {
+    if (path.basename(filePath) !== 'SKILL.md') {
+        return content;
+    }
+    const text = content.toString('utf8');
+    const { frontmatter, rawFrontmatter, body } = (0, FrontmatterParser_1.parseFrontmatter)(text);
+    const referencePath = isReferenceBody(body);
+    let normalizedBody = body;
+    if (referencePath) {
+        const skillFolderPath = path.dirname(filePath);
+        const projectRoot = inferProjectRootFromSkillFile(filePath);
+        const absoluteRefPath = referencePath.startsWith('./') || referencePath.startsWith('../')
+            ? path.resolve(skillFolderPath, referencePath)
+            : path.resolve(projectRoot, referencePath);
+        try {
+            const referencedContent = await fs.readFile(absoluteRefPath, 'utf8');
+            normalizedBody = (0, FrontmatterParser_1.parseFrontmatter)(referencedContent).body;
+        }
+        catch {
+            return content;
+        }
+    }
+    const frontmatterData = rawFrontmatter && Object.keys(rawFrontmatter).length > 0
+        ? rawFrontmatter
+        : frontmatter && Object.keys(frontmatter).length > 0
+            ? frontmatter
+            : null;
+    if (!frontmatterData) {
+        return Buffer.from(`${normalizedBody.trimEnd()}\n`);
+    }
+    return Buffer.from(`---
+${yaml.dump(frontmatterData, { lineWidth: -1, noRefs: true }).trim()}
+---
+
+${normalizedBody.trimEnd()}
+`);
+}
+async function filesAreEquivalent(leftPath, leftContent, rightPath, rightContent) {
+    if (buffersEqual(leftContent, rightContent))
+        return true;
+    const [normalizedLeft, normalizedRight] = await Promise.all([
+        normalizeSkillDocumentContent(leftPath, leftContent),
+        normalizeSkillDocumentContent(rightPath, rightContent),
+    ]);
+    return buffersEqual(normalizedLeft, normalizedRight);
+}
+async function collectFilesRecursive(dir, prefix = '') {
+    const collected = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const relativePath = prefix ? path.join(prefix, entry.name) : entry.name;
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collected.push(...(await collectFilesRecursive(fullPath, relativePath)));
+            continue;
+        }
+        if (entry.isFile()) {
+            collected.push({
+                relativePath,
+                content: await fs.readFile(fullPath),
+            });
+        }
+    }
+    return collected;
+}
+async function planBufferWrite(destinationPath, content, sourceLabel, plannedWrites, conflicts) {
+    const planned = plannedWrites.get(destinationPath);
+    if (planned) {
+        if (!buffersEqual(planned, content)) {
+            conflicts.push(`${sourceLabel} conflicts with planned write ${destinationPath}`);
+        }
+        return;
+    }
+    try {
+        const stat = await fs.stat(destinationPath);
+        if (!stat.isFile()) {
+            conflicts.push(`${sourceLabel} conflicts with existing directory ${destinationPath}`);
+            return;
+        }
+        const existing = await fs.readFile(destinationPath);
+        if (!(await filesAreEquivalent(sourceLabel, content, destinationPath, existing))) {
+            conflicts.push(`${sourceLabel} conflicts with existing file ${destinationPath}`);
+        }
+        return;
+    }
+    catch {
+        plannedWrites.set(destinationPath, content);
+    }
+}
+async function planFileMigration(sourcePath, destinationPath, plannedWrites, deletePaths, conflicts) {
+    if (!(await pathExists(sourcePath)))
+        return;
+    await planBufferWrite(destinationPath, await fs.readFile(sourcePath), sourcePath, plannedWrites, conflicts);
+    if (conflicts.length === 0) {
+        deletePaths.add(sourcePath);
+    }
+}
+async function planDirectoryMigration(sourceDir, destinationDir, plannedWrites, deletePaths, conflicts) {
+    if (!(await pathExists(sourceDir)))
+        return;
+    for (const entry of await collectFilesRecursive(sourceDir)) {
+        await planBufferWrite(path.join(destinationDir, entry.relativePath), entry.content, path.join(sourceDir, entry.relativePath), plannedWrites, conflicts);
+    }
+    if (conflicts.length === 0) {
+        deletePaths.add(sourceDir);
+    }
+}
+async function findRuleSkillFolders(dir) {
+    const folders = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const fullPath = path.join(dir, entry.name);
+        if (await pathExists(path.join(fullPath, 'SKILL.md'))) {
+            folders.push(fullPath);
+            continue;
+        }
+        folders.push(...(await findRuleSkillFolders(fullPath)));
+    }
+    return folders;
+}
+async function planLegacyRulesMigration(legacyRulesDir, canonicalRulesDir, canonicalSkillsDir, plannedWrites, deletePaths, conflicts) {
+    if (!(await pathExists(legacyRulesDir)))
+        return;
+    const entries = await fs.readdir(legacyRulesDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith('.mdc'))
+            continue;
+        const sourcePath = path.join(legacyRulesDir, entry.name);
+        const ruleDestination = path.join(canonicalRulesDir, entry.name);
+        await planBufferWrite(ruleDestination, await fs.readFile(sourcePath), sourcePath, plannedWrites, conflicts);
+    }
+    const skillFolders = await findRuleSkillFolders(legacyRulesDir);
+    for (const folder of skillFolders) {
+        const folderName = path.basename(folder);
+        await planDirectoryMigration(folder, path.join(canonicalSkillsDir, folderName), plannedWrites, deletePaths, conflicts);
+    }
+    if (conflicts.length === 0) {
+        deletePaths.add(legacyRulesDir);
+    }
+}
+function getCanonicalSkillsDir(projectRoot) {
+    return path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, 'skills');
+}
+function getCanonicalRulesDir(projectRoot) {
+    return path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR, 'rules');
+}
+async function readLocalRuleSkillNames(projectRoot) {
+    try {
+        const entries = await fs.readdir(getCanonicalRulesDir(projectRoot), {
+            withFileTypes: true,
+        });
+        return new Set(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.mdc'))
+            .map((entry) => path.basename(entry.name, '.mdc'))
+            .sort((a, b) => a.localeCompare(b)));
+    }
+    catch {
+        return new Set();
+    }
+}
+async function readCanonicalSkillNames(projectRoot) {
+    try {
+        const entries = await fs.readdir(getCanonicalSkillsDir(projectRoot), {
+            withFileTypes: true,
+        });
+        return new Set(entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((a, b) => a.localeCompare(b)));
+    }
+    catch {
+        return new Set();
+    }
+}
+async function readUpstreamOwnedSkillNames(projectRoot) {
+    try {
+        const raw = JSON.parse(await fs.readFile(getSkillsLockPath(projectRoot), 'utf8'));
+        return new Set(Object.keys(raw.skills ?? {})
+            .map(normalizeSkillNameForFilesystem)
+            .sort((a, b) => a.localeCompare(b)));
+    }
+    catch {
+        return new Set();
+    }
+}
+async function resolveSkillOwnership(projectRoot) {
+    const upstreamOwned = await readUpstreamOwnedSkillNames(projectRoot);
+    const localOwned = new Set([
+        ...(await (0, SkillsManifest_1.loadLocalSkillNames)(projectRoot)),
+        ...(await readLocalRuleSkillNames(projectRoot)),
+    ]);
+    const canonicalSkillNames = await readCanonicalSkillNames(projectRoot);
+    const allExplicitNames = new Set([...upstreamOwned, ...localOwned]);
+    const orphaned = new Set([...canonicalSkillNames]
+        .filter((name) => !allExplicitNames.has(name))
+        .sort((a, b) => a.localeCompare(b)));
+    const conflicts = [...allExplicitNames]
+        .filter((name) => {
+        let owners = 0;
+        if (upstreamOwned.has(name))
+            owners += 1;
+        if (localOwned.has(name))
+            owners += 1;
+        return owners > 1;
+    })
+        .sort((a, b) => a.localeCompare(b));
+    const warnings = [
+        ...conflicts.map((name) => {
+            const owners = [];
+            if (upstreamOwned.has(name))
+                owners.push('skills-lock.json');
+            if (localOwned.has(name))
+                owners.push('local rules/.agents/.skiller.json');
+            return `Skill '${name}' has mixed ownership: ${owners.join(', ')}`;
+        }),
+        ...[...orphaned].map((name) => {
+            return `Canonical skill '${name}' is unmanaged; leaving it untouched because it is not in skills-lock.json, .agents/rules/${name}.mdc, or .agents/.skiller.json localSkills.`;
+        }),
+    ];
+    return {
+        upstreamOwned,
+        localOwned,
+        orphaned,
+        conflicts,
+        warnings,
+    };
+}
+async function adoptSkillerOwnedSkillNames(projectRoot, skillNames, dryRun) {
+    if (skillNames.length === 0)
+        return;
+    const ownership = await resolveSkillOwnership(projectRoot);
+    const next = new Set(ownership.localOwned);
+    for (const name of skillNames) {
+        if (ownership.upstreamOwned.has(name))
+            continue;
+        next.add(name);
+    }
+    await (0, SkillsManifest_1.writeLocalSkillNames)(projectRoot, [...next], dryRun);
+}
+async function migrateLegacyProjectState(projectRoot, dryRun) {
+    const legacyDir = path.join(projectRoot, project_paths_1.LEGACY_SKILLER_DIR);
+    const canonicalDir = path.join(projectRoot, project_paths_1.CANONICAL_SKILLER_DIR);
+    const canonicalSkillsDir = path.join(canonicalDir, 'skills');
+    const canonicalRulesDir = path.join(canonicalDir, 'rules');
+    try {
+        await fs.access(legacyDir);
+    }
+    catch {
+        return;
+    }
+    const plannedWrites = new Map();
+    const deletePaths = new Set();
+    const conflicts = [];
+    await planFileMigration(path.join(legacyDir, '.skiller.json'), path.join(canonicalDir, '.skiller.json'), plannedWrites, deletePaths, conflicts);
+    const legacyConfigPath = path.join(legacyDir, project_paths_1.SKILLER_CONFIG_FILE);
+    if (await pathExists(legacyConfigPath)) {
+        await planBufferWrite(path.join(canonicalDir, project_paths_1.SKILLER_CONFIG_FILE), Buffer.from(rewriteLegacyAgentIdsInToml(await fs.readFile(legacyConfigPath, 'utf8'))), legacyConfigPath, plannedWrites, conflicts);
+        if (conflicts.length === 0) {
+            deletePaths.add(legacyConfigPath);
+        }
+    }
+    await planFileMigration(path.join(legacyDir, project_paths_1.PROJECT_AGENTS_FILE), path.join(canonicalDir, project_paths_1.PROJECT_AGENTS_FILE), plannedWrites, deletePaths, conflicts);
+    await planDirectoryMigration(path.join(legacyDir, 'skills'), canonicalSkillsDir, plannedWrites, deletePaths, conflicts);
+    await planLegacyRulesMigration(path.join(legacyDir, 'rules'), canonicalRulesDir, canonicalSkillsDir, plannedWrites, deletePaths, conflicts);
+    if (conflicts.length > 0) {
+        throw new Error(`Legacy .claude migration conflicts:\n- ${conflicts.join('\n- ')}`);
+    }
+    if (dryRun)
+        return;
+    for (const [destinationPath, content] of plannedWrites.entries()) {
+        await fs.mkdir(path.dirname(destinationPath), { recursive: true });
+        await fs.writeFile(destinationPath, content);
+    }
+    for (const deletePath of [...deletePaths].sort((a, b) => b.length - a.length)) {
+        await fs.rm(deletePath, { recursive: true, force: true });
+    }
+    if (await pathExists(canonicalSkillsDir)) {
+        const { compileRulesToSkills, extractLocalRulesFromCanonicalSkills, normalizeCanonicalSkills, } = await Promise.resolve().then(() => __importStar(require('./SkillsProcessor')));
+        await extractLocalRulesFromCanonicalSkills(projectRoot, false, false);
+        await compileRulesToSkills(canonicalDir, projectRoot, false, false);
+        await normalizeCanonicalSkills(projectRoot, canonicalSkillsDir, false, false);
+    }
+}