@a5c-ai/babysitter-sdk 0.0.169 → 0.0.170-staging.00aac85c

package/dist/cli/commands/skill.js

@@ -0,0 +1,869 @@
+"use strict";
+/**
+ * Skill, agent, and process discovery CLI commands.
+ * Replaces bash logic from skill-context-resolver.sh and skill-discovery.sh
+ */
+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.discoverSkillsInternal = discoverSkillsInternal;
+exports.handleSkillDiscover = handleSkillDiscover;
+exports.handleSkillFetchRemote = handleSkillFetchRemote;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const DEFAULT_CACHE_TTL = 300; // 5 minutes
+const CACHE_DIR = path.join(os.tmpdir(), 'babysitter-skill-cache');
+// ---------------------------------------------------------------------------
+// Frontmatter parsing
+// ---------------------------------------------------------------------------
+/**
+ * Parse scalar key:value pairs from YAML frontmatter.
+ * Ignores array items (lines starting with "- ").
+ */
+function parseFrontmatter(content) {
+    const lines = content.split('\n');
+    let inFrontmatter = false;
+    const fields = {};
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === '---') {
+            if (!inFrontmatter) {
+                inFrontmatter = true;
+                continue;
+            }
+            else {
+                break;
+            }
+        }
+        if (inFrontmatter && trimmed && !trimmed.startsWith('- ')) {
+            const colonIndex = trimmed.indexOf(':');
+            if (colonIndex > 0) {
+                const key = trimmed.slice(0, colonIndex).trim();
+                let value = trimmed.slice(colonIndex + 1).trim();
+                // Remove surrounding quotes
+                if ((value.startsWith('"') && value.endsWith('"')) ||
+                    (value.startsWith("'") && value.endsWith("'"))) {
+                    value = value.slice(1, -1);
+                }
+                if (value) {
+                    fields[key] = value;
+                }
+            }
+        }
+    }
+    return fields;
+}
+/**
+ * Parse YAML frontmatter from a SKILL.md file content.
+ */
+function parseSkillFrontmatter(content) {
+    const fields = parseFrontmatter(content);
+    const name = fields.name;
+    if (!name)
+        return null;
+    return {
+        name,
+        description: fields.description || '',
+        category: fields.category || fields.domain || '',
+    };
+}
+/**
+ * Parse YAML frontmatter from an AGENT.md file content.
+ */
+function parseAgentFrontmatter(content) {
+    const fields = parseFrontmatter(content);
+    const name = fields.name;
+    if (!name)
+        return null;
+    return {
+        name,
+        description: fields.description || '',
+        role: fields.role || undefined,
+        category: fields.category || fields.domain || '',
+    };
+}
+// ---------------------------------------------------------------------------
+// File scanning
+// ---------------------------------------------------------------------------
+/**
+ * Recursively find files matching a target name in a directory.
+ */
+async function findMarkdownFiles(dir, targetName, maxDepth = 5) {
+    const results = [];
+    async function scan(currentDir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await node_fs_1.promises.readdir(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(currentDir, entry.name);
+            if (entry.isFile() && entry.name === targetName) {
+                results.push(fullPath);
+            }
+            else if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                await scan(fullPath, depth + 1);
+            }
+        }
+    }
+    await scan(dir, 0);
+    return results;
+}
+/**
+ * Recursively find all SKILL.md files in a directory.
+ */
+async function findSkillFiles(dir, maxDepth = 5) {
+    return findMarkdownFiles(dir, 'SKILL.md', maxDepth);
+}
+/**
+ * Recursively find all AGENT.md files in a directory.
+ */
+async function findAgentFiles(dir, maxDepth = 5) {
+    return findMarkdownFiles(dir, 'AGENT.md', maxDepth);
+}
+/**
+ * Find *.js process files in a directory (non-recursive, depth 1 only).
+ */
+async function findProcessFiles(dir) {
+    try {
+        const entries = await node_fs_1.promises.readdir(dir, { withFileTypes: true });
+        return entries
+            .filter(e => e.isFile() && e.name.endsWith('.js'))
+            .map(e => path.join(dir, e.name));
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Directory scanning
+// ---------------------------------------------------------------------------
+/**
+ * Read and parse skills from a directory.
+ */
+async function scanSkillsDirectory(dir, source, maxFiles = 50) {
+    const skills = [];
+    const skillFiles = await findSkillFiles(dir);
+    for (const file of skillFiles.slice(0, maxFiles)) {
+        try {
+            const content = await node_fs_1.promises.readFile(file, 'utf8');
+            const parsed = parseSkillFrontmatter(content);
+            if (parsed) {
+                skills.push({
+                    ...parsed,
+                    description: parsed.description.slice(0, 80),
+                    source,
+                    file,
+                });
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    return skills;
+}
+/**
+ * Read and parse agents from a directory.
+ */
+async function scanAgentsDirectory(dir, source, maxFiles = 50) {
+    const agents = [];
+    const agentFiles = await findAgentFiles(dir);
+    for (const file of agentFiles.slice(0, maxFiles)) {
+        try {
+            const content = await node_fs_1.promises.readFile(file, 'utf8');
+            const parsed = parseAgentFrontmatter(content);
+            if (parsed) {
+                agents.push({
+                    ...parsed,
+                    description: parsed.description.slice(0, 80),
+                    source,
+                    file,
+                });
+            }
+        }
+        catch {
+            // Skip files that can't be read
+        }
+    }
+    return agents;
+}
+/**
+ * Read process file names from a directory and return ProcessMetadata.
+ */
+async function scanProcessesDirectory(dir, category, source) {
+    const jsFiles = await findProcessFiles(dir);
+    return jsFiles.map(file => ({
+        name: path.basename(file, '.js'),
+        category,
+        source,
+        file,
+    }));
+}
+// ---------------------------------------------------------------------------
+// Specialization scoping
+// ---------------------------------------------------------------------------
+/**
+ * Given a process path like "specializations/web-development/api-integration-testing.js"
+ * or a full path containing "specializations/<name>/", extract the specialization name.
+ */
+function extractSpecializationFromProcessPath(processPath) {
+    const normalized = processPath.replace(/\\/g, '/');
+    const match = normalized.match(/specializations\/([^/]+)/);
+    return match ? match[1] : null;
+}
+// ---------------------------------------------------------------------------
+// Cache
+// ---------------------------------------------------------------------------
+/**
+ * Get cache file path for a run ID.
+ */
+function getCachePath(runId, suffix) {
+    const safeId = runId || 'default';
+    return path.join(CACHE_DIR, `${safeId}.${suffix}`);
+}
+/**
+ * Read cached discovery results if valid.
+ * Returns null on cache miss or if the entry is missing the agents field (legacy format).
+ */
+async function readCache(runId, ttl) {
+    const cachePath = getCachePath(runId, 'json');
+    try {
+        const content = await node_fs_1.promises.readFile(cachePath, 'utf8');
+        const entry = JSON.parse(content);
+        // Require agents field to be present (invalidates old skills-only cache)
+        if (!Array.isArray(entry.agents))
+            return null;
+        const age = (Date.now() - entry.timestamp) / 1000;
+        if (age < ttl) {
+            return entry;
+        }
+    }
+    catch {
+        // Cache miss
+    }
+    return null;
+}
+/**
+ * Write cache entry.
+ */
+async function writeCache(runId, entry) {
+    try {
+        await node_fs_1.promises.mkdir(CACHE_DIR, { recursive: true });
+        const cachePath = getCachePath(runId, 'json');
+        await node_fs_1.promises.writeFile(cachePath, JSON.stringify(entry), 'utf8');
+        const summaryPath = getCachePath(runId, 'summary');
+        await node_fs_1.promises.writeFile(summaryPath, entry.summary, 'utf8');
+    }
+    catch {
+        // Cache write failure is non-fatal
+    }
+}
+// ---------------------------------------------------------------------------
+// Domain detection and sorting
+// ---------------------------------------------------------------------------
+/**
+ * Detect domain/category from run process definition.
+ */
+async function detectRunDomain(runId, runsDir) {
+    if (!runId)
+        return '';
+    const runDir = path.join(runsDir, runId);
+    try {
+        const files = await node_fs_1.promises.readdir(runDir);
+        const jsFile = files.find(f => f.endsWith('.js'));
+        if (jsFile) {
+            const content = await node_fs_1.promises.readFile(path.join(runDir, jsFile), 'utf8');
+            const match = content.match(/(?:domain|category|specialization)[:\s]*["']?([a-z-]+)/i);
+            if (match) {
+                return match[1].toLowerCase();
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return '';
+}
+/**
+ * Generate compact summary string from skills and agents.
+ */
+function generateSummary(skills, agents) {
+    const parts = [];
+    if (skills.length > 0) {
+        const skillPart = skills
+            .map(s => `${s.name} (${s.description.slice(0, 60) || 'no description'})`)
+            .join(', ');
+        parts.push(skillPart);
+    }
+    if (agents.length > 0) {
+        const agentPart = agents
+            .map(a => `${a.name} (${a.description.slice(0, 60) || 'no description'})`)
+            .join(', ');
+        parts.push(agentPart);
+    }
+    return parts.join(', ');
+}
+/**
+ * Deduplicate skills by name, keeping first occurrence.
+ */
+function deduplicateSkills(skills) {
+    const seen = new Set();
+    return skills.filter(s => {
+        if (seen.has(s.name))
+            return false;
+        seen.add(s.name);
+        return true;
+    });
+}
+/**
+ * Deduplicate agents by name, keeping first occurrence.
+ */
+function deduplicateAgents(agents) {
+    const seen = new Set();
+    return agents.filter(a => {
+        if (seen.has(a.name))
+            return false;
+        seen.add(a.name);
+        return true;
+    });
+}
+/**
+ * Sort skills by domain relevance if domain is provided.
+ */
+function sortSkillsByDomain(skills, domain) {
+    if (!domain)
+        return skills;
+    const lowerDomain = domain.toLowerCase();
+    return [...skills].sort((a, b) => {
+        const aMatch = a.category.toLowerCase().includes(lowerDomain) ? 0 : 1;
+        const bMatch = b.category.toLowerCase().includes(lowerDomain) ? 0 : 1;
+        return aMatch - bMatch;
+    });
+}
+/**
+ * Sort agents by domain relevance if domain is provided.
+ */
+function sortAgentsByDomain(agents, domain) {
+    if (!domain)
+        return agents;
+    const lowerDomain = domain.toLowerCase();
+    return [...agents].sort((a, b) => {
+        const aMatch = a.category.toLowerCase().includes(lowerDomain) ? 0 : 1;
+        const bMatch = b.category.toLowerCase().includes(lowerDomain) ? 0 : 1;
+        return aMatch - bMatch;
+    });
+}
+/**
+ * Internal discovery logic, extracted for reuse by other CLI commands
+ * (e.g. session:iteration-message, hookRun stop handler).
+ *
+ * Returns a structured result instead of writing to stdout.
+ */
+async function discoverSkillsInternal(options) {
+    const { pluginRoot, runId = '', cacheTtl = DEFAULT_CACHE_TTL, runsDir = '.a5c/runs', includeRemote = false, processPath, includeProcesses = false, } = options;
+    // Bypass cache when processPath is set (specialization-scoped queries)
+    if (!processPath) {
+        const cached = await readCache(runId, cacheTtl);
+        if (cached) {
+            return { skills: cached.skills, agents: cached.agents, summary: cached.summary, cached: true };
+        }
+    }
+    // Determine domain for sorting — from processPath or run metadata
+    let domain = '';
+    if (processPath) {
+        domain = extractSpecializationFromProcessPath(processPath) ?? '';
+    }
+    if (!domain) {
+        domain = await detectRunDomain(runId, runsDir);
+    }
+    const specializationsDir = path.join(pluginRoot, 'skills', 'babysit', 'process', 'specializations');
+    // ------------------------------------------------------------------
+    // Skills
+    // ------------------------------------------------------------------
+    const allSkills = [];
+    // 1. Scan specializations directory
+    const specializationSkills = await scanSkillsDirectory(specializationsDir, 'local');
+    allSkills.push(...specializationSkills);
+    // 2. Scan plugin-level skills
+    const pluginSkillsDir = path.join(pluginRoot, 'skills');
+    const pluginSkills = await scanSkillsDirectory(pluginSkillsDir, 'local-plugin');
+    const filteredPluginSkills = pluginSkills.filter(s => !s.file?.includes('/specializations/'));
+    allSkills.push(...filteredPluginSkills);
+    // 3. Scan repo-level skills (.a5c/skills)
+    const repoSkillsDir = '.a5c/skills';
+    try {
+        await node_fs_1.promises.access(repoSkillsDir);
+        const repoSkills = await scanSkillsDirectory(repoSkillsDir, 'local');
+        allSkills.push(...repoSkills);
+    }
+    catch {
+        // Repo skills dir doesn't exist, skip
+    }
+    // 4. Optionally fetch remote skills
+    if (includeRemote) {
+        const remoteSkills = await fetchRemoteSkillSources(pluginRoot);
+        allSkills.push(...remoteSkills);
+    }
+    // ------------------------------------------------------------------
+    // Agents
+    // ------------------------------------------------------------------
+    const allAgents = [];
+    // 1. Scan specializations directory for agents
+    const specializationAgents = await scanAgentsDirectory(specializationsDir, 'local');
+    allAgents.push(...specializationAgents);
+    // 2. Scan repo-level agents (.a5c/agents)
+    const repoAgentsDir = '.a5c/agents';
+    try {
+        await node_fs_1.promises.access(repoAgentsDir);
+        const repoAgents = await scanAgentsDirectory(repoAgentsDir, 'local');
+        allAgents.push(...repoAgents);
+    }
+    catch {
+        // Repo agents dir doesn't exist, skip
+    }
+    // ------------------------------------------------------------------
+    // Processes (only when explicitly requested — not for hooks/session)
+    // ------------------------------------------------------------------
+    let processes;
+    if (includeProcesses) {
+        const allProcesses = [];
+        // 1. Specialization processes
+        try {
+            const specDirs = await node_fs_1.promises.readdir(specializationsDir, { withFileTypes: true });
+            for (const entry of specDirs) {
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    const specDir = path.join(specializationsDir, entry.name);
+                    const procs = await scanProcessesDirectory(specDir, entry.name, 'library');
+                    allProcesses.push(...procs);
+                }
+            }
+        }
+        catch {
+            // Specializations dir may not exist
+        }
+        // 2. Methodology processes
+        const methodologiesDir = path.join(pluginRoot, 'skills', 'babysit', 'process', 'methodologies');
+        try {
+            // Top-level methodology files
+            const topProcs = await scanProcessesDirectory(methodologiesDir, 'methodologies', 'library');
+            allProcesses.push(...topProcs);
+            // Methodology subdirectories
+            const methodDirs = await node_fs_1.promises.readdir(methodologiesDir, { withFileTypes: true });
+            for (const entry of methodDirs) {
+                if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                    const methodDir = path.join(methodologiesDir, entry.name);
+                    const procs = await scanProcessesDirectory(methodDir, entry.name, 'library');
+                    allProcesses.push(...procs);
+                }
+            }
+        }
+        catch {
+            // Methodologies dir may not exist
+        }
+        // 3. Repo-level processes (.a5c/processes)
+        const repoProcessesDir = '.a5c/processes';
+        try {
+            await node_fs_1.promises.access(repoProcessesDir);
+            const repoProcs = await scanProcessesDirectory(repoProcessesDir, 'project', 'repo');
+            allProcesses.push(...repoProcs);
+        }
+        catch {
+            // Repo processes dir doesn't exist
+        }
+        processes = allProcesses;
+    }
+    // ------------------------------------------------------------------
+    // Specialization scoping
+    // ------------------------------------------------------------------
+    let skills = deduplicateSkills(allSkills);
+    let agents = deduplicateAgents(allAgents);
+    if (processPath && domain) {
+        // Filter to matching specialization
+        const lowerDomain = domain.toLowerCase();
+        const matchesSpec = (filePath) => {
+            if (!filePath)
+                return false;
+            const normalized = filePath.replace(/\\/g, '/').toLowerCase();
+            return normalized.includes(`/specializations/${lowerDomain}/`);
+        };
+        skills = skills.filter(s => matchesSpec(s.file));
+        agents = agents.filter(a => matchesSpec(a.file));
+        if (processes) {
+            processes = processes.filter(p => p.category.toLowerCase() === lowerDomain);
+        }
+    }
+    else {
+        // Sort by domain relevance
+        skills = sortSkillsByDomain(skills, domain);
+        agents = sortAgentsByDomain(agents, domain);
+    }
+    // Limit for context window efficiency
+    skills = skills.slice(0, 30);
+    agents = agents.slice(0, 30);
+    // Generate summary
+    const summary = generateSummary(skills, agents);
+    // Cache results (only for non-scoped queries)
+    if (!processPath) {
+        const cacheEntry = {
+            skills,
+            agents,
+            summary,
+            timestamp: Date.now(),
+        };
+        await writeCache(runId, cacheEntry);
+    }
+    return { skills, agents, processes, summary, cached: false };
+}
+// ---------------------------------------------------------------------------
+// Remote sources
+// ---------------------------------------------------------------------------
+/**
+ * Fetch skills from remote sources defined in .a5c/skill-sources.json
+ * and a default GitHub source.
+ */
+async function fetchRemoteSkillSources(_pluginRoot) {
+    const remoteSkills = [];
+    const sources = [
+        { type: 'github', url: 'https://github.com/MaTriXy/babysitter/tree/main/plugins/babysitter/skills' },
+    ];
+    // Check for additional sources in .a5c/skill-sources.json
+    try {
+        const content = await node_fs_1.promises.readFile('.a5c/skill-sources.json', 'utf8');
+        const parsed = JSON.parse(content);
+        if (parsed.sources && Array.isArray(parsed.sources)) {
+            for (const s of parsed.sources) {
+                if ((s.type === 'github' || s.type === 'well-known') && typeof s.url === 'string') {
+                    sources.push({ type: s.type, url: s.url });
+                }
+            }
+        }
+    }
+    catch {
+        // No external sources file, that's fine
+    }
+    for (const source of sources) {
+        try {
+            let skills = [];
+            if (source.type === 'github') {
+                skills = await discoverGitHub(source.url);
+            }
+            else if (source.type === 'well-known') {
+                skills = await discoverWellKnown(source.url);
+            }
+            remoteSkills.push(...skills);
+        }
+        catch {
+            // Skip failed remote sources
+        }
+    }
+    return remoteSkills;
+}
+// ---------------------------------------------------------------------------
+// CLI command handlers
+// ---------------------------------------------------------------------------
+/**
+ * Handle skill:discover command.
+ * Scans for available skills, agents, and processes in plugin and repo directories.
+ * Thin wrapper around discoverSkillsInternal that handles CLI I/O.
+ */
+async function handleSkillDiscover(args) {
+    const { pluginRoot, runId, cacheTtl, runsDir, json, includeRemote, summaryOnly, processPath, } = args;
+    if (!pluginRoot) {
+        const error = { error: 'MISSING_PLUGIN_ROOT', message: '--plugin-root is required' };
+        if (json) {
+            console.error(JSON.stringify(error));
+        }
+        else {
+            console.error('Error: --plugin-root is required');
+        }
+        return 1;
+    }
+    const result = await discoverSkillsInternal({
+        pluginRoot,
+        runId,
+        cacheTtl,
+        runsDir,
+        includeRemote,
+        processPath,
+        includeProcesses: true,
+    });
+    if (summaryOnly) {
+        console.log(result.summary || '');
+        return 0;
+    }
+    if (json) {
+        console.log(JSON.stringify({
+            skills: result.skills,
+            agents: result.agents,
+            processes: result.processes,
+            summary: result.summary,
+            cached: result.cached,
+        }));
+    }
+    else {
+        if (result.skills.length === 0 && result.agents.length === 0) {
+            console.log('(no skills or agents found)');
+        }
+        else {
+            if (result.skills.length > 0) {
+                console.log(`Skills (${result.skills.length}):`);
+                for (const skill of result.skills) {
+                    console.log(`  - ${skill.name}: ${skill.description || '(no description)'}${skill.file ? ` [${skill.file}]` : ''}`);
+                }
+            }
+            if (result.agents.length > 0) {
+                console.log(`Agents (${result.agents.length}):`);
+                for (const agent of result.agents) {
+                    console.log(`  - ${agent.name}: ${agent.description || '(no description)'}${agent.file ? ` [${agent.file}]` : ''}`);
+                }
+            }
+            if (result.processes && result.processes.length > 0) {
+                console.log(`Processes (${result.processes.length}):`);
+                for (const proc of result.processes) {
+                    console.log(`  - ${proc.name} [${proc.category}]: ${proc.file}`);
+                }
+            }
+        }
+    }
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Remote discovery helpers
+// ---------------------------------------------------------------------------
+/**
+ * Convert GitHub web URL to API URL.
+ */
+function githubWebToApi(url) {
+    // https://github.com/OWNER/REPO/tree/BRANCH/PATH
+    const treeMatch = url.match(/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)/);
+    if (treeMatch) {
+        const [, owner, repo, branch, treePath] = treeMatch;
+        return {
+            apiUrl: `https://api.github.com/repos/${owner}/${repo}/contents/${treePath}?ref=${branch}`,
+            rawBase: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${treePath}`,
+        };
+    }
+    // https://github.com/OWNER/REPO
+    const repoMatch = url.match(/github\.com\/([^/]+)\/([^/]+)\/?$/);
+    if (repoMatch) {
+        const [, owner, repo] = repoMatch;
+        return {
+            apiUrl: `https://api.github.com/repos/${owner}/${repo}/contents/skills?ref=main`,
+            rawBase: `https://raw.githubusercontent.com/${owner}/${repo}/main/skills`,
+        };
+    }
+    return null;
+}
+/**
+ * Fetch URL with timeout.
+ */
+async function fetchWithTimeout(url, timeout = 10000) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+            headers: {
+                'User-Agent': 'babysitter-sdk',
+            },
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok)
+            return null;
+        return await response.text();
+    }
+    catch {
+        clearTimeout(timeoutId);
+        return null;
+    }
+}
+/**
+ * Discover skills from GitHub repository.
+ */
+async function discoverGitHub(url) {
+    const parsed = githubWebToApi(url);
+    if (!parsed)
+        return [];
+    const { apiUrl, rawBase } = parsed;
+    const skills = [];
+    const listingText = await fetchWithTimeout(apiUrl);
+    if (!listingText)
+        return [];
+    let listing;
+    try {
+        listing = JSON.parse(listingText);
+    }
+    catch {
+        return [];
+    }
+    const dirs = listing.filter(e => e.type === 'dir').map(e => e.name);
+    const skillFile = listing.find(e => e.name === 'SKILL.md');
+    if (skillFile?.download_url) {
+        const content = await fetchWithTimeout(skillFile.download_url);
+        if (content) {
+            const parsed = parseSkillFrontmatter(content);
+            if (parsed) {
+                skills.push({
+                    ...parsed,
+                    source: 'remote',
+                    url,
+                });
+            }
+        }
+        return skills;
+    }
+    let count = 0;
+    for (const dir of dirs) {
+        if (count >= 20)
+            break;
+        count++;
+        const skillUrl = `${rawBase}/${dir}/SKILL.md`;
+        const content = await fetchWithTimeout(skillUrl);
+        if (content) {
+            const parsed = parseSkillFrontmatter(content);
+            if (parsed) {
+                skills.push({
+                    ...parsed,
+                    source: 'remote',
+                    url: skillUrl,
+                });
+            }
+        }
+    }
+    return skills;
+}
+/**
+ * Discover skills from well-known endpoint.
+ */
+async function discoverWellKnown(url) {
+    const baseUrl = url.replace(/\/$/, '');
+    const skills = [];
+    let indexUrl = `${baseUrl}/.well-known/skills/index.json`;
+    let content = await fetchWithTimeout(indexUrl);
+    if (!content) {
+        const hostMatch = baseUrl.match(/^https?:\/\/([^/]+)/);
+        if (hostMatch) {
+            indexUrl = `https://${hostMatch[1]}/.well-known/skills/index.json`;
+            content = await fetchWithTimeout(indexUrl);
+        }
+    }
+    if (!content)
+        return [];
+    try {
+        const index = JSON.parse(content);
+        if (index.skills) {
+            for (const s of index.skills) {
+                skills.push({
+                    name: s.name,
+                    description: s.description || '',
+                    category: '',
+                    source: 'remote',
+                    url: baseUrl,
+                });
+            }
+        }
+    }
+    catch {
+        // Invalid JSON
+    }
+    return skills;
+}
+/**
+ * Handle skill:fetch-remote command.
+ * Fetches skills from external sources (GitHub or well-known).
+ */
+async function handleSkillFetchRemote(args) {
+    const { sourceType, url, json } = args;
+    if (!sourceType) {
+        const error = { error: 'MISSING_SOURCE_TYPE', message: '--source-type is required (github or well-known)' };
+        if (json) {
+            console.error(JSON.stringify(error));
+        }
+        else {
+            console.error('Error: --source-type is required (github or well-known)');
+        }
+        return 1;
+    }
+    if (!url) {
+        const error = { error: 'MISSING_URL', message: '--url is required' };
+        if (json) {
+            console.error(JSON.stringify(error));
+        }
+        else {
+            console.error('Error: --url is required');
+        }
+        return 1;
+    }
+    let skills = [];
+    switch (sourceType) {
+        case 'github':
+            skills = await discoverGitHub(url);
+            break;
+        case 'well-known':
+            skills = await discoverWellKnown(url);
+            break;
+        default: {
+            const _exhaustive = sourceType;
+            const unknownType = _exhaustive;
+            const error = { error: 'INVALID_SOURCE_TYPE', message: `Unknown source type: ${unknownType}` };
+            if (json) {
+                console.error(JSON.stringify(error));
+            }
+            else {
+                console.error(`Error: Unknown source type: ${unknownType}`);
+            }
+            return 1;
+        }
+    }
+    if (json) {
+        console.log(JSON.stringify({ skills }));
+    }
+    else {
+        if (skills.length === 0) {
+            console.log('[]');
+        }
+        else {
+            for (const skill of skills) {
+                console.log(`- ${skill.name}: ${skill.description || '(no description)'}`);
+            }
+        }
+    }
+    return 0;
+}