cli4ai 1.2.0 → 1.2.1

package/src/commands/list.ts

@@ -1,95 +0,0 @@
-/**
- * cli4ai list - Show installed packages
- */
-
-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
-  const local = getLocalPackages(process.cwd());
-  const cli4aiGlobal = getGlobalPackages();
-  const npmGlobal = getNpmGlobalPackages();
-
-  if (options.global) {
-    // Only global packages (cli4ai + npm)
-    const cli4aiNames = new Set(cli4aiGlobal.map(p => p.name));
-    packages = [
-      ...cli4aiGlobal.map(p => ({ ...p, scope: 'cli4ai' as const })),
-      ...npmGlobal.filter(p => !cli4aiNames.has(p.name)).map(p => ({ ...p, scope: 'npm' as const }))
-    ];
-  } else {
-    // All packages: local > cli4ai global > npm global
-    const seenNames = new Set<string>();
-
-    packages = [];
-
-    for (const pkg of local) {
-      packages.push({ ...pkg, scope: 'local' as const });
-      seenNames.add(pkg.name);
-    }
-
-    for (const pkg of cli4aiGlobal) {
-      if (!seenNames.has(pkg.name)) {
-        packages.push({ ...pkg, scope: 'cli4ai' as const });
-        seenNames.add(pkg.name);
-      }
-    }
-
-    for (const pkg of npmGlobal) {
-      if (!seenNames.has(pkg.name)) {
-        packages.push({ ...pkg, scope: 'npm' as const });
-        seenNames.add(pkg.name);
-      }
-    }
-  }
-
-  output({
-    packages: packages.map(p => ({
-      name: p.name,
-      version: p.version,
-      path: p.path,
-      source: p.source,
-      scope: p.scope
-    })),
-    count: packages.length,
-    location: options.global ? 'global' : 'all'
-  });
-}

package/src/commands/mcp-config.ts

@@ -1,69 +0,0 @@
-/**
- * cli4ai mcp-config - Generate MCP configuration for Claude Code
- */
-
-import { output, outputError } from '../lib/cli.js';
-import {
-  generateClaudeCodeConfig,
-  formatClaudeCodeConfig,
-  generateConfigSnippet,
-  generateServerConfig
-} from '../mcp/config-gen.js';
-import { findPackage } from '../core/config.js';
-import { tryLoadManifest } from '../core/manifest.js';
-
-interface McpConfigOptions {
-  global?: boolean;
-  package?: string;
-  snippet?: boolean;
-}
-
-export async function mcpConfigCommand(options: McpConfigOptions): Promise<void> {
-  const cwd = process.cwd();
-
-  // Single package snippet mode
-  if (options.snippet && options.package) {
-    const pkg = findPackage(options.package, cwd);
-    if (!pkg) {
-      outputError('NOT_FOUND', `Package not found: ${options.package}`);
-    }
-
-    const manifest = tryLoadManifest(pkg!.path);
-    if (!manifest) {
-      outputError('MANIFEST_ERROR', `Could not load manifest for ${options.package}`);
-    }
-
-    if (!manifest!.mcp?.enabled) {
-      outputError('INVALID_INPUT', `Package ${options.package} does not have MCP enabled`);
-    }
-
-    const serverName = `cli4ai-${manifest!.name}`;
-    const serverConfig = generateServerConfig(manifest!, pkg!.path);
-    const snippet = generateConfigSnippet(manifest!, pkg!.path);
-    output({
-      serverName,
-      serverConfig,
-      snippet
-    });
-    return;
-  }
-
-  // Generate full config
-  const packages = options.package ? [options.package] : undefined;
-  const config = generateClaudeCodeConfig(cwd, {
-    global: options.global,
-    packages
-  });
-
-  if (Object.keys(config.mcpServers).length === 0) {
-    outputError('NOT_FOUND', 'No MCP-enabled packages found', {
-      hint: 'Install packages with "cli4ai add <package>" first'
-    });
-  }
-
-  // Output formatted config
-  output({
-    config,
-    formatted: formatClaudeCodeConfig(config)
-  });
-}

package/src/commands/remotes.ts

