cli4ai 0.8.0

package/src/commands/remove.ts

@@ -0,0 +1,72 @@
+/**
+ * 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;
+}
+
+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) {
+    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'
+  });
+}

package/src/commands/routines.ts

@@ -0,0 +1,393 @@
+/**
+ * cli4ai routines - Manage and run routines
+ */
+
+import { spawn, spawnSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync, chmodSync, rmSync } from 'fs';
+import { resolve } from 'path';
+import { output, outputError, log } from '../lib/cli.js';
+import { ensureCli4aiHome, ensureLocalDir, ROUTINES_DIR, LOCAL_ROUTINES_DIR } from '../core/config.js';
+import { getGlobalRoutines, getLocalRoutines, resolveRoutine, validateRoutineName, type RoutineInfo } from '../core/routines.js';
+import { loadRoutineDefinition, dryRunRoutine, runRoutine, RoutineParseError, RoutineValidationError, RoutineTemplateError } from '../core/routine-engine.js';
+
+interface RoutinesListOptions {
+  global?: boolean;
+  json?: boolean;
+}
+
+interface RoutinesRunOptions {
+  global?: boolean;
+  var?: string[];
+  dryRun?: boolean;
+}
+
+interface RoutinesCreateOptions {
+  global?: boolean;
+  type?: 'json' | 'bash';
+}
+
+function ensureValidRoutineName(name: string): void {
+  try {
+    validateRoutineName(name);
+  } catch (err) {
+    outputError('INVALID_INPUT', err instanceof Error ? err.message : String(err), { name });
+  }
+}
+
+function normalizeEnvSegment(value: string): string {
+  return value
+    .trim()
+    .toUpperCase()
+    .replace(/[^A-Z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '');
+}
+
+function parseVars(vars: string[] | undefined): Record<string, string> {
+  const result: Record<string, string> = {};
+  if (!vars) return result;
+
+  for (const entry of vars) {
+    const eq = entry.indexOf('=');
+    if (eq <= 0) {
+      outputError('INVALID_INPUT', `Invalid --var (expected KEY=value): ${entry}`);
+    }
+    const key = entry.slice(0, eq).trim();
+    const value = entry.slice(eq + 1);
+    if (!key) {
+      outputError('INVALID_INPUT', `Invalid --var (empty key): ${entry}`);
+    }
+    result[key] = value;
+  }
+
+  return result;
+}
+
+function varsToEnv(vars: Record<string, string>): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const [key, value] of Object.entries(vars)) {
+    const envKey = `CLI4AI_VAR_${normalizeEnvSegment(key)}`;
+    env[envKey] = value;
+  }
+  return env;
+}
+
+function collectStream(stream: NodeJS.ReadableStream): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    stream.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+  });
+}
+
+export async function routinesListCommand(options: RoutinesListOptions): Promise<void> {
+  const local = options.global ? [] : getLocalRoutines(process.cwd());
+  const global = getGlobalRoutines();
+
+  const routines: RoutineInfo[] = [];
+  const seen = new Set<string>();
+
+  for (const r of local) {
+    routines.push(r);
+    seen.add(r.name);
+  }
+
+  for (const r of global) {
+    if (!seen.has(r.name)) {
+      routines.push(r);
+      seen.add(r.name);
+    }
+  }
+
+  if (options.json || !process.stdout.isTTY) {
+    output({
+      routines: routines.map(r => ({
+        name: r.name,
+        kind: r.kind,
+        scope: r.scope,
+        path: r.path
+      })),
+      count: routines.length
+    });
+    return;
+  }
+
+  if (routines.length === 0) {
+    console.log('No routines found');
+    console.log('\nCreate one: cli4ai routines create <name>\n');
+    return;
+  }
+
+  console.log(`\nRoutines (${routines.length}):\n`);
+  for (const r of routines) {
+    const scopeTag = r.scope === 'local' ? '' : ' (global)';
+    console.log(`  ${r.name}${scopeTag}  [${r.kind}]`);
+    console.log(`    ${r.path}`);
+  }
+  console.log('');
+}
+
+function getTargetDir(global: boolean, projectDir: string): string {
+  if (global) {
+    ensureCli4aiHome();
+    return ROUTINES_DIR;
+  }
+  ensureLocalDir(projectDir);
+  return resolve(projectDir, LOCAL_ROUTINES_DIR);
+}
+
+export async function routinesCreateCommand(name: string, options: RoutinesCreateOptions): Promise<void> {
+  ensureValidRoutineName(name);
+  const projectDir = process.cwd();
+  const type = options.type ?? 'bash';
+  if (type !== 'bash' && type !== 'json') {
+    outputError('INVALID_INPUT', `Invalid routine type: ${type}`, {
+      allowed: ['bash', 'json']
+    });
+  }
+  const dir = getTargetDir(!!options.global, projectDir);
+
+  const suffix = type === 'json' ? '.routine.json' : '.routine.sh';
+  const filePath = resolve(dir, `${name}${suffix}`);
+
+  if (existsSync(filePath)) {
+    outputError('INVALID_INPUT', `Routine already exists: ${name}`, { path: filePath });
+  }
+
+  if (type === 'json') {
+    const template = {
+      version: 1,
+      name,
+      description: 'TODO: describe this routine',
+      vars: {},
+      steps: [],
+      result: '{{steps}}'
+    };
+    writeFileSync(filePath, JSON.stringify(template, null, 2) + '\n');
+  } else {
+    const template = `#!/usr/bin/env bash
+set -euo pipefail
+
+# Example:
+#   cli4ai run github trending
+#
+# Vars passed via --var KEY=value are available as env vars:
+#   CLI4AI_VAR_KEY=value
+
+echo "TODO: implement ${name}" 1>&2
+`;
+    writeFileSync(filePath, template);
+    try {
+      chmodSync(filePath, 0o755);
+    } catch {}
+  }
+
+  output({
+    action: 'create',
+    name,
+    type,
+    scope: options.global ? 'global' : 'local',
+    path: filePath
+  });
+}
+
+export async function routinesRunCommand(
+  name: string,
+  args: string[],
+  options: RoutinesRunOptions
+): Promise<void> {
+  ensureValidRoutineName(name);
+  const routine = resolveRoutine(name, process.cwd(), { globalOnly: options.global });
+  if (!routine) {
+    outputError('NOT_FOUND', `Routine not found: ${name}`, {
+      hint: options.global
+        ? 'Create a global routine in ~/.cli4ai/routines'
+        : 'Create a routine in ./.cli4ai/routines or ~/.cli4ai/routines'
+    });
+  }
+
+  const vars = parseVars(options.var);
+
+  if (options.dryRun) {
+    if (routine.kind === 'json') {
+      try {
+        const def = loadRoutineDefinition(routine.path);
+        const plan = await dryRunRoutine(def, vars, process.cwd());
+        output({
+          kind: routine.kind,
+          scope: routine.scope,
+          path: routine.path,
+          ...plan
+        });
+        return;
+      } catch (err) {
+        if (err instanceof RoutineParseError) {
+          outputError('PARSE_ERROR', err.message, { path: err.path });
+        }
+        if (err instanceof RoutineValidationError || err instanceof RoutineTemplateError) {
+          outputError('INVALID_INPUT', err.message, err.details);
+        }
+        throw err;
+      }
+    }
+
+    const plan = {
+      routine: routine.name,
+      kind: routine.kind,
+      scope: routine.scope,
+      path: routine.path,
+      vars,
+      exec: { cmd: 'bash', args: [routine.path, ...args] }
+    };
+
+    if (!process.stdout.isTTY) {
+      output(plan);
+      return;
+    }
+
+    console.log(`\nRoutine: ${routine.name} [${routine.kind}]`);
+    console.log(`Path:    ${routine.path}`);
+    console.log(`Vars:    ${Object.keys(vars).length ? JSON.stringify(vars) : '(none)'}`);
+    console.log(`\nWould run:\n  bash ${routine.path}${args.length ? ' ' + args.join(' ') : ''}\n`);
+    return;
+  }
+
+  if (routine.kind === 'json') {
+    try {
+      const def = loadRoutineDefinition(routine.path);
+      const summary = await runRoutine(def, vars, process.cwd());
+      output({
+        kind: routine.kind,
+        scope: routine.scope,
+        path: routine.path,
+        ...summary
+      });
+      process.exit(summary.exitCode);
+    } catch (err) {
+      if (err instanceof RoutineParseError) {
+        outputError('PARSE_ERROR', err.message, { path: err.path });
+      }
+      if (err instanceof RoutineValidationError || err instanceof RoutineTemplateError) {
+        outputError('INVALID_INPUT', err.message, err.details);
+      }
+      throw err;
+    }
+  }
+
+  const startTime = Date.now();
+  const isTTY = process.stdout.isTTY;
+  const varEnv = varsToEnv(vars);
+
+  const child = spawn('bash', [routine.path, ...args], {
+    cwd: process.cwd(),
+    stdio: isTTY ? 'inherit' : ['pipe', 'pipe', 'pipe'],
+    env: {
+      ...process.env,
+      ...varEnv,
+      C4AI_ROUTINE_NAME: routine.name,
+      C4AI_ROUTINE_PATH: routine.path
+    }
+  });
+
+  if (isTTY) {
+    const exitCode = await new Promise<number>((resolve) => {
+      child.on('close', (code) => resolve(code ?? 0));
+      child.on('error', (err) => outputError('API_ERROR', `Failed to execute routine: ${err.message}`));
+    });
+    process.exit(exitCode);
+  }
+
+  // Non-TTY: capture and emit single JSON summary.
+  const stdoutPromise = child.stdout ? collectStream(child.stdout) : Promise.resolve('');
+  const stderrPromise = child.stderr ? collectStream(child.stderr) : Promise.resolve('');
+
+  if (child.stderr) {
+    child.stderr.on('data', (chunk) => {
+      process.stderr.write(chunk);
+    });
+  }
+
+  const exitCode = await new Promise<number>((resolve) => {
+    child.on('close', (code) => resolve(code ?? 0));
+    child.on('error', (err) => outputError('API_ERROR', `Failed to execute routine: ${err.message}`));
+  });
+
+  const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+
+  output({
+    routine: routine.name,
+    kind: routine.kind,
+    scope: routine.scope,
+    status: exitCode === 0 ? 'success' : 'failed',
+    exitCode,
+    durationMs: Date.now() - startTime,
+    stdout,
+    stderr
+  });
+
+  process.exit(exitCode);
+}
+
+export async function routinesShowCommand(name: string, options: { global?: boolean }): Promise<void> {
+  ensureValidRoutineName(name);
+  const routine = resolveRoutine(name, process.cwd(), { globalOnly: options.global });
+  if (!routine) {
+    outputError('NOT_FOUND', `Routine not found: ${name}`);
+  }
+
+  const content = readFileSync(routine.path, 'utf-8');
+
+  if (!process.stdout.isTTY) {
+    output({ routine: routine.name, kind: routine.kind, scope: routine.scope, path: routine.path, content });
+    return;
+  }
+
+  log(`\n${routine.path}\n`);
+  process.stdout.write(content);
+  if (!content.endsWith('\n')) process.stdout.write('\n');
+}
+
+export async function routinesRemoveCommand(name: string, options: { global?: boolean }): Promise<void> {
+  ensureValidRoutineName(name);
+  const routine = resolveRoutine(name, process.cwd(), { globalOnly: options.global });
+  if (!routine) {
+    outputError('NOT_FOUND', `Routine not found: ${name}`);
+  }
+
+  rmSync(routine.path, { force: true });
+
+  output({
+    action: 'remove',
+    name: routine.name,
+    scope: routine.scope,
+    kind: routine.kind,
+    path: routine.path
+  });
+}
+
+export async function routinesEditCommand(name: string, options: { global?: boolean }): Promise<void> {
+  ensureValidRoutineName(name);
+  const routine = resolveRoutine(name, process.cwd(), { globalOnly: options.global });
+  if (!routine) {
+    outputError('NOT_FOUND', `Routine not found: ${name}`);
+  }
+
+  const editor = process.env.VISUAL || process.env.EDITOR;
+
+  if (!editor || !process.stdout.isTTY || !process.stdin.isTTY) {
+    output({
+      action: 'edit',
+      name: routine.name,
+      path: routine.path,
+      hint: editor ? 'Run your editor with the path above' : 'Set $EDITOR (or $VISUAL) to enable `cli4ai routines edit`'
+    });
+    return;
+  }
+
+  const result = spawnSync(editor, [routine.path], {
+    stdio: 'inherit',
+    shell: true
+  });
+
+  process.exit(result.status ?? 0);
+}

