@rbbtsn0w/adg 0.1.0-alpha.1 → 0.1.0-beta.2

package/dist/vendor/skills/src/cli.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
+import { basename, join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { runAdd, parseAddOptions, initTelemetry } from "./add.js";
+import { runFind } from "./find.js";
+import { runInstallFromLock } from "./install.js";
+import { runList } from "./list.js";
+import { removeCommand, parseRemoveOptions } from "./remove.js";
+import { runSync, parseSyncOptions } from "./sync.js";
+import { flushTelemetry } from "./telemetry.js";
+import { isRunningInAgent } from "./detect-agent.js";
+import { runUpdate } from "./update.js";
+import { runUse, parseUseOptions } from "./use.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+    try {
+        const pkgPath = join(__dirname, '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+const VERSION = getVersion();
+initTelemetry(VERSION);
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+// 256-color grays - visible on both light and dark backgrounds
+const DIM = '\x1b[38;5;102m'; // darker gray for secondary text
+const TEXT = '\x1b[38;5;145m'; // lighter gray for primary text
+const LOGO_LINES = [
+    '███████╗██╗  ██╗██╗██╗     ██╗     ███████╗',
+    '██╔════╝██║ ██╔╝██║██║     ██║     ██╔════╝',
+    '███████╗█████╔╝ ██║██║     ██║     ███████╗',
+    '╚════██║██╔═██╗ ██║██║     ██║     ╚════██║',
+    '███████║██║  ██╗██║███████╗███████╗███████║',
+    '╚══════╝╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚══════╝',
+];
+// 256-color middle grays - visible on both light and dark backgrounds
+const GRAYS = [
+    '\x1b[38;5;250m', // lighter gray
+    '\x1b[38;5;248m',
+    '\x1b[38;5;245m', // mid gray
+    '\x1b[38;5;243m',
+    '\x1b[38;5;240m',
+    '\x1b[38;5;238m', // darker gray
+];
+function showLogo() {
+    console.log();
+    LOGO_LINES.forEach((line, i) => {
+        console.log(`${GRAYS[i]}${line}${RESET}`);
+    });
+}
+function showBanner() {
+    showLogo();
+    console.log();
+    console.log(`${DIM}The open agent skills ecosystem${RESET}`);
+    console.log();
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills add ${DIM}<package>${RESET}        ${DIM}Add a new skill${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills use ${DIM}<package>@<skill>${RESET} ${DIM}Use a skill without installing${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills remove${RESET}               ${DIM}Remove installed skills${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills list${RESET}                 ${DIM}List installed skills${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills find ${DIM}[query]${RESET}         ${DIM}Search for skills${RESET}`);
+    console.log();
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills update${RESET}               ${DIM}Update installed skills${RESET}`);
+    console.log();
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills experimental_install${RESET} ${DIM}Restore from skills-lock.json${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills init ${DIM}[name]${RESET}          ${DIM}Create a new skill${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx skills experimental_sync${RESET}    ${DIM}Sync skills from node_modules${RESET}`);
+    console.log();
+    console.log(`${DIM}try:${RESET} npx skills add vercel-labs/agent-skills`);
+    console.log();
+    console.log(`Discover more skills at ${TEXT}https://skills.sh/${RESET}`);
+    console.log();
+}
+function showHelp() {
+    console.log(`
+${BOLD}Usage:${RESET} skills <command> [options]
+
+${BOLD}Manage Skills:${RESET}
+  add <package>        Add a skill package (alias: a)
+                       e.g. vercel-labs/agent-skills
+                            https://github.com/vercel-labs/agent-skills
+  use <package>@<skill>
+                       Generate a prompt for using one skill without installing it
+  remove [skills]      Remove installed skills
+  list, ls             List installed skills
+  find [query]         Search for skills interactively
+
+${BOLD}Updates:${RESET}
+  update [skills...]   Update skills to latest versions (alias: upgrade)
+
+${BOLD}Update Options:${RESET}
+  -g, --global           Update global skills only
+  -p, --project          Update project skills only
+  -y, --yes              Skip scope prompt (auto-detect: project if in a project, else global)
+
+${BOLD}Project:${RESET}
+  experimental_install Restore skills from skills-lock.json
+  init [name]          Initialize a skill (creates <name>/SKILL.md or ./SKILL.md)
+  experimental_sync    Sync skills from node_modules into agent directories
+
+${BOLD}Add Options:${RESET}
+  -g, --global           Install skill globally (user-level) instead of project-level
+  -a, --agent <agents>   Specify agents to install to (use '*' for all agents)
+  -s, --skill <skills>   Specify skill names to install (use '*' for all skills)
+  -l, --list             List available skills in the repository without installing
+  -y, --yes              Skip confirmation prompts
+  --copy                 Copy files instead of symlinking to agent directories
+  --all                  Shorthand for --skill '*' --agent '*' -y
+  --full-depth           Search all subdirectories even when a root SKILL.md exists
+
+${BOLD}Use Options:${RESET}
+  -s, --skill <skill>    Specify the skill to use
+  -a, --agent <agent>    Start one supported agent interactively
+  --full-depth           Search all subdirectories even when a root SKILL.md exists
+  --dangerously-accept-openclaw-risks
+                         Allow unverified OpenClaw community skills
+
+${BOLD}Remove Options:${RESET}
+  -g, --global           Remove from global scope
+  -a, --agent <agents>   Remove from specific agents (use '*' for all agents)
+  -s, --skill <skills>   Specify skills to remove (use '*' for all skills)
+  -y, --yes              Skip confirmation prompts
+  --all                  Shorthand for --skill '*' --agent '*' -y
+  
+${BOLD}Experimental Sync Options:${RESET}
+  -a, --agent <agents>   Specify agents to install to (use '*' for all agents)
+  -y, --yes              Skip confirmation prompts
+
+${BOLD}List Options:${RESET}
+  -g, --global           List global skills (default: project)
+  -a, --agent <agents>   Filter by specific agents
+  --json                 Output as JSON (machine-readable, no ANSI codes)
+
+${BOLD}Options:${RESET}
+  --help, -h        Show this help message
+  --version, -v     Show version number
+
+${BOLD}Examples:${RESET}
+  ${DIM}$${RESET} skills add vercel-labs/agent-skills
+  ${DIM}$${RESET} skills use vercel-labs/agent-skills@vercel-optimize | claude
+  ${DIM}$${RESET} skills use vercel-labs/agent-skills --skill vercel-optimize --agent claude-code
+  ${DIM}$${RESET} skills add vercel-labs/agent-skills -g
+  ${DIM}$${RESET} skills add vercel-labs/agent-skills --agent claude-code cursor
+  ${DIM}$${RESET} skills add vercel-labs/agent-skills --skill pr-review commit
+  ${DIM}$${RESET} skills remove                        ${DIM}# interactive remove${RESET}
+  ${DIM}$${RESET} skills remove web-design             ${DIM}# remove by name${RESET}
+  ${DIM}$${RESET} skills rm --global frontend-design
+  ${DIM}$${RESET} skills list                          ${DIM}# list project skills${RESET}
+  ${DIM}$${RESET} skills ls -g                         ${DIM}# list global skills${RESET}
+  ${DIM}$${RESET} skills ls -a claude-code             ${DIM}# filter by agent${RESET}
+  ${DIM}$${RESET} skills ls --json                      ${DIM}# JSON output${RESET}
+  ${DIM}$${RESET} skills find                          ${DIM}# interactive search${RESET}
+  ${DIM}$${RESET} skills find typescript               ${DIM}# search by keyword${RESET}
+  ${DIM}$${RESET} skills update
+  ${DIM}$${RESET} skills update my-skill             ${DIM}# update a single skill${RESET}
+  ${DIM}$${RESET} skills update -g                    ${DIM}# update global skills only${RESET}
+  ${DIM}$${RESET} skills experimental_install            ${DIM}# restore from skills-lock.json${RESET}
+  ${DIM}$${RESET} skills init my-skill
+  ${DIM}$${RESET} skills experimental_sync              ${DIM}# sync from node_modules${RESET}
+  ${DIM}$${RESET} skills experimental_sync -y           ${DIM}# sync without prompts${RESET}
+
+Discover more skills at ${TEXT}https://skills.sh/${RESET}
+`);
+}
+function showRemoveHelp() {
+    console.log(`
+${BOLD}Usage:${RESET} skills remove [skills...] [options]
+
+${BOLD}Description:${RESET}
+  Remove installed skills from agents. If no skill names are provided,
+  an interactive selection menu will be shown.
+
+${BOLD}Arguments:${RESET}
+  skills            Optional skill names to remove (space-separated)
+
+${BOLD}Options:${RESET}
+  -g, --global       Remove from global scope (~/) instead of project scope
+  -a, --agent        Remove from specific agents (use '*' for all agents)
+  -s, --skill        Specify skills to remove (use '*' for all skills)
+  -y, --yes          Skip confirmation prompts
+  --all              Shorthand for --skill '*' --agent '*' -y
+
+${BOLD}Examples:${RESET}
+  ${DIM}$${RESET} skills remove                           ${DIM}# interactive selection${RESET}
+  ${DIM}$${RESET} skills remove my-skill                   ${DIM}# remove specific skill${RESET}
+  ${DIM}$${RESET} skills remove skill1 skill2 -y           ${DIM}# remove multiple skills${RESET}
+  ${DIM}$${RESET} skills remove --global my-skill          ${DIM}# remove from global scope${RESET}
+  ${DIM}$${RESET} skills rm --agent claude-code my-skill   ${DIM}# remove from specific agent${RESET}
+  ${DIM}$${RESET} skills remove --all                      ${DIM}# remove all skills${RESET}
+  ${DIM}$${RESET} skills remove --skill '*' -a cursor      ${DIM}# remove all skills from cursor${RESET}
+
+Discover more skills at ${TEXT}https://skills.sh/${RESET}
+`);
+}
+function runInit(args) {
+    const cwd = process.cwd();
+    const skillName = args[0] || basename(cwd);
+    const hasName = args[0] !== undefined;
+    const skillDir = hasName ? join(cwd, skillName) : cwd;
+    const skillFile = join(skillDir, 'SKILL.md');
+    const displayPath = hasName ? `${skillName}/SKILL.md` : 'SKILL.md';
+    if (existsSync(skillFile)) {
+        console.log(`${TEXT}Skill already exists at ${DIM}${displayPath}${RESET}`);
+        return;
+    }
+    if (hasName) {
+        mkdirSync(skillDir, { recursive: true });
+    }
+    const skillContent = `---
+name: ${skillName}
+description: A brief description of what this skill does
+---
+
+# ${skillName}
+
+Instructions for the agent to follow when this skill is activated.
+
+## When to use
+
+Describe when this skill should be used.
+
+## Instructions
+
+1. First step
+2. Second step
+3. Additional steps as needed
+`;
+    writeFileSync(skillFile, skillContent);
+    console.log(`${TEXT}Initialized skill: ${DIM}${skillName}${RESET}`);
+    console.log();
+    console.log(`${DIM}Created:${RESET}`);
+    console.log(`  ${displayPath}`);
+    console.log();
+    console.log(`${DIM}Next steps:${RESET}`);
+    console.log(`  1. Edit ${TEXT}${displayPath}${RESET} to define your skill instructions`);
+    console.log(`  2. Update the ${TEXT}name${RESET} and ${TEXT}description${RESET} in the frontmatter`);
+    console.log();
+    console.log(`${DIM}Publishing:${RESET}`);
+    console.log(`  ${DIM}GitHub:${RESET}  Push to a repo, then ${TEXT}npx skills add <owner>/<repo>${RESET}`);
+    console.log(`  ${DIM}URL:${RESET}     Host the file, then ${TEXT}npx skills add https://example.com/${displayPath}${RESET}`);
+    console.log();
+    console.log(`Browse existing skills for inspiration at ${TEXT}https://skills.sh/${RESET}`);
+    console.log();
+}
+// ============================================
+// Main
+// ============================================
+async function main() {
+    const args = process.argv.slice(2);
+    const inAgent = await isRunningInAgent();
+    if (args.length === 0) {
+        if (!inAgent) {
+            showBanner();
+        }
+        return;
+    }
+    const command = args[0];
+    const restArgs = args.slice(1);
+    switch (command) {
+        case 'find':
+        case 'search':
+        case 'f':
+        case 's':
+            if (!inAgent)
+                showLogo();
+            console.log();
+            await runFind(restArgs);
+            break;
+        case 'init':
+            if (!inAgent)
+                showLogo();
+            console.log();
+            runInit(restArgs);
+            break;
+        case 'experimental_install': {
+            if (!inAgent)
+                showLogo();
+            await runInstallFromLock(restArgs);
+            break;
+        }
+        case 'i':
+        case 'install':
+        case 'a':
+        case 'add': {
+            if (!inAgent)
+                showLogo();
+            const { source: addSource, options: addOpts } = parseAddOptions(restArgs);
+            await runAdd(addSource, addOpts);
+            break;
+        }
+        case 'use': {
+            const { source: useSource, options: useOptions, errors: useErrors, } = parseUseOptions(restArgs);
+            await runUse(useSource, useOptions, useErrors);
+            break;
+        }
+        case 'remove':
+        case 'rm':
+        case 'r':
+            // Check for --help or -h flag
+            if (restArgs.includes('--help') || restArgs.includes('-h')) {
+                showRemoveHelp();
+                break;
+            }
+            const { skills, options: removeOptions } = parseRemoveOptions(restArgs);
+            await removeCommand(skills, removeOptions);
+            break;
+        case 'experimental_sync': {
+            if (!inAgent)
+                showLogo();
+            const { options: syncOptions } = parseSyncOptions(restArgs);
+            await runSync(restArgs, syncOptions);
+            break;
+        }
+        case 'list':
+        case 'ls':
+            await runList(restArgs);
+            break;
+        case 'check':
+        case 'update':
+        case 'upgrade':
+            await runUpdate(restArgs);
+            break;
+        case '--help':
+        case '-h':
+            showHelp();
+            break;
+        case '--version':
+        case '-v':
+            console.log(VERSION);
+            break;
+        default:
+            console.log(`Unknown command: ${command}`);
+            console.log(`Run ${BOLD}skills --help${RESET} for usage.`);
+    }
+}
+main().finally(() => flushTelemetry().then(() => process.exit(0)));

package/dist/vendor/skills/src/constants.js

@@ -0,0 +1,3 @@
+export const AGENTS_DIR = '.agents';
+export const SKILLS_SUBDIR = 'skills';
+export const UNIVERSAL_SKILLS_DIR = '.agents/skills';

package/dist/vendor/skills/src/detect-agent.js

@@ -0,0 +1,56 @@
+import { determineAgent } from '@vercel/detect-agent';
+import { setDetectedAgent } from "./telemetry.js";
+let cachedResult = null;
+/**
+ * Map from @vercel/detect-agent names to skills-cli AgentType identifiers.
+ * Only includes agents that exist in both systems.
+ */
+const agentNameToType = {
+    cursor: 'cursor',
+    'cursor-cli': 'cursor',
+    claude: 'claude-code',
+    cowork: 'claude-code',
+    devin: 'universal', // Devin not in skills-cli agent list, use universal
+    replit: 'replit',
+    gemini: 'gemini-cli',
+    codex: 'codex',
+    antigravity: 'antigravity',
+    'augment-cli': 'augment',
+    opencode: 'opencode',
+    'github-copilot': 'github-copilot',
+};
+/**
+ * Detect if the CLI is being run inside an AI agent environment.
+ * Results are cached after the first call. Also updates telemetry with the agent name.
+ */
+export async function detectAgent() {
+    if (cachedResult)
+        return cachedResult;
+    cachedResult = await determineAgent();
+    if (cachedResult.isAgent) {
+        setDetectedAgent(cachedResult.agent.name);
+    }
+    return cachedResult;
+}
+/**
+ * Returns true if the CLI is running inside a detected AI agent.
+ * When true, the CLI should skip interactive prompts and use sensible defaults.
+ */
+export async function isRunningInAgent() {
+    const result = await detectAgent();
+    return result.isAgent;
+}
+/**
+ * Returns the name of the detected agent, or null if not running in an agent.
+ */
+export async function getAgentName() {
+    const result = await detectAgent();
+    return result.isAgent ? result.agent.name : null;
+}
+/**
+ * Maps a detected agent name to the corresponding skills-cli AgentType.
+ * Returns null if the agent can't be mapped to a specific skills-cli agent.
+ */
+export function getAgentType(agentName) {
+    return agentNameToType[agentName] ?? null;
+}

package/dist/vendor/skills/src/find.js

@@ -0,0 +1,294 @@
+import * as readline from 'readline';
+import { runAdd, parseAddOptions } from "./add.js";
+import { sanitizeMetadata } from "./sanitize.js";
+import { track } from "./telemetry.js";
+import { isRepoPrivate } from "./source-parser.js";
+import { isRunningInAgent } from "./detect-agent.js";
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[38;5;102m';
+const TEXT = '\x1b[38;5;145m';
+const CYAN = '\x1b[36m';
+const MAGENTA = '\x1b[35m';
+const YELLOW = '\x1b[33m';
+// API endpoint for skills search
+const SEARCH_API_BASE = process.env.SKILLS_API_URL || 'https://skills.sh';
+function formatInstalls(count) {
+    if (!count || count <= 0)
+        return '';
+    if (count >= 1_000_000)
+        return `${(count / 1_000_000).toFixed(1).replace(/\.0$/, '')}M installs`;
+    if (count >= 1_000)
+        return `${(count / 1_000).toFixed(1).replace(/\.0$/, '')}K installs`;
+    return `${count} install${count === 1 ? '' : 's'}`;
+}
+// Search via API
+export async function searchSkillsAPI(query) {
+    try {
+        const url = `${SEARCH_API_BASE}/api/search?q=${encodeURIComponent(query)}&limit=10`;
+        const res = await fetch(url);
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        return data.skills
+            .map((skill) => ({
+            name: sanitizeMetadata(skill.name),
+            slug: sanitizeMetadata(skill.id),
+            source: sanitizeMetadata(skill.source || ''),
+            installs: skill.installs,
+        }))
+            .sort((a, b) => (b.installs || 0) - (a.installs || 0));
+    }
+    catch {
+        return [];
+    }
+}
+// ANSI escape codes for terminal control
+const HIDE_CURSOR = '\x1b[?25l';
+const SHOW_CURSOR = '\x1b[?25h';
+const CLEAR_DOWN = '\x1b[J';
+const MOVE_UP = (n) => `\x1b[${n}A`;
+const MOVE_TO_COL = (n) => `\x1b[${n}G`;
+// Custom fzf-style search prompt using raw readline
+async function runSearchPrompt(initialQuery = '') {
+    let results = [];
+    let selectedIndex = 0;
+    let query = initialQuery;
+    let loading = false;
+    let debounceTimer = null;
+    let lastRenderedLines = 0;
+    // Enable raw mode for keypress events
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    // Setup readline for keypress events but don't let it echo
+    readline.emitKeypressEvents(process.stdin);
+    // Resume stdin to start receiving events
+    process.stdin.resume();
+    // Hide cursor during selection
+    process.stdout.write(HIDE_CURSOR);
+    function render() {
+        // Move cursor up to overwrite previous render
+        if (lastRenderedLines > 0) {
+            process.stdout.write(MOVE_UP(lastRenderedLines) + MOVE_TO_COL(1));
+        }
+        // Clear from cursor to end of screen (removes ghost trails)
+        process.stdout.write(CLEAR_DOWN);
+        const lines = [];
+        // Search input line with cursor
+        const cursor = `${BOLD}_${RESET}`;
+        lines.push(`${TEXT}Search skills:${RESET} ${query}${cursor}`);
+        lines.push('');
+        // Results - keep showing existing results while loading new ones
+        if (!query || query.length < 2) {
+            lines.push(`${DIM}Start typing to search (min 2 chars)${RESET}`);
+        }
+        else if (results.length === 0 && loading) {
+            lines.push(`${DIM}Searching...${RESET}`);
+        }
+        else if (results.length === 0) {
+            lines.push(`${DIM}No skills found${RESET}`);
+        }
+        else {
+            const maxVisible = 8;
+            const visible = results.slice(0, maxVisible);
+            for (let i = 0; i < visible.length; i++) {
+                const skill = visible[i];
+                const isSelected = i === selectedIndex;
+                const arrow = isSelected ? `${BOLD}>${RESET}` : ' ';
+                const name = isSelected ? `${BOLD}${skill.name}${RESET}` : `${TEXT}${skill.name}${RESET}`;
+                const source = skill.source ? ` ${DIM}${skill.source}${RESET}` : '';
+                const installs = formatInstalls(skill.installs);
+                const installsBadge = installs ? ` ${CYAN}${installs}${RESET}` : '';
+                const loadingIndicator = loading && i === 0 ? ` ${DIM}...${RESET}` : '';
+                lines.push(`  ${arrow} ${name}${source}${installsBadge}${loadingIndicator}`);
+            }
+        }
+        lines.push('');
+        lines.push(`${DIM}up/down navigate | enter select | esc cancel${RESET}`);
+        // Write each line
+        for (const line of lines) {
+            process.stdout.write(line + '\n');
+        }
+        lastRenderedLines = lines.length;
+    }
+    function triggerSearch(q) {
+        // Always clear any pending debounce timer
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = null;
+        }
+        // Always reset loading state when starting a new search
+        loading = false;
+        if (!q || q.length < 2) {
+            results = [];
+            selectedIndex = 0;
+            render();
+            return;
+        }
+        // Use API search for all queries (debounced)
+        loading = true;
+        render();
+        // Adaptive debounce: shorter queries = longer wait (user still typing)
+        // 2 chars: 250ms, 3 chars: 200ms, 4 chars: 150ms, 5+ chars: 150ms
+        const debounceMs = Math.max(150, 350 - q.length * 50);
+        debounceTimer = setTimeout(async () => {
+            try {
+                results = await searchSkillsAPI(q);
+                selectedIndex = 0;
+            }
+            catch {
+                results = [];
+            }
+            finally {
+                loading = false;
+                debounceTimer = null;
+                render();
+            }
+        }, debounceMs);
+    }
+    // Trigger initial search if there's a query, then render
+    if (initialQuery) {
+        triggerSearch(initialQuery);
+    }
+    render();
+    return new Promise((resolve) => {
+        function cleanup() {
+            process.stdin.removeListener('keypress', handleKeypress);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdout.write(SHOW_CURSOR);
+            // Pause stdin to fully release it for child processes
+            process.stdin.pause();
+        }
+        function handleKeypress(_ch, key) {
+            if (!key)
+                return;
+            if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+                // Cancel
+                cleanup();
+                resolve(null);
+                return;
+            }
+            if (key.name === 'return') {
+                // Submit
+                cleanup();
+                resolve(results[selectedIndex] || null);
+                return;
+            }
+            if (key.name === 'up') {
+                selectedIndex = Math.max(0, selectedIndex - 1);
+                render();
+                return;
+            }
+            if (key.name === 'down') {
+                selectedIndex = Math.min(Math.max(0, results.length - 1), selectedIndex + 1);
+                render();
+                return;
+            }
+            if (key.name === 'backspace') {
+                if (query.length > 0) {
+                    query = query.slice(0, -1);
+                    triggerSearch(query);
+                }
+                return;
+            }
+            // Regular character input
+            if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+                const char = key.sequence;
+                if (char >= ' ' && char <= '~') {
+                    query += char;
+                    triggerSearch(query);
+                }
+            }
+        }
+        process.stdin.on('keypress', handleKeypress);
+    });
+}
+// Parse owner/repo from a package string (for the find command)
+function getOwnerRepoFromString(pkg) {
+    // Handle owner/repo or owner/repo@skill
+    const atIndex = pkg.lastIndexOf('@');
+    const repoPath = atIndex > 0 ? pkg.slice(0, atIndex) : pkg;
+    const match = repoPath.match(/^([^/]+)\/([^/]+)$/);
+    if (match) {
+        return { owner: match[1], repo: match[2] };
+    }
+    return null;
+}
+async function isRepoPublic(owner, repo) {
+    const isPrivate = await isRepoPrivate(owner, repo);
+    // Return true only if we know it's public (isPrivate === false)
+    // Return false if private or unable to determine
+    return isPrivate === false;
+}
+export async function runFind(args) {
+    const query = args.join(' ');
+    const isNonInteractive = !process.stdin.isTTY;
+    const agentTip = `${DIM}Tip: if running in a coding agent, follow these steps:${RESET}
+${DIM}  1) npx skills find [query]${RESET}
+${DIM}  2) npx skills add <owner/repo@skill>${RESET}`;
+    // Non-interactive mode: just print results and exit
+    if (query) {
+        const results = await searchSkillsAPI(query);
+        // Track telemetry for non-interactive search
+        track({
+            event: 'find',
+            query,
+            resultCount: String(results.length),
+        });
+        if (results.length === 0) {
+            console.log(`${DIM}No skills found for "${query}"${RESET}`);
+            return;
+        }
+        console.log(`${DIM}Install with${RESET} npx skills add <owner/repo@skill>`);
+        console.log();
+        for (const skill of results.slice(0, 6)) {
+            const pkg = skill.source || skill.slug;
+            const installs = formatInstalls(skill.installs);
+            console.log(`${TEXT}${pkg}@${skill.name}${RESET}${installs ? ` ${CYAN}${installs}${RESET}` : ''}`);
+            console.log(`${DIM}└ https://skills.sh/${skill.slug}${RESET}`);
+            console.log();
+        }
+        return;
+    }
+    // Skip interactive search when running inside an AI agent or non-TTY
+    if (isNonInteractive || (await isRunningInAgent())) {
+        console.log(agentTip);
+        console.log();
+        console.log(`${DIM}Usage: npx skills find <query>${RESET}`);
+        return;
+    }
+    const selected = await runSearchPrompt();
+    // Track telemetry for interactive search
+    track({
+        event: 'find',
+        query: '',
+        resultCount: selected ? '1' : '0',
+        interactive: '1',
+    });
+    if (!selected) {
+        console.log(`${DIM}Search cancelled${RESET}`);
+        console.log();
+        return;
+    }
+    // Use source (owner/repo) and skill name for installation
+    const pkg = selected.source || selected.slug;
+    const skillName = selected.name;
+    console.log();
+    console.log(`${TEXT}Installing ${BOLD}${skillName}${RESET} from ${DIM}${pkg}${RESET}...`);
+    console.log();
+    // Run add directly since we're in the same CLI
+    const { source, options } = parseAddOptions([pkg, '--skill', skillName]);
+    await runAdd(source, options);
+    console.log();
+    const info = getOwnerRepoFromString(pkg);
+    if (info && (await isRepoPublic(info.owner, info.repo))) {
+        console.log(`${DIM}View the skill at${RESET} ${TEXT}https://skills.sh/${selected.slug}${RESET}`);
+    }
+    else {
+        console.log(`${DIM}Discover more skills at${RESET} ${TEXT}https://skills.sh${RESET}`);
+    }
+    console.log();
+}