@@ -1,253 +0,0 @@
-/**
- * Remote hosts management command.
- *
- * Manage connections to remote cli4ai instances for distributed execution.
- */
-
-import { output, outputError, log } from '../lib/cli.js';
-import {
-  getRemotes,
-  getRemote,
-  addRemote,
-  updateRemote,
-  removeRemote,
-  RemoteNotFoundError,
-  RemoteAlreadyExistsError,
-  InvalidRemoteUrlError
-} from '../core/remotes.js';
-import { testRemoteConnection, remoteListPackages } from '../core/remote-client.js';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// LIST REMOTES
-// ═══════════════════════════════════════════════════════════════════════════
-
-export async function remotesListCommand(): Promise<void> {
-  const remotes = getRemotes();
-
-  if (remotes.length === 0) {
-    output({ remotes: [], message: 'No remotes configured. Use "cli4ai remotes add <name> <url>" to add one.' });
-    return;
-  }
-
-  output({
-    remotes: remotes.map(r => ({
-      name: r.name,
-      url: r.url,
-      description: r.description,
-      hasApiKey: !!r.apiKey,
-      addedAt: r.addedAt,
-      lastConnected: r.lastConnected
-    }))
-  });
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ADD REMOTE
-// ═══════════════════════════════════════════════════════════════════════════
-
-export interface AddRemoteOptions {
-  apiKey?: string;
-  description?: string;
-  test?: boolean;
-}
-
-export async function remotesAddCommand(
-  name: string,
-  url: string,
-  options: AddRemoteOptions
-): Promise<void> {
-  try {
-    const remote = addRemote(name, url, {
-      apiKey: options.apiKey,
-      description: options.description
-    });
-
-    log(`Added remote: ${remote.name} -> ${remote.url}`);
-
-    // Test connection if requested
-    if (options.test !== false) {
-      log('Testing connection...');
-      const result = await testRemoteConnection(name);
-
-      if (result.success) {
-        log(`Connection successful: ${result.message}`);
-        output({
-          remote: {
-            name: remote.name,
-            url: remote.url,
-            description: remote.description,
-            hasApiKey: !!remote.apiKey
-          },
-          connectionTest: result
-        });
-      } else {
-        log(`Warning: Connection failed - ${result.message}`);
-        log('The remote was added but could not be reached. Check the URL and try again.');
-        output({
-          remote: {
-            name: remote.name,
-            url: remote.url,
-            description: remote.description,
-            hasApiKey: !!remote.apiKey
-          },
-          connectionTest: result
-        });
-      }
-    } else {
-      output({
-        remote: {
-          name: remote.name,
-          url: remote.url,
-          description: remote.description,
-          hasApiKey: !!remote.apiKey
-        }
-      });
-    }
-  } catch (err) {
-    if (err instanceof RemoteAlreadyExistsError) {
-      outputError('ALREADY_EXISTS', `Remote "${err.remoteName}" already exists. Use "cli4ai remotes update" to modify it.`);
-    }
-    if (err instanceof InvalidRemoteUrlError) {
-      outputError('INVALID_INPUT', `Invalid URL "${err.url}": ${err.reason}`);
-    }
-    throw err;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// UPDATE REMOTE
-// ═══════════════════════════════════════════════════════════════════════════
-
-export interface UpdateRemoteOptions {
-  url?: string;
-  apiKey?: string;
-  description?: string;
-}
-
-export async function remotesUpdateCommand(
-  name: string,
-  options: UpdateRemoteOptions
-): Promise<void> {
-  try {
-    // Check if any update provided
-    if (!options.url && !options.apiKey && !options.description) {
-      outputError('INVALID_INPUT', 'No updates provided. Use --url, --api-key, or --description.');
-    }
-
-    const remote = updateRemote(name, options);
-
-    output({
-      updated: true,
-      remote: {
-        name: remote.name,
-        url: remote.url,
-        description: remote.description,
-        hasApiKey: !!remote.apiKey
-      }
-    });
-  } catch (err) {
-    if (err instanceof RemoteNotFoundError) {
-      outputError('NOT_FOUND', `Remote "${err.remoteName}" not found`);
-    }
-    if (err instanceof InvalidRemoteUrlError) {
-      outputError('INVALID_INPUT', `Invalid URL "${err.url}": ${err.reason}`);
-    }
-    throw err;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// REMOVE REMOTE
-// ═══════════════════════════════════════════════════════════════════════════
-
-export async function remotesRemoveCommand(name: string): Promise<void> {
-  try {
-    removeRemote(name);
-    output({ removed: true, name });
-  } catch (err) {
-    if (err instanceof RemoteNotFoundError) {
-      outputError('NOT_FOUND', `Remote "${err.remoteName}" not found`);
-    }
-    throw err;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SHOW REMOTE
-// ═══════════════════════════════════════════════════════════════════════════
-
-export async function remotesShowCommand(name: string): Promise<void> {
-  const remote = getRemote(name);
-
-  if (!remote) {
-    outputError('NOT_FOUND', `Remote "${name}" not found`);
-  }
-
-  output({
-    name: remote.name,
-    url: remote.url,
-    description: remote.description,
-    hasApiKey: !!remote.apiKey,
-    addedAt: remote.addedAt,
-    lastConnected: remote.lastConnected
-  });
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// TEST REMOTE
-// ═══════════════════════════════════════════════════════════════════════════
-
-export async function remotesTestCommand(name: string): Promise<void> {
-  const remote = getRemote(name);
-
-  if (!remote) {
-    outputError('NOT_FOUND', `Remote "${name}" not found`);
-  }
-
-  log(`Testing connection to ${remote.name} (${remote.url})...`);
-
-  const result = await testRemoteConnection(name);
-
-  if (result.success) {
-    log(`Connection successful!`);
-    output({
-      name,
-      url: remote.url,
-      connected: true,
-      ...result.details
-    });
-  } else {
-    log(`Connection failed: ${result.message}`);
-    output({
-      name,
-      url: remote.url,
-      connected: false,
-      error: result.message
-    });
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// LIST PACKAGES ON REMOTE
-// ═══════════════════════════════════════════════════════════════════════════
-
-export async function remotesPackagesCommand(name: string): Promise<void> {
-  const remote = getRemote(name);
-
-  if (!remote) {
-    outputError('NOT_FOUND', `Remote "${name}" not found`);
-  }
-
-  try {
-    const result = await remoteListPackages(name);
-    output({
-      remote: name,
-      packages: result.packages
-    });
-  } catch (err) {
-    if (err instanceof Error) {
-      outputError('API_ERROR', `Failed to list packages on remote "${name}": ${err.message}`);
-    }
-    throw err;
-  }
-}

package/src/commands/remove.ts

@@ -1,78 +0,0 @@
-/**
- * cli4ai remove - Uninstall packages
- */
-
-import { existsSync, rmSync, lstatSync, unlinkSync } from 'fs';
-import { resolve } from 'path';
-import { output, outputError, log } from '../lib/cli.js';
-import { PACKAGES_DIR, LOCAL_PACKAGES_DIR } from '../core/config.js';
-import { unlockPackage } from '../core/lockfile.js';
-import { unlinkPackage as unlinkFromPath } from '../core/link.js';
-
-interface RemoveOptions {
-  global?: boolean;
-}
-
-interface RemoveResult {
-  name: string;
-  path: string;
-}
-
-const PKG_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
-
-export async function removeCommand(packages: string[], options: RemoveOptions): Promise<void> {
-  const results: RemoveResult[] = [];
-  const errors: { package: string; error: string }[] = [];
-
-  const targetDir = options.global ? PACKAGES_DIR : resolve(process.cwd(), LOCAL_PACKAGES_DIR);
-  const projectDir = process.cwd();
-
-  for (const pkg of packages) {
-    if (!PKG_NAME_PATTERN.test(pkg)) {
-      errors.push({ package: pkg, error: 'Invalid package name' });
-      continue;
-    }
-    const pkgPath = resolve(targetDir, pkg);
-
-    if (!existsSync(pkgPath)) {
-      errors.push({ package: pkg, error: 'Not installed' });
-      continue;
-    }
-
-    try {
-      const stat = lstatSync(pkgPath);
-      if (stat.isSymbolicLink()) {
-        unlinkSync(pkgPath);
-      } else {
-        rmSync(pkgPath, { recursive: true });
-      }
-
-      results.push({ name: pkg, path: pkgPath });
-
-      if (options.global) {
-        // Remove from PATH
-        unlinkFromPath(pkg);
-        log(`- ${pkg} (unlinked from PATH)`);
-      } else {
-        log(`- ${pkg}`);
-        // Update lockfile (only for local/project installs)
-        unlockPackage(projectDir, pkg);
-      }
-    } catch (err) {
-      errors.push({
-        package: pkg,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-
-  if (errors.length > 0 && results.length === 0) {
-    outputError('INSTALL_ERROR', 'Failed to remove packages', { errors });
-  }
-
-  output({
-    removed: results,
-    errors: errors.length > 0 ? errors : undefined,
-    location: options.global ? 'global' : 'local'
-  });
-}