cli4ai 1.2.0 → 1.2.2

package/dist/commands/browse.js

@@ -0,0 +1,382 @@
+/**
+ * cli4ai browse - Interactive package browser
+ */
+import { spawnSync } from 'child_process';
+import { platform } from 'os';
+import { log, outputError } from '../lib/cli.js';
+import { getNpmGlobalPackages, getGlobalPackages, getLocalPackages } from '../core/config.js';
+// Windows-safe cli4ai command (npm creates .cmd wrappers on Windows)
+const cli4aiCmd = platform() === 'win32' ? 'cli4ai.cmd' : 'cli4ai';
+// ANSI codes
+const RESET = '\x1B[0m';
+const BOLD = '\x1B[1m';
+const DIM = '\x1B[2m';
+const ITALIC = '\x1B[3m';
+const CYAN = '\x1B[36m';
+const GREEN = '\x1B[32m';
+const YELLOW = '\x1B[33m';
+const WHITE = '\x1B[37m';
+const MAGENTA = '\x1B[35m';
+const BLUE = '\x1B[34m';
+const BG_CYAN = '\x1B[46m';
+const BG_BLUE = '\x1B[44m';
+// Box drawing
+const BOX = {
+    TL: '╭', TR: '╮', BL: '╰', BR: '╯',
+    H: '─', V: '│',
+    LT: '├', RT: '┤', TT: '┬', BT: '┴', X: '┼'
+};
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+/**
+ * Fetch @cli4ai packages from npm registry API (fast!)
+ */
+async function fetchPackages() {
+    try {
+        const response = await fetch('https://registry.npmjs.org/-/v1/search?text=@cli4ai&size=100', {
+            headers: { 'Accept': 'application/json' }
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        // Filter to only @cli4ai packages (exclude @cli4ai/lib)
+        return data.objects
+            .map(o => o.package)
+            .filter(p => p.name.startsWith('@cli4ai/') && p.name !== '@cli4ai/lib')
+            .map(p => ({
+            name: p.name,
+            version: p.version,
+            description: p.description || '',
+            keywords: p.keywords || []
+        }));
+    }
+    catch (err) {
+        outputError('NETWORK_ERROR', 'Failed to fetch packages from npm', {
+            hint: 'Check your internet connection'
+        });
+        return [];
+    }
+}
+/**
+ * Get set of all installed package names (from all sources)
+ */
+function getInstalledPackageNames() {
+    const installed = new Set();
+    // Check npm global @cli4ai packages
+    for (const pkg of getNpmGlobalPackages()) {
+        installed.add(pkg.name);
+    }
+    // Check cli4ai global packages
+    for (const pkg of getGlobalPackages()) {
+        installed.add(pkg.name);
+    }
+    // Check local packages
+    for (const pkg of getLocalPackages(process.cwd())) {
+        installed.add(pkg.name);
+    }
+    return installed;
+}
+/**
+ * Pad string to width
+ */
+function pad(str, width) {
+    if (str.length >= width)
+        return str.slice(0, width);
+    return str + ' '.repeat(width - str.length);
+}
+/**
+ * Center string in width
+ */
+function center(str, width) {
+    const stripped = str.replace(/\x1B\[[0-9;]*m/g, '');
+    const padding = Math.max(0, width - stripped.length);
+    const left = Math.floor(padding / 2);
+    const right = padding - left;
+    return ' '.repeat(left) + str + ' '.repeat(right);
+}
+/**
+ * Loading animation
+ */
+async function showLoadingAnimation() {
+    const frames = ['[•_•]', '[•_•]', '[°_°]', '[•_•]'];
+    const text = 'Fetching packages';
+    for (let i = 0; i < 8; i++) {
+        const dots = '.'.repeat((i % 3) + 1).padEnd(3);
+        process.stderr.write(`\r  ${CYAN}${frames[i % frames.length]}${RESET} ${DIM}${text}${dots}${RESET}`);
+        await sleep(150);
+    }
+    process.stderr.write('\r\x1B[K');
+}
+/**
+ * Interactive multi-select UI with table layout
+ */
+async function multiSelect(items) {
+    if (!process.stdin.isTTY) {
+        outputError('INVALID_INPUT', 'Interactive mode requires a TTY', {
+            hint: 'Use "cli4ai add <package>" for non-interactive installation'
+        });
+    }
+    const selected = new Set();
+    let cursor = 0;
+    const WIDTH = 72;
+    const render = () => {
+        // Clear screen and move to top
+        process.stderr.write('\x1B[2J\x1B[H');
+        // Robot header
+        log('');
+        log(`  ${CYAN}${BOLD}[•_•]${RESET} ${BOLD}cli4ai${RESET} ${DIM}─${RESET} ${WHITE}Package Browser${RESET}`);
+        log(`        ${DIM}cli4ai.com${RESET}`);
+        log('');
+        // Box top
+        log(`  ${CYAN}${BOX.TL}${BOX.H.repeat(WIDTH)}${BOX.TR}${RESET}`);
+        // Controls bar
+        const controls = `${DIM}↑↓${RESET} move  ${DIM}space${RESET} select  ${DIM}a${RESET} all  ${DIM}enter${RESET} install  ${DIM}q${RESET} quit`;
+        log(`  ${CYAN}${BOX.V}${RESET} ${controls}${' '.repeat(WIDTH - 55)}${CYAN}${BOX.V}${RESET}`);
+        // Separator
+        log(`  ${CYAN}${BOX.LT}${BOX.H.repeat(WIDTH)}${BOX.RT}${RESET}`);
+        // Package list
+        items.forEach((item, i) => {
+            const isCursor = i === cursor;
+            const isSelected = selected.has(i);
+            const name = item.name.replace('@cli4ai/', '');
+            // Checkbox
+            let checkbox;
+            if (isSelected) {
+                checkbox = `${GREEN}◉${RESET}`;
+            }
+            else {
+                checkbox = `${DIM}○${RESET}`;
+            }
+            // Status badge
+            let badge = '';
+            if (item.installed) {
+                badge = ` ${GREEN}●${RESET}`;
+            }
+            // Name with cursor indicator
+            let line;
+            if (isCursor) {
+                line = `  ${CYAN}▸${RESET} ${checkbox}  ${BOLD}${CYAN}${pad(name, 14)}${RESET} ${DIM}v${item.version}${RESET}${badge}`;
+            }
+            else {
+                line = `    ${checkbox}  ${WHITE}${pad(name, 14)}${RESET} ${DIM}v${item.version}${RESET}${badge}`;
+            }
+            // Pad to fit box
+            const stripped = line.replace(/\x1B\[[0-9;]*m/g, '');
+            const padding = WIDTH - stripped.length + 2;
+            log(`  ${CYAN}${BOX.V}${RESET}${line}${' '.repeat(Math.max(0, padding))}${CYAN}${BOX.V}${RESET}`);
+            // Description for selected item
+            if (isCursor && item.description) {
+                const desc = item.description.slice(0, WIDTH - 8);
+                log(`  ${CYAN}${BOX.V}${RESET}        ${DIM}${desc}${RESET}${' '.repeat(Math.max(0, WIDTH - desc.length - 6))}${CYAN}${BOX.V}${RESET}`);
+                // Keywords
+                if (item.keywords.length > 0) {
+                    const tags = item.keywords.slice(0, 4).map(k => `${MAGENTA}#${k}${RESET}`).join(' ');
+                    const tagsStripped = tags.replace(/\x1B\[[0-9;]*m/g, '');
+                    log(`  ${CYAN}${BOX.V}${RESET}        ${tags}${' '.repeat(Math.max(0, WIDTH - tagsStripped.length - 6))}${CYAN}${BOX.V}${RESET}`);
+                }
+                log(`  ${CYAN}${BOX.V}${RESET}${' '.repeat(WIDTH)}${CYAN}${BOX.V}${RESET}`);
+            }
+        });
+        // Box bottom
+        log(`  ${CYAN}${BOX.BL}${BOX.H.repeat(WIDTH)}${BOX.BR}${RESET}`);
+        // Footer
+        log('');
+        const selectedCount = selected.size;
+        const installedCount = items.filter(i => i.installed).length;
+        if (selectedCount > 0) {
+            log(`  ${GREEN}◉${RESET} ${BOLD}${selectedCount}${RESET} selected for installation`);
+        }
+        log(`  ${GREEN}●${RESET} ${DIM}${installedCount} already installed${RESET}`);
+        log('');
+    };
+    return new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        render();
+        const onKeypress = (key) => {
+            // Handle arrow keys (escape sequences)
+            if (key === '\x1B[A' || key === 'k') {
+                // Up arrow or k
+                cursor = Math.max(0, cursor - 1);
+                render();
+            }
+            else if (key === '\x1B[B' || key === 'j') {
+                // Down arrow or j
+                cursor = Math.min(items.length - 1, cursor + 1);
+                render();
+            }
+            else if (key === ' ') {
+                // Space - toggle selection
+                if (selected.has(cursor)) {
+                    selected.delete(cursor);
+                }
+                else {
+                    selected.add(cursor);
+                }
+                render();
+            }
+            else if (key === '\r' || key === '\n') {
+                // Enter - confirm
+                process.stdin.setRawMode(false);
+                process.stdin.removeListener('data', onKeypress);
+                process.stdin.pause();
+                process.stderr.write('\x1B[2J\x1B[H'); // Clear screen
+                const selectedPackages = Array.from(selected).map(i => items[i].name);
+                resolve(selectedPackages);
+            }
+            else if (key === 'q' || key === '\x1B' || key === '\x03') {
+                // q, Escape, or Ctrl+C - quit
+                process.stdin.setRawMode(false);
+                process.stdin.removeListener('data', onKeypress);
+                process.stdin.pause();
+                process.stderr.write('\x1B[2J\x1B[H'); // Clear screen
+                resolve([]);
+            }
+            else if (key === 'a') {
+                // Select all
+                items.forEach((_, i) => selected.add(i));
+                render();
+            }
+            else if (key === 'n') {
+                // Select none
+                selected.clear();
+                render();
+            }
+        };
+        process.stdin.on('data', onKeypress);
+    });
+}
+/**
+ * Ask user for install scope (global or local)
+ */
+async function askInstallScope() {
+    return new Promise((resolve) => {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        let cursor = 0; // 0 = global, 1 = local
+        const options = [
+            { key: 'global', label: 'Global', desc: 'Available everywhere (~/.cli4ai/)' },
+            { key: 'local', label: 'Project', desc: 'Only in this directory (./.cli4ai/)' }
+        ];
+        const render = () => {
+            process.stderr.write('\x1B[2J\x1B[H'); // Clear screen
+            log('');
+            log(`  ${CYAN}${BOLD}[•_•]${RESET} ${BOLD}Where to install?${RESET}`);
+            log('');
+            options.forEach((opt, i) => {
+                const isSelected = i === cursor;
+                const bullet = isSelected ? `${CYAN}▸${RESET}` : ' ';
+                const label = isSelected ? `${BOLD}${WHITE}${opt.label}${RESET}` : `${DIM}${opt.label}${RESET}`;
+                const desc = isSelected ? `${opt.desc}` : `${DIM}${opt.desc}${RESET}`;
+                log(`  ${bullet} ${label}  ${DIM}─${RESET}  ${desc}`);
+            });
+            log('');
+            log(`  ${DIM}↑↓ select  enter confirm  q cancel${RESET}`);
+            log('');
+        };
+        render();
+        const onKeypress = (key) => {
+            if (key === '\x1B[A' || key === 'k') {
+                cursor = Math.max(0, cursor - 1);
+                render();
+            }
+            else if (key === '\x1B[B' || key === 'j') {
+                cursor = Math.min(options.length - 1, cursor + 1);
+                render();
+            }
+            else if (key === '\r' || key === '\n') {
+                process.stdin.setRawMode(false);
+                process.stdin.removeListener('data', onKeypress);
+                process.stdin.pause();
+                resolve(cursor === 0 ? 'global' : 'local');
+            }
+            else if (key === 'q' || key === '\x1B' || key === '\x03') {
+                process.stdin.setRawMode(false);
+                process.stdin.removeListener('data', onKeypress);
+                process.stdin.pause();
+                resolve(null);
+            }
+        };
+        process.stdin.on('data', onKeypress);
+    });
+}
+/**
+ * Install packages with animation
+ */
+async function installPackages(packages, scope) {
+    if (packages.length === 0) {
+        log(`  ${DIM}[•_•] No packages selected. Bye!${RESET}\n`);
+        return;
+    }
+    const scopeFlag = scope === 'global' ? '-g' : '';
+    const scopeLabel = scope === 'global' ? 'globally' : 'locally';
+    log('');
+    log(`  ${CYAN}[•_•]${RESET} ${BOLD}Installing ${packages.length} package${packages.length !== 1 ? 's' : ''} ${scopeLabel}...${RESET}`);
+    log('');
+    for (const pkg of packages) {
+        const shortName = pkg.replace('@cli4ai/', '');
+        // Animated install
+        const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+        let frameIndex = 0;
+        const spinner = setInterval(() => {
+            process.stderr.write(`\r  ${CYAN}${frames[frameIndex]}${RESET} Installing ${BOLD}${shortName}${RESET}...`);
+            frameIndex = (frameIndex + 1) % frames.length;
+        }, 80);
+        try {
+            // Use cli4ai add command for proper integration
+            // Use spawnSync with argument array to prevent command injection
+            const addArgs = ['add', pkg];
+            if (scopeFlag)
+                addArgs.push(scopeFlag);
+            addArgs.push('-y');
+            const result = spawnSync(cli4aiCmd, addArgs, { stdio: 'pipe' });
+            clearInterval(spinner);
+            if (result.status === 0) {
+                process.stderr.write(`\r  ${GREEN}✓${RESET} ${BOLD}${shortName}${RESET} installed                    \n`);
+            }
+            else {
+                process.stderr.write(`\r  ${YELLOW}✗${RESET} ${shortName} failed                         \n`);
+            }
+        }
+        catch (err) {
+            clearInterval(spinner);
+            process.stderr.write(`\r  ${YELLOW}✗${RESET} ${shortName} failed                         \n`);
+        }
+    }
+    log('');
+    log(`  ${GREEN}[°_°]${RESET} ${BOLD}Done!${RESET}`);
+    log(`        ${DIM}Run with:${RESET} cli4ai run ${CYAN}<package>${RESET} ${CYAN}<command>${RESET}`);
+    log('');
+}
+export async function browseCommand() {
+    log('');
+    await showLoadingAnimation();
+    const packages = await fetchPackages();
+    if (packages.length === 0) {
+        log(`  ${YELLOW}[•_•]${RESET} ${DIM}No packages found on npm.${RESET}\n`);
+        return;
+    }
+    // Check installation status
+    const installedNames = getInstalledPackageNames();
+    const items = packages.map(pkg => ({
+        name: pkg.name,
+        version: pkg.version,
+        description: pkg.description,
+        keywords: pkg.keywords,
+        installed: installedNames.has(pkg.name.replace('@cli4ai/', ''))
+    }));
+    // Show interactive selector
+    const selected = await multiSelect(items);
+    // Ask for scope and install selected packages
+    if (selected.length > 0) {
+        const scope = await askInstallScope();
+        if (scope) {
+            await installPackages(selected, scope);
+        }
+        else {
+            log(`  ${DIM}[•_•] Installation cancelled. Bye!${RESET}\n`);
+        }
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,10 @@
+/**
+ * cli4ai config - Configuration management
+ */
+interface ConfigOptions {
+    list?: boolean;
+    addRegistry?: string;
+    removeRegistry?: string;
+}
+export declare function configCommand(key: string | undefined, value: string | undefined, options: ConfigOptions): Promise<void>;
+export {};

package/dist/commands/config.js

@@ -0,0 +1,121 @@
+/**
+ * cli4ai config - Configuration management
+ */
+import { output, outputError, log } from '../lib/cli.js';
+import { loadConfig, updateConfig, addLocalRegistry, removeLocalRegistry, CLI4AI_HOME, CONFIG_FILE } from '../core/config.js';
+export async function configCommand(key, value, options) {
+    const config = loadConfig();
+    // Handle --add-registry
+    if (options.addRegistry) {
+        addLocalRegistry(options.addRegistry);
+        output({
+            action: 'add-registry',
+            path: options.addRegistry,
+            localRegistries: loadConfig().localRegistries
+        });
+        return;
+    }
+    // Handle --remove-registry
+    if (options.removeRegistry) {
+        removeLocalRegistry(options.removeRegistry);
+        output({
+            action: 'remove-registry',
+            path: options.removeRegistry,
+            localRegistries: loadConfig().localRegistries
+        });
+        return;
+    }
+    // Handle --list or no args
+    if (options.list || (!key && !value)) {
+        output({
+            configFile: CONFIG_FILE,
+            cli4aiHome: CLI4AI_HOME,
+            config
+        });
+        return;
+    }
+    // Get specific key
+    if (key && !value) {
+        const val = getNestedValue(config, key);
+        if (val === undefined) {
+            outputError('NOT_FOUND', `Config key not found: ${key}`, {
+                availableKeys: Object.keys(config)
+            });
+        }
+        output({ [key]: val });
+        return;
+    }
+    // Set key=value
+    if (key && value) {
+        const parsed = parseValue(value);
+        if (key === 'registry') {
+            validateRegistryUrl(parsed);
+        }
+        const updated = updateConfig((current) => setNestedValue(current, key, parsed));
+        log(`Set ${key} = ${value}`);
+        output({
+            action: 'set',
+            key,
+            value: getNestedValue(updated, key)
+        });
+        return;
+    }
+}
+function validateRegistryUrl(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        outputError('INVALID_INPUT', 'Registry must be a non-empty URL string', {
+            got: value
+        });
+    }
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        outputError('INVALID_INPUT', `Invalid registry URL: ${value}`, {
+            hint: 'Use a valid http(s) URL, e.g. https://registry.cli4ai.com'
+        });
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        outputError('INVALID_INPUT', `Invalid registry URL protocol: ${url.protocol}`, {
+            hint: 'Registry URL must start with http:// or https://'
+        });
+    }
+}
+function getNestedValue(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        if (typeof current !== 'object')
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function setNestedValue(obj, path, value) {
+    const parts = path.split('.');
+    // Create a mutable copy that we can safely modify
+    const result = JSON.parse(JSON.stringify(obj));
+    let current = result;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (typeof current[part] !== 'object' || current[part] === null) {
+            current[part] = {};
+        }
+        current = current[part];
+    }
+    current[parts[parts.length - 1]] = value;
+    return result;
+}
+function parseValue(value) {
+    // Try to parse as JSON
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        // Return as string
+        return value;
+    }
+}

package/dist/commands/info.d.ts

@@ -0,0 +1,9 @@
+/**
+ * cli4ai info - Show package information
+ */
+interface InfoOptions {
+    versions?: boolean;
+    remote?: string;
+}
+export declare function infoCommand(packageName: string, options: InfoOptions): Promise<void>;
+export {};

package/dist/commands/info.js

@@ -0,0 +1,125 @@
+/**
+ * cli4ai info - Show package information
+ */
+import { resolve } from 'path';
+import { spawnSync } from 'child_process';
+import { platform } from 'os';
+import { output, outputError, log } from '../lib/cli.js';
+// Windows-safe npm command
+const npmCmd = platform() === 'win32' ? 'npm.cmd' : 'npm';
+import { findPackage, loadConfig } from '../core/config.js';
+import { loadManifest, tryLoadManifest } from '../core/manifest.js';
+import { remotePackageInfo, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
+export async function infoCommand(packageName, options) {
+    // Handle remote info
+    if (options.remote) {
+        try {
+            const info = await remotePackageInfo(options.remote, packageName);
+            if (!info) {
+                outputError('NOT_FOUND', `Package not found on remote: ${packageName}`, {
+                    remote: options.remote
+                });
+                return;
+            }
+            output({
+                remote: options.remote,
+                name: info.name,
+                version: info.version,
+                description: info.description,
+                commands: info.commands ? Object.keys(info.commands) : [],
+                commandDetails: info.commands
+            });
+        }
+        catch (err) {
+            if (err instanceof RemoteConnectionError) {
+                outputError('NETWORK_ERROR', err.message, { remote: err.remoteName, url: err.url });
+            }
+            else if (err instanceof RemoteApiError) {
+                outputError(err.code, err.message, { remote: err.remoteName, details: err.details });
+            }
+            else {
+                throw err;
+            }
+        }
+        return;
+    }
+    // First check if it's installed
+    const installed = findPackage(packageName, process.cwd());
+    if (installed) {
+        const manifest = loadManifest(installed.path);
+        outputPackageInfo(manifest, installed.path, true);
+        return;
+    }
+    // Search in local registries
+    const config = loadConfig();
+    for (const registryPath of config.localRegistries) {
+        const pkgPath = resolve(registryPath, packageName);
+        const manifest = tryLoadManifest(pkgPath);
+        if (manifest) {
+            outputPackageInfo(manifest, pkgPath, false);
+            return;
+        }
+    }
+    // Try npm with @cli4ai scope
+    const scopedName = packageName.startsWith('@cli4ai/') ? packageName : `@cli4ai/${packageName}`;
+    try {
+        log(`Fetching ${scopedName} from npm...`);
+        // Use spawnSync with argument array to prevent command injection
+        const result = spawnSync(npmCmd, ['view', scopedName, '--json'], {
+            encoding: 'utf-8',
+            timeout: 10000,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        if (result.status === 0 && result.stdout) {
+            const pkg = JSON.parse(result.stdout);
+            outputNpmPackageInfo(pkg, packageName);
+            return;
+        }
+    }
+    catch {
+        // npm fetch failed
+    }
+    outputError('NOT_FOUND', `Package not found: ${packageName}`, {
+        hint: `Tried @cli4ai/${packageName} on npm. Check the package name or add a local registry with "cli4ai config --add-registry <path>"`
+    });
+}
+function outputPackageInfo(manifest, path, installed) {
+    output({
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description,
+        author: manifest.author,
+        license: manifest.license,
+        runtime: manifest.runtime || 'node',
+        entry: manifest.entry,
+        path,
+        installed,
+        commands: manifest.commands ? Object.keys(manifest.commands) : [],
+        commandDetails: manifest.commands,
+        env: manifest.env,
+        peerDependencies: manifest.peerDependencies,
+        mcp: manifest.mcp,
+        repository: manifest.repository,
+        homepage: manifest.homepage,
+        keywords: manifest.keywords
+    });
+}
+function outputNpmPackageInfo(pkg, requestedName) {
+    const shortName = typeof pkg.name === 'string' ? pkg.name.replace('@cli4ai/', '') : requestedName;
+    output({
+        name: shortName,
+        npmName: pkg.name,
+        version: pkg.version,
+        description: pkg.description,
+        author: typeof pkg.author === 'object' ? pkg.author?.name : pkg.author,
+        license: pkg.license,
+        source: 'npm',
+        installed: false,
+        install: `cli4ai add ${shortName} -g`,
+        repository: pkg.repository,
+        homepage: pkg.homepage,
+        keywords: pkg.keywords,
+        dependencies: pkg.dependencies,
+        versions: pkg.versions
+    });
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,10 @@
+/**
+ * cli4ai init - Create a new tool project
+ */
+interface InitOptions {
+    template?: string;
+    runtime?: 'node' | 'bun';
+    yes?: boolean;
+}
+export declare function initCommand(name: string | undefined, options: InitOptions): Promise<void>;
+export {};