package/src/commands/run.ts

@@ -0,0 +1,45 @@
+/**
+ * cli4ai run - Execute a tool command
+ */
+
+import { outputError } from '../lib/cli.js';
+import { executeTool, ExecuteToolError } from '../core/execute.js';
+
+interface RunOptions {
+  env?: string[];
+}
+
+export async function runCommand(
+  packageName: string,
+  command: string | undefined,
+  args: string[],
+  options: RunOptions
+): Promise<void> {
+  // Parse environment variables from options (-e KEY=value)
+  const extraEnv: Record<string, string> = {};
+  if (options.env) {
+    for (const envVar of options.env) {
+      const eqIndex = envVar.indexOf('=');
+      if (eqIndex > 0) {
+        extraEnv[envVar.slice(0, eqIndex)] = envVar.slice(eqIndex + 1);
+      }
+    }
+  }
+
+  try {
+    const result = await executeTool({
+      packageName,
+      command,
+      args,
+      cwd: process.cwd(),
+      env: extraEnv,
+      capture: 'inherit'
+    });
+    process.exit(result.exitCode);
+  } catch (err) {
+    if (err instanceof ExecuteToolError) {
+      outputError(err.code, err.message, err.details);
+    }
+    throw err;
+  }
+}

package/src/commands/search.ts

