reskill 0.17.0 → 0.18.0

package/dist/cli/index.js

@@ -831,12 +831,10 @@ class CacheManager {
 const DEFAULT_SKILLS_JSON = {
     skills: {},
     defaults: {
-        registry: 'github',
         installDir: '.skills'
     }
 };
 const DEFAULT_VALUES = {
-    registry: 'github',
     installDir: '.skills',
     targetAgents: [],
     installMode: 'symlink'
@@ -908,7 +906,6 @@ class ConfigLoader {
         const config = this.getConfigOrDefault();
         const storedDefaults = config.defaults ?? {};
         return {
-            registry: storedDefaults.registry ?? DEFAULT_VALUES.registry,
             installDir: storedDefaults.installDir ?? DEFAULT_VALUES.installDir,
             targetAgents: storedDefaults.targetAgents ?? DEFAULT_VALUES.targetAgents,
             installMode: storedDefaults.installMode ?? DEFAULT_VALUES.installMode
@@ -973,10 +970,7 @@ class ConfigLoader {
     }
 }
 class GitResolver {
-    defaultRegistry;
-    constructor(defaultRegistry = 'github'){
-        this.defaultRegistry = defaultRegistry;
-    }
+    defaultRegistry = 'github';
     parseRef(ref) {
         const raw = ref;
         if (isGitUrl(ref)) return this.parseGitUrlRef(ref);
@@ -1274,8 +1268,7 @@ class SkillManager {
         this.config = new ConfigLoader(this.projectRoot);
         this.lockManager = new LockManager(this.projectRoot);
         this.cache = new CacheManager();
-        const defaults = this.config.getDefaults();
-        this.resolver = new GitResolver(defaults.registry);
+        this.resolver = new GitResolver();
     }
     isGlobalMode() {
         return this.isGlobal;
@@ -1801,6 +1794,619 @@ function maybeHandleCompletion() {
     }
     return false;
 }
+function getStatusIcon(status) {
+    switch(status){
+        case 'ok':
+            return __WEBPACK_EXTERNAL_MODULE_chalk__["default"].green('✓');
+        case 'warn':
+            return __WEBPACK_EXTERNAL_MODULE_chalk__["default"].yellow('⚠');
+        case 'error':
+            return __WEBPACK_EXTERNAL_MODULE_chalk__["default"].red('✗');
+    }
+}
+function execCommand(command) {
+    try {
+        return (0, __WEBPACK_EXTERNAL_MODULE_node_child_process__.execSync)(command, {
+            encoding: 'utf-8',
+            stdio: [
+                'pipe',
+                'pipe',
+                'pipe'
+            ]
+        }).trim();
+    } catch  {
+        return null;
+    }
+}
+function getDirSize(dirPath) {
+    if (!(0, external_node_fs_.existsSync)(dirPath)) return 0;
+    let size = 0;
+    try {
+        const items = (0, external_node_fs_.readdirSync)(dirPath, {
+            withFileTypes: true
+        });
+        for (const item of items){
+            const itemPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(dirPath, item.name);
+            if (item.isDirectory()) size += getDirSize(itemPath);
+            else if (item.isFile()) size += (0, external_node_fs_.statSync)(itemPath).size;
+        }
+    } catch  {}
+    return size;
+}
+function formatBytes(bytes) {
+    if (0 === bytes) return '0 B';
+    const k = 1024;
+    const sizes = [
+        'B',
+        'KB',
+        'MB',
+        'GB'
+    ];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${Number.parseFloat((bytes / k ** i).toFixed(1))} ${sizes[i]}`;
+}
+function countCachedSkills(cacheDir) {
+    if (!(0, external_node_fs_.existsSync)(cacheDir)) return 0;
+    let count = 0;
+    try {
+        const registries = (0, external_node_fs_.readdirSync)(cacheDir, {
+            withFileTypes: true
+        });
+        for (const registry of registries){
+            if (!registry.isDirectory()) continue;
+            const registryPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(cacheDir, registry.name);
+            const owners = (0, external_node_fs_.readdirSync)(registryPath, {
+                withFileTypes: true
+            });
+            for (const owner of owners){
+                if (!owner.isDirectory()) continue;
+                const ownerPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(registryPath, owner.name);
+                const repos = (0, external_node_fs_.readdirSync)(ownerPath, {
+                    withFileTypes: true
+                });
+                for (const repo of repos){
+                    if (!repo.isDirectory()) continue;
+                    const repoPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(ownerPath, repo.name);
+                    const versions = (0, external_node_fs_.readdirSync)(repoPath, {
+                        withFileTypes: true
+                    });
+                    count += versions.filter((v)=>v.isDirectory()).length;
+                }
+            }
+        }
+    } catch  {}
+    return count;
+}
+async function checkReskillVersion(currentVersion, packageName) {
+    try {
+        const result = await checkForUpdate(packageName, currentVersion);
+        if (result?.hasUpdate) return {
+            name: 'reskill version',
+            status: 'warn',
+            message: `${currentVersion} (latest: ${result.latest})`,
+            hint: `Run: npm i -g ${packageName}@latest`
+        };
+        return {
+            name: 'reskill version',
+            status: 'ok',
+            message: `${currentVersion} (latest)`
+        };
+    } catch  {
+        return {
+            name: 'reskill version',
+            status: 'ok',
+            message: currentVersion
+        };
+    }
+}
+function checkNodeVersion() {
+    const version = process.version;
+    const major = Number.parseInt(version.slice(1).split('.')[0], 10);
+    const required = 18;
+    if (major < required) return {
+        name: 'Node.js version',
+        status: 'error',
+        message: `${version} (requires >=${required}.0.0)`,
+        hint: 'Please upgrade Node.js to version 18 or higher'
+    };
+    return {
+        name: 'Node.js version',
+        status: 'ok',
+        message: `${version} (>=${required}.0.0 required)`
+    };
+}
+function checkGitVersion() {
+    const version = execCommand('git --version');
+    if (!version) return {
+        name: 'Git',
+        status: 'error',
+        message: 'not found',
+        hint: 'Please install Git: https://git-scm.com/downloads'
+    };
+    const match = version.match(/git version (\d+\.\d+\.\d+)/);
+    const versionNum = match ? match[1] : version;
+    return {
+        name: 'Git',
+        status: 'ok',
+        message: versionNum
+    };
+}
+function checkGitAuth() {
+    const home = (0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)();
+    const sshDir = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(home, '.ssh');
+    const sshKeyFiles = [
+        'id_rsa',
+        'id_ed25519',
+        'id_ecdsa',
+        'id_dsa'
+    ];
+    let hasSSHKey = false;
+    if ((0, external_node_fs_.existsSync)(sshDir)) {
+        for (const keyFile of sshKeyFiles)if ((0, external_node_fs_.existsSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(sshDir, keyFile))) {
+            hasSSHKey = true;
+            break;
+        }
+    }
+    const credentialHelper = execCommand('git config --global credential.helper');
+    const hasCredentialHelper = !!credentialHelper;
+    if (hasSSHKey && hasCredentialHelper) return {
+        name: 'Git authentication',
+        status: 'ok',
+        message: 'SSH key + credential helper configured'
+    };
+    if (hasSSHKey) return {
+        name: 'Git authentication',
+        status: 'ok',
+        message: 'SSH key found'
+    };
+    if (hasCredentialHelper) return {
+        name: 'Git authentication',
+        status: 'ok',
+        message: `credential helper: ${credentialHelper}`
+    };
+    return {
+        name: 'Git authentication',
+        status: 'warn',
+        message: 'no SSH key or credential helper found',
+        hint: 'For private repos, add SSH key: ssh-keygen -t ed25519'
+    };
+}
+function checkCacheDir() {
+    const cacheDir = process.env.RESKILL_CACHE_DIR || (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)((0, __WEBPACK_EXTERNAL_MODULE_node_os__.homedir)(), '.reskill-cache');
+    if (!(0, external_node_fs_.existsSync)(cacheDir)) return {
+        name: 'Cache directory',
+        status: 'ok',
+        message: `${cacheDir} (not created yet)`
+    };
+    const size = getDirSize(cacheDir);
+    const count = countCachedSkills(cacheDir);
+    return {
+        name: 'Cache directory',
+        status: 'ok',
+        message: `${cacheDir} (${formatBytes(size)}, ${count} skill${1 !== count ? 's' : ''} cached)`
+    };
+}
+function checkSkillsJson(cwd) {
+    const configLoader = new ConfigLoader(cwd);
+    if (!configLoader.exists()) return {
+        name: 'skills.json',
+        status: 'warn',
+        message: 'not found',
+        hint: 'Run: reskill init'
+    };
+    try {
+        const skills = configLoader.getSkills();
+        const count = Object.keys(skills).length;
+        return {
+            name: 'skills.json',
+            status: 'ok',
+            message: `found (${count} skill${1 !== count ? 's' : ''} declared)`
+        };
+    } catch (error) {
+        return {
+            name: 'skills.json',
+            status: 'error',
+            message: `invalid format: ${error.message}`,
+            hint: 'Check skills.json syntax'
+        };
+    }
+}
+const RESERVED_REGISTRIES = [
+    'github',
+    'gitlab'
+];
+const DANGEROUS_INSTALL_DIRS = [
+    'src',
+    'lib',
+    'dist',
+    'build',
+    'out',
+    'node_modules',
+    '.git',
+    '.github',
+    '.gitlab',
+    '.vscode',
+    '.idea'
+];
+const DANGEROUS_SKILL_NAMES = [
+    '.git',
+    '..',
+    '.',
+    'node_modules',
+    '__proto__',
+    'constructor'
+];
+const NETWORK_CHECK_TIMEOUT_MS = 5000;
+const CHECK_NAME_PAD_WIDTH = 26;
+function checkRegistryConflicts(cwd) {
+    const results = [];
+    const configLoader = new ConfigLoader(cwd);
+    if (!configLoader.exists()) return results;
+    try {
+        const config = configLoader.load();
+        const registries = config.registries || {};
+        for (const name of Object.keys(registries))if (RESERVED_REGISTRIES.includes(name.toLowerCase())) results.push({
+            name: 'Registry conflict',
+            status: 'warn',
+            message: `"${name}" overrides built-in registry`,
+            hint: 'Consider using a different name for custom registries'
+        });
+    } catch  {}
+    return results;
+}
+function checkInstallDir(cwd) {
+    const configLoader = new ConfigLoader(cwd);
+    if (!configLoader.exists()) return null;
+    try {
+        const defaults = configLoader.getDefaults();
+        const installDir = defaults.installDir;
+        if (!installDir) return null;
+        const normalizedDir = installDir.replace(/^\.\//, '').replace(/\/$/, '');
+        if (DANGEROUS_INSTALL_DIRS.includes(normalizedDir.toLowerCase())) return {
+            name: 'Dangerous installDir',
+            status: 'error',
+            message: `"${installDir}" may conflict with important directories`,
+            hint: 'Use a dedicated directory like ".skills" or ".agents/skills"'
+        };
+        if (installDir.includes('..')) return {
+            name: 'Dangerous installDir',
+            status: 'error',
+            message: `"${installDir}" contains path traversal`,
+            hint: 'Use a simple directory name without ".."'
+        };
+    } catch  {}
+    return null;
+}
+function checkTargetAgents(cwd) {
+    const results = [];
+    const configLoader = new ConfigLoader(cwd);
+    if (!configLoader.exists()) return results;
+    try {
+        const defaults = configLoader.getDefaults();
+        const targetAgents = defaults.targetAgents || [];
+        for (const agent of targetAgents)if (!isValidAgentType(agent)) results.push({
+            name: 'Invalid agent',
+            status: 'warn',
+            message: `Unknown agent type: "${agent}"`,
+            hint: 'Run: reskill install --help to see valid agent types'
+        });
+    } catch  {}
+    return results;
+}
+function checkSkillRefs(cwd) {
+    const results = [];
+    const configLoader = new ConfigLoader(cwd);
+    if (!configLoader.exists()) return results;
+    try {
+        const skills = configLoader.getSkills();
+        const resolver = new GitResolver();
+        for (const [name, ref] of Object.entries(skills)){
+            if (DANGEROUS_SKILL_NAMES.includes(name) || name.includes('/') || name.includes('\\')) {
+                results.push({
+                    name: 'Dangerous skill name',
+                    status: 'error',
+                    message: `"${name}" is not a valid skill name`,
+                    hint: 'Use alphanumeric names with hyphens or underscores'
+                });
+                continue;
+            }
+            try {
+                resolver.parseRef(ref);
+            } catch (error) {
+                results.push({
+                    name: 'Invalid skill ref',
+                    status: 'error',
+                    message: `"${name}": ${error.message}`,
+                    hint: 'Format: registry:owner/repo@version or owner/repo@version'
+                });
+            }
+        }
+    } catch  {}
+    return results;
+}
+function checkMonorepoVersions(cwd) {
+    const results = [];
+    const configLoader = new ConfigLoader(cwd);
+    if (!configLoader.exists()) return results;
+    try {
+        const skills = configLoader.getSkills();
+        const resolver = new GitResolver();
+        const repoVersions = new Map();
+        for (const [name, ref] of Object.entries(skills))try {
+            const parsed = resolver.parseRef(ref);
+            if (!parsed.subPath) continue;
+            const repoKey = `${parsed.registry}:${parsed.owner}/${parsed.repo}`;
+            const version = parsed.version || 'default';
+            let versions = repoVersions.get(repoKey);
+            if (!versions) {
+                versions = new Map();
+                repoVersions.set(repoKey, versions);
+            }
+            let skillList = versions.get(version);
+            if (!skillList) {
+                skillList = [];
+                versions.set(version, skillList);
+            }
+            skillList.push(name);
+        } catch  {}
+        for (const [repo, versions] of repoVersions)if (versions.size > 1) {
+            const versionList = [
+                ...versions.entries()
+            ].map(([v, skills])=>`${v} (${skills.join(', ')})`).join(', ');
+            results.push({
+                name: 'Version mismatch',
+                status: 'warn',
+                message: `${repo} has multiple versions: ${versionList}`,
+                hint: 'Consider using the same version for all skills from this repo'
+            });
+        }
+    } catch  {}
+    return results;
+}
+function checkSkillsLock(cwd) {
+    const configLoader = new ConfigLoader(cwd);
+    const lockManager = new LockManager(cwd);
+    if (!configLoader.exists()) return {
+        name: 'skills.lock',
+        status: 'ok',
+        message: 'n/a (no skills.json)'
+    };
+    if (!lockManager.exists()) {
+        const skills = configLoader.getSkills();
+        if (0 === Object.keys(skills).length) return {
+            name: 'skills.lock',
+            status: 'ok',
+            message: 'n/a (no skills declared)'
+        };
+        return {
+            name: 'skills.lock',
+            status: 'warn',
+            message: 'not found',
+            hint: 'Run: reskill install'
+        };
+    }
+    const configSkills = configLoader.getSkills();
+    const lockedSkills = lockManager.getAll();
+    const configNames = new Set(Object.keys(configSkills));
+    const lockedNames = new Set(Object.keys(lockedSkills));
+    const missingInLock = [
+        ...configNames
+    ].filter((n)=>!lockedNames.has(n));
+    const extraInLock = [
+        ...lockedNames
+    ].filter((n)=>!configNames.has(n));
+    if (missingInLock.length > 0) {
+        const displayMissing = missingInLock.length > 3 ? `${missingInLock.slice(0, 3).join(', ')} +${missingInLock.length - 3} more` : missingInLock.join(', ');
+        return {
+            name: 'skills.lock',
+            status: 'warn',
+            message: `out of sync (missing: ${displayMissing})`,
+            hint: 'Run: reskill install'
+        };
+    }
+    if (extraInLock.length > 0) {
+        const displayExtra = extraInLock.length > 3 ? `${extraInLock.slice(0, 3).join(', ')} +${extraInLock.length - 3} more` : extraInLock.join(', ');
+        return {
+            name: 'skills.lock',
+            status: 'warn',
+            message: `out of sync (extra: ${displayExtra})`,
+            hint: 'Run: reskill install'
+        };
+    }
+    return {
+        name: 'skills.lock',
+        status: 'ok',
+        message: `in sync (${lockedNames.size} skill${1 !== lockedNames.size ? 's' : ''} locked)`
+    };
+}
+function isValidSymlink(path) {
+    try {
+        const stat = (0, external_node_fs_.lstatSync)(path);
+        if (!stat.isSymbolicLink()) return true;
+        (0, external_node_fs_.realpathSync)(path);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function validateSkillJson(skillJsonPath) {
+    if (!(0, external_node_fs_.existsSync)(skillJsonPath)) return {
+        valid: true
+    };
+    try {
+        const content = (0, external_node_fs_.readFileSync)(skillJsonPath, 'utf-8');
+        const json = JSON.parse(content);
+        if (!json.name) return {
+            valid: false,
+            error: 'skill.json missing "name" field'
+        };
+        return {
+            valid: true
+        };
+    } catch (error) {
+        if (error instanceof SyntaxError) return {
+            valid: false,
+            error: 'skill.json is not valid JSON'
+        };
+        return {
+            valid: false,
+            error: `skill.json read error: ${error.message}`
+        };
+    }
+}
+function checkInstalledSkills(cwd) {
+    const results = [];
+    const skillManager = new SkillManager(cwd);
+    const installed = skillManager.list();
+    if (0 === installed.length) return [
+        {
+            name: 'Installed skills',
+            status: 'ok',
+            message: 'none'
+        }
+    ];
+    const issues = [];
+    for (const skill of installed){
+        const skillJsonPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(skill.path, 'skill.json');
+        const skillMdPath = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(skill.path, 'SKILL.md');
+        if (skill.isLinked && !isValidSymlink(skill.path)) {
+            issues.push({
+                name: skill.name,
+                reason: 'symlink target does not exist',
+                severity: 'error'
+            });
+            continue;
+        }
+        const hasSkillJson = (0, external_node_fs_.existsSync)(skillJsonPath);
+        const hasSkillMd = (0, external_node_fs_.existsSync)(skillMdPath);
+        if (!hasSkillJson && !hasSkillMd) {
+            issues.push({
+                name: skill.name,
+                reason: 'missing both skill.json and SKILL.md',
+                severity: 'error'
+            });
+            continue;
+        }
+        if (hasSkillJson) {
+            const validation = validateSkillJson(skillJsonPath);
+            if (!validation.valid) issues.push({
+                name: skill.name,
+                reason: validation.error || 'invalid skill.json',
+                severity: 'warn'
+            });
+        }
+    }
+    const errorCount = issues.filter((i)=>'error' === i.severity).length;
+    const warnCount = issues.filter((i)=>'warn' === i.severity).length;
+    if (0 === issues.length) results.push({
+        name: 'Installed skills',
+        status: 'ok',
+        message: `${installed.length} skill${1 !== installed.length ? 's' : ''} installed`
+    });
+    else {
+        const status = errorCount > 0 ? 'error' : 'warn';
+        const issueText = errorCount > 0 ? `${errorCount} broken` : `${warnCount} with issues`;
+        results.push({
+            name: 'Installed skills',
+            status,
+            message: `${installed.length} installed, ${issueText}`,
+            hint: 'Run: reskill install --force to fix'
+        });
+        for (const issue of issues)results.push({
+            name: `  └─ ${issue.name}`,
+            status: 'error' === issue.severity ? 'error' : 'warn',
+            message: issue.reason
+        });
+    }
+    return results;
+}
+async function checkNetwork(host) {
+    const displayName = host.replace('https://', '').replace('http://', '');
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(()=>controller.abort(), NETWORK_CHECK_TIMEOUT_MS);
+        const response = await fetch(host, {
+            method: 'HEAD',
+            signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (response.ok || 301 === response.status || 302 === response.status) return {
+            name: `Network (${displayName})`,
+            status: 'ok',
+            message: 'reachable'
+        };
+        return {
+            name: `Network (${displayName})`,
+            status: 'warn',
+            message: `status ${response.status}`
+        };
+    } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'unknown error';
+        return {
+            name: `Network (${displayName})`,
+            status: 'error',
+            message: `unreachable (${errorMessage})`,
+            hint: 'Check your internet connection or firewall settings'
+        };
+    }
+}
+function printResult(result) {
+    const icon = getStatusIcon(result.status);
+    const name = result.name.padEnd(CHECK_NAME_PAD_WIDTH);
+    const message = 'ok' === result.status ? result.message : __WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(result.message);
+    logger_logger.log(`${icon} ${name} ${message}`);
+    if (result.hint) logger_logger.log(`  ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim('→')} ${__WEBPACK_EXTERNAL_MODULE_chalk__["default"].dim(result.hint)}`);
+}
+async function runDoctorChecks(options) {
+    const { cwd, packageName, packageVersion, skipNetwork, skipConfigChecks } = options;
+    const results = [];
+    results.push(await checkReskillVersion(packageVersion, packageName));
+    results.push(checkNodeVersion());
+    results.push(checkGitVersion());
+    results.push(checkGitAuth());
+    results.push(checkCacheDir());
+    results.push(checkSkillsJson(cwd));
+    results.push(checkSkillsLock(cwd));
+    results.push(...checkInstalledSkills(cwd));
+    if (!skipConfigChecks) {
+        results.push(...checkRegistryConflicts(cwd));
+        const installDirCheck = checkInstallDir(cwd);
+        if (installDirCheck) results.push(installDirCheck);
+        results.push(...checkTargetAgents(cwd));
+        results.push(...checkSkillRefs(cwd));
+        results.push(...checkMonorepoVersions(cwd));
+    }
+    if (!skipNetwork) {
+        results.push(await checkNetwork('https://github.com'));
+        results.push(await checkNetwork('https://gitlab.com'));
+    }
+    return results;
+}
+const doctorCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('doctor').description('Diagnose reskill environment and check for issues').option('--json', 'Output as JSON').option('--skip-network', 'Skip network connectivity checks').action(async (options)=>{
+    const __dirname = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)((0, __WEBPACK_EXTERNAL_MODULE_node_url__.fileURLToPath)(import.meta.url));
+    const packageJson = JSON.parse((0, external_node_fs_.readFileSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(__dirname, '../../package.json'), 'utf-8'));
+    if (!options.json) logger_logger.log(__WEBPACK_EXTERNAL_MODULE_chalk__["default"].bold('\n🩺 Checking reskill environment...\n'));
+    const results = await runDoctorChecks({
+        cwd: process.cwd(),
+        packageName: packageJson.name,
+        packageVersion: packageJson.version,
+        skipNetwork: options.skipNetwork
+    });
+    if (options.json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    for (const result of results)printResult(result);
+    const errors = results.filter((r)=>'error' === r.status).length;
+    const warnings = results.filter((r)=>'warn' === r.status).length;
+    logger_logger.newline();
+    if (errors > 0) {
+        logger_logger.error(`Found ${errors} error${1 !== errors ? 's' : ''} and ${warnings} warning${1 !== warnings ? 's' : ''}`);
+        process.exit(1);
+    }
+    if (warnings > 0) logger_logger.warn(`Found ${warnings} warning${1 !== warnings ? 's' : ''}, but reskill should work`);
+    else logger_logger.success('All checks passed! reskill is ready to use.');
+});
 const infoCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('info').description('Show skill details').argument('<skill>', 'Skill name').option('-j, --json', 'Output as JSON').action((skillName, options)=>{
     const skillManager = new SkillManager();
     const info = skillManager.getInfo(skillName);
@@ -1840,29 +2446,29 @@ const infoCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('info').de
         }
     } else logger_logger.warn(`Skill ${skillName} is not installed`);
 });
-const initCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('init').description('Initialize a new skills.json configuration').option('-n, --name <name>', 'Project name').option('-r, --registry <registry>', 'Default registry', 'github').option('-d, --install-dir <dir>', 'Skills installation directory', '.skills').option('-y, --yes', 'Skip prompts and use defaults').action(async (options)=>{
+const DEFAULT_INSTALL_DIR = '.skills';
+function displayConfigSummary(installDir) {
+    logger_logger.success('Created skills.json');
+    logger_logger.newline();
+    logger_logger.log('Configuration:');
+    logger_logger.log(`  Install directory: ${installDir}`);
+    logger_logger.newline();
+    logger_logger.log('Next steps:');
+    logger_logger.log('  reskill install <skill>  Install a skill');
+    logger_logger.log('  reskill list             List installed skills');
+}
+const initCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('init').description('Initialize a new skills.json configuration').option('-d, --install-dir <dir>', 'Skills installation directory', DEFAULT_INSTALL_DIR).option('-y, --yes', 'Skip prompts and use defaults').action((options)=>{
     const configLoader = new ConfigLoader();
     if (configLoader.exists()) {
         logger_logger.warn('skills.json already exists');
         return;
     }
-    const config = configLoader.create({
-        name: options.name,
+    configLoader.create({
         defaults: {
-            registry: options.registry,
             installDir: options.installDir
         }
     });
-    logger_logger.success('Created skills.json');
-    logger_logger.newline();
-    logger_logger.log('Configuration:');
-    logger_logger.log(`  Name: ${config.name || '(not set)'}`);
-    logger_logger.log(`  Default registry: ${config.defaults?.registry}`);
-    logger_logger.log(`  Install directory: ${config.defaults?.installDir}`);
-    logger_logger.newline();
-    logger_logger.log('Next steps:');
-    logger_logger.log('  reskill install <skill>  Install a skill');
-    logger_logger.log('  reskill list             List installed skills');
+    displayConfigSummary(options.installDir);
 });
 function formatAgentNames(agentTypes, maxShow = 5) {
     const names = agentTypes.map((a)=>agents[a].displayName);
@@ -2327,9 +2933,9 @@ const updateCommand = new __WEBPACK_EXTERNAL_MODULE_commander__.Command('update'
 });
 if (maybeHandleCompletion()) process.exit(0);
 const cli_rslib_entry_dirname = (0, __WEBPACK_EXTERNAL_MODULE_node_path__.dirname)((0, __WEBPACK_EXTERNAL_MODULE_node_url__.fileURLToPath)(import.meta.url));
-const packageJson = JSON.parse((0, external_node_fs_.readFileSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(cli_rslib_entry_dirname, '../../package.json'), 'utf-8'));
+const cli_rslib_entry_packageJson = JSON.parse((0, external_node_fs_.readFileSync)((0, __WEBPACK_EXTERNAL_MODULE_node_path__.join)(cli_rslib_entry_dirname, '../../package.json'), 'utf-8'));
 const program = new __WEBPACK_EXTERNAL_MODULE_commander__.Command();
-program.name('reskill').description('AI Skills Package Manager - Git-based skills management for AI agents').version(packageJson.version);
+program.name('reskill').description('AI Skills Package Manager - Git-based skills management for AI agents').version(cli_rslib_entry_packageJson.version);
 program.addCommand(initCommand);
 program.addCommand(installCommand);
 program.addCommand(listCommand);
@@ -2338,7 +2944,8 @@ program.addCommand(updateCommand);
 program.addCommand(outdatedCommand);
 program.addCommand(uninstallCommand);
 program.addCommand(completionCommand);
-const updateCheckPromise = checkForUpdate(packageJson.name, packageJson.version);
+program.addCommand(doctorCommand);
+const updateCheckPromise = checkForUpdate(cli_rslib_entry_packageJson.name, cli_rslib_entry_packageJson.version);
 program.parseAsync().then(async ()=>{
     const result = await updateCheckPromise;
     if (result?.hasUpdate) logger_logger.log(formatUpdateMessage(result));