cli4ai 1.1.5 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cli4ai",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "description": "The package manager for AI CLI tools - cli4ai.com",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -93,6 +93,7 @@ export function createProgram(): Command {
     .alias('ls')
     .description('List installed packages')
     .option('-g, --global', 'List global packages')
+    .option('-r, --remote <name>', 'List packages on a remote server')
     .option('--json', 'Output as JSON')
     .action(withErrorHandling(listCommand));
 
@@ -143,12 +144,14 @@ Remote Execution:
     .command('info <package>')
     .description('Show package information')
     .option('--versions', 'Show all available versions')
+    .option('-r, --remote <name>', 'Get info from a remote server')
     .action(withErrorHandling(infoCommand));
 
   program
     .command('search <query>')
     .description('Search for packages')
     .option('-l, --limit <n>', 'Max results', '20')
+    .option('-r, --remote <name>', 'Search packages on a remote server')
     .action(withErrorHandling(searchCommand));
 
   program

package/src/commands/info.ts

@@ -8,12 +8,43 @@ import { output, outputError, log } from '../lib/cli.js';
 import { findPackage, loadConfig } from '../core/config.js';
 import { loadManifest, tryLoadManifest, type Manifest } from '../core/manifest.js';
 import { existsSync } from 'fs';
+import { remotePackageInfo, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
 
 interface InfoOptions {
   versions?: boolean;
+  remote?: string;
 }
 
 export async function infoCommand(packageName: string, options: InfoOptions): Promise<void> {
+  // 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());
 

package/src/commands/list.ts

@@ -2,22 +2,45 @@
  * cli4ai list - Show installed packages
  */
 
-import { output } from '../lib/cli.js';
+import { output, outputError } from '../lib/cli.js';
 import {
   getGlobalPackages,
   getLocalPackages,
   getNpmGlobalPackages,
   type InstalledPackage
 } from '../core/config.js';
+import { remoteListPackages, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
 
 interface ListOptions {
   global?: boolean;
   json?: boolean;
+  remote?: string;
 }
 
 type PackageWithScope = InstalledPackage & { scope: 'local' | 'cli4ai' | 'npm' };
 
 export async function listCommand(options: ListOptions): Promise<void> {
+  // Handle remote listing
+  if (options.remote) {
+    try {
+      const result = await remoteListPackages(options.remote);
+      output({
+        remote: options.remote,
+        packages: result.packages,
+        count: result.packages.length
+      });
+    } 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;
+  }
+
   let packages: PackageWithScope[];
 
   // Get all package sources

package/src/commands/search.ts

@@ -5,12 +5,14 @@
 import { readdirSync, existsSync } from 'fs';
 import { resolve } from 'path';
 import { spawnSync } from 'child_process';
-import { output, log } from '../lib/cli.js';
+import { output, outputError, log } from '../lib/cli.js';
 import { loadConfig, getGlobalPackages, getLocalPackages } from '../core/config.js';
 import { tryLoadManifest, type Manifest } from '../core/manifest.js';
+import { remoteListPackages, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
 
 interface SearchOptions {
   limit?: string;
+  remote?: string;
 }
 
 interface SearchResult {
@@ -26,6 +28,41 @@ export async function searchCommand(query: string, options: SearchOptions): Prom
   const limit = parseInt(options.limit || '20', 10);
   const queryLower = query.toLowerCase();
 
+  // Handle remote search
+  if (options.remote) {
+    try {
+      const packageList = await remoteListPackages(options.remote);
+      const results = packageList.packages
+        .filter(pkg =>
+          pkg.name.toLowerCase().includes(queryLower) ||
+          pkg.path.toLowerCase().includes(queryLower)
+        )
+        .slice(0, limit)
+        .map(pkg => ({
+          name: pkg.name,
+          version: pkg.version,
+          source: 'remote' as const,
+          installed: true
+        }));
+
+      output({
+        remote: options.remote,
+        query,
+        results,
+        count: results.length
+      });
+    } 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;
+  }
+
   const results: SearchResult[] = [];
   const seen = new Set<string>();