@@ -0,0 +1,148 @@
+/**
+ * cli4ai search - Search for packages
+ */
+
+import { readdirSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { spawnSync } from 'child_process';
+import { output, log } from '../lib/cli.js';
+import { loadConfig, getGlobalPackages, getLocalPackages } from '../core/config.js';
+import { tryLoadManifest, type Manifest } from '../core/manifest.js';
+
+interface SearchOptions {
+  limit?: string;
+}
+
+interface SearchResult {
+  name: string;
+  version: string;
+  description?: string;
+  path?: string;
+  source: 'local-registry' | 'installed' | 'npm';
+  installed: boolean;
+}
+
+export async function searchCommand(query: string, options: SearchOptions): Promise<void> {
+  const limit = parseInt(options.limit || '20', 10);
+  const queryLower = query.toLowerCase();
+
+  const results: SearchResult[] = [];
+  const seen = new Set<string>();
+
+  // Get installed packages
+  const installedNames = new Set([
+    ...getLocalPackages(process.cwd()).map(p => p.name),
+    ...getGlobalPackages().map(p => p.name)
+  ]);
+
+  // Search local registries
+  const config = loadConfig();
+  for (const registryPath of config.localRegistries) {
+    if (!existsSync(registryPath)) continue;
+
+    try {
+      for (const entry of readdirSync(registryPath, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        if (seen.has(entry.name)) continue;
+
+        const pkgPath = resolve(registryPath, entry.name);
+        const manifest = tryLoadManifest(pkgPath);
+
+        if (!manifest) continue;
+
+        // Check if matches query
+        if (matches(manifest, queryLower)) {
+          seen.add(manifest.name);
+          results.push({
+            name: manifest.name,
+            version: manifest.version,
+            description: manifest.description,
+            path: pkgPath,
+            source: 'local-registry',
+            installed: installedNames.has(manifest.name)
+          });
+        }
+
+        if (results.length >= limit) break;
+      }
+    } catch {
+      // Skip inaccessible registries
+    }
+
+    if (results.length >= limit) break;
+  }
+
+  // Search npm for @cli4ai packages
+  if (results.length < limit) {
+    try {
+      log(`Searching npm for @cli4ai packages...`);
+      // Use spawnSync with argument array to prevent command injection
+      const searchResult = spawnSync('npm', ['search', `@cli4ai/${query}`, '--json'], {
+        encoding: 'utf-8',
+        timeout: 10000,
+        stdio: ['pipe', 'pipe', 'pipe']
+      });
+
+      let npmResults = searchResult.stdout || '';
+
+      // Fallback to searching @cli4ai if specific query fails
+      if (!npmResults || npmResults === '[]') {
+        const fallbackResult = spawnSync('npm', ['search', '@cli4ai', '--json'], {
+          encoding: 'utf-8',
+          timeout: 10000,
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+        npmResults = fallbackResult.stdout || '[]';
+      }
+
+      const packages = JSON.parse(npmResults || '[]');
+      for (const pkg of packages) {
+        if (seen.has(pkg.name)) continue;
+
+        // Filter to only @cli4ai scoped packages
+        if (!pkg.name.startsWith('@cli4ai/')) continue;
+
+        // Check if matches query
+        const shortName = pkg.name.replace('@cli4ai/', '');
+        if (
+          shortName.toLowerCase().includes(queryLower) ||
+          pkg.description?.toLowerCase().includes(queryLower) ||
+          pkg.keywords?.some((k: string) => k.toLowerCase().includes(queryLower))
+        ) {
+          seen.add(pkg.name);
+          results.push({
+            name: shortName,
+            version: pkg.version,
+            description: pkg.description,
+            source: 'npm',
+            installed: installedNames.has(shortName) || installedNames.has(pkg.name)
+          });
+        }
+
+        if (results.length >= limit) break;
+      }
+    } catch {
+      // npm search failed, continue with local results
+    }
+  }
+
+  output({
+    query,
+    results: results.slice(0, limit),
+    count: results.length,
+    registries: config.localRegistries
+  });
+}
+
+function matches(manifest: Manifest, query: string): boolean {
+  // Match against name
+  if (manifest.name.toLowerCase().includes(query)) return true;
+
+  // Match against description
+  if (manifest.description?.toLowerCase().includes(query)) return true;
+
+  // Match against keywords
+  if (manifest.keywords?.some(k => k.toLowerCase().includes(query))) return true;
+
+  return false;
+}