cli4ai 1.2.0 → 1.2.1

package/src/commands/scheduler.ts

@@ -1,438 +0,0 @@
-/**
- * Scheduler CLI commands.
- *
- * cli4ai scheduler start [--foreground]   # Start daemon
- * cli4ai scheduler stop                    # Stop daemon
- * cli4ai scheduler status                  # Show status + upcoming runs
- * cli4ai scheduler logs [routine]          # View logs
- * cli4ai scheduler history [routine]       # View execution history
- * cli4ai scheduler run <routine>           # Manual trigger
- */
-
-import { spawn } from 'child_process';
-import { readFileSync, existsSync, createReadStream } from 'fs';
-import { resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { output, outputError, log } from '../lib/cli.js';
-import {
-  isDaemonRunning,
-  getDaemonPid,
-  removeDaemonPid,
-  loadSchedulerState,
-  getRunHistory,
-  getNextRunTime,
-  Scheduler,
-  SCHEDULER_LOG_FILE,
-  SCHEDULER_PID_FILE
-} from '../core/scheduler.js';
-import { getScheduledRoutines } from '../core/routines.js';
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SCHEDULER START
-// ═══════════════════════════════════════════════════════════════════════════
-
-interface SchedulerStartOptions {
-  foreground?: boolean;
-}
-
-export async function schedulerStartCommand(options: SchedulerStartOptions): Promise<void> {
-  // Check if already running
-  if (isDaemonRunning()) {
-    const pid = getDaemonPid();
-    outputError('INVALID_INPUT', `Scheduler is already running (PID ${pid})`, {
-      hint: 'Use "cli4ai scheduler stop" to stop it first'
-    });
-    return;
-  }
-
-  // Clean up stale PID file
-  if (existsSync(SCHEDULER_PID_FILE)) {
-    removeDaemonPid();
-  }
-
-  if (options.foreground) {
-    // Run in foreground (blocking)
-    log('Starting scheduler in foreground mode...');
-    log('Press Ctrl+C to stop');
-
-    const scheduler = new Scheduler({ projectDir: process.cwd() });
-    await scheduler.start();
-
-    // Keep running until signal
-    await new Promise<void>((resolve) => {
-      process.on('SIGINT', async () => {
-        log('\nStopping scheduler...');
-        await scheduler.stop();
-        resolve();
-      });
-      process.on('SIGTERM', async () => {
-        await scheduler.stop();
-        resolve();
-      });
-    });
-
-    output({ status: 'stopped' });
-    return;
-  }
-
-  // Run as daemon (background)
-  const daemonScript = resolve(dirname(fileURLToPath(import.meta.url)), '../core/scheduler-daemon.ts');
-
-  // Spawn with detached mode
-  const child = spawn('npx', ['tsx', daemonScript, '--project-dir', process.cwd()], {
-    detached: true,
-    stdio: 'ignore',
-    env: {
-      ...process.env,
-      CLI4AI_DAEMON: 'true'
-    }
-  });
-
-  // Unref to allow parent to exit
-  child.unref();
-
-  // Wait a moment for the daemon to write its PID
-  await new Promise(r => setTimeout(r, 500));
-
-  const pid = getDaemonPid();
-  if (pid && isDaemonRunning()) {
-    log(`Scheduler daemon started (PID ${pid})`);
-    output({ status: 'started', pid });
-  } else {
-    outputError('API_ERROR', 'Failed to start scheduler daemon', {
-      hint: 'Check logs with "cli4ai scheduler logs"'
-    });
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SCHEDULER STOP
-// ═══════════════════════════════════════════════════════════════════════════
-
-export async function schedulerStopCommand(): Promise<void> {
-  const pid = getDaemonPid();
-
-  if (!pid) {
-    outputError('NOT_FOUND', 'Scheduler daemon is not running');
-    return;
-  }
-
-  if (!isDaemonRunning()) {
-    // Clean up stale PID file
-    removeDaemonPid();
-    log('Scheduler was not running (cleaned up stale PID file)');
-    output({ status: 'stopped', pid: null });
-    return;
-  }
-
-  log(`Stopping scheduler daemon (PID ${pid})...`);
-
-  try {
-    // Send SIGTERM for graceful shutdown
-    process.kill(pid, 'SIGTERM');
-
-    // Wait for process to exit (up to 10 seconds)
-    const maxWait = 10000;
-    const checkInterval = 100;
-    let waited = 0;
-
-    while (waited < maxWait) {
-      await new Promise(r => setTimeout(r, checkInterval));
-      waited += checkInterval;
-
-      if (!isDaemonRunning()) {
-        break;
-      }
-    }
-
-    if (isDaemonRunning()) {
-      // Force kill if still running
-      log('Scheduler did not stop gracefully, sending SIGKILL...');
-      process.kill(pid, 'SIGKILL');
-      await new Promise(r => setTimeout(r, 500));
-    }
-
-    removeDaemonPid();
-    log('Scheduler daemon stopped');
-    output({ status: 'stopped', pid });
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === 'ESRCH') {
-      // Process doesn't exist
-      removeDaemonPid();
-      log('Scheduler was not running (cleaned up stale PID file)');
-      output({ status: 'stopped', pid: null });
-    } else {
-      outputError('API_ERROR', `Failed to stop scheduler: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SCHEDULER STATUS
-// ═══════════════════════════════════════════════════════════════════════════
-
-export async function schedulerStatusCommand(): Promise<void> {
-  const pid = getDaemonPid();
-  const running = isDaemonRunning();
-
-  // Get scheduled routines
-  const scheduledRoutines = getScheduledRoutines(process.cwd());
-  const state = loadSchedulerState();
-
-  if (!running) {
-    log('Scheduler: not running');
-
-    if (scheduledRoutines.length === 0) {
-      log('\nNo scheduled routines found.');
-      log('Add a "schedule" field to your .routine.json files to enable scheduling.');
-    } else {
-      log(`\nFound ${scheduledRoutines.length} scheduled routine(s):`);
-      for (const routine of scheduledRoutines) {
-        const scheduleStr = routine.schedule.cron
-          ? `cron: ${routine.schedule.cron}`
-          : `interval: ${routine.schedule.interval}`;
-        log(`  - ${routine.name} (${scheduleStr})`);
-      }
-      log('\nStart the scheduler with: cli4ai scheduler start');
-    }
-
-    output({
-      running: false,
-      pid: null,
-      routines: scheduledRoutines.map(r => ({
-        name: r.name,
-        schedule: r.schedule,
-        path: r.path
-      }))
-    });
-    return;
-  }
-
-  log(`Scheduler: running (PID ${pid})`);
-
-  if (state) {
-    log(`Started: ${state.startedAt}`);
-
-    const routineStates = Object.values(state.routines);
-    if (routineStates.length === 0) {
-      log('\nNo scheduled routines.');
-    } else {
-      log(`\nScheduled routines (${routineStates.length}):`);
-      log('');
-
-      for (const routine of routineStates) {
-        const scheduleStr = routine.schedule.cron
-          ? `cron: ${routine.schedule.cron}`
-          : `interval: ${routine.schedule.interval}`;
-
-        const statusIcon = routine.running ? '⏳' :
-          routine.lastStatus === 'success' ? '✓' :
-          routine.lastStatus === 'failed' ? '✗' : '○';
-
-        log(`  ${statusIcon} ${routine.name}`);
-        log(`    Schedule: ${scheduleStr}`);
-
-        if (routine.nextRunAt) {
-          const nextRun = new Date(routine.nextRunAt);
-          const now = new Date();
-          const diffMs = nextRun.getTime() - now.getTime();
-          const diffMins = Math.round(diffMs / 60000);
-
-          if (diffMins < 1) {
-            log(`    Next run: in < 1 minute`);
-          } else if (diffMins < 60) {
-            log(`    Next run: in ${diffMins} minute${diffMins === 1 ? '' : 's'}`);
-          } else {
-            const diffHours = Math.round(diffMins / 60);
-            log(`    Next run: in ${diffHours} hour${diffHours === 1 ? '' : 's'}`);
-          }
-        }
-
-        if (routine.lastRunAt) {
-          log(`    Last run: ${routine.lastRunAt} (${routine.lastStatus})`);
-        }
-
-        log('');
-      }
-    }
-  }
-
-  output({
-    running: true,
-    pid,
-    startedAt: state?.startedAt,
-    routines: state ? Object.values(state.routines) : []
-  });
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SCHEDULER LOGS
-// ═══════════════════════════════════════════════════════════════════════════
-
-interface SchedulerLogsOptions {
-  follow?: boolean;
-  lines?: number;
-}
-
-export async function schedulerLogsCommand(options: SchedulerLogsOptions): Promise<void> {
-  if (!existsSync(SCHEDULER_LOG_FILE)) {
-    log('No scheduler logs found.');
-    output({ logs: [] });
-    return;
-  }
-
-  const lines = options.lines ?? 50;
-
-  if (options.follow) {
-    // Tail -f mode
-    log(`Tailing scheduler logs (${SCHEDULER_LOG_FILE})...`);
-    log('Press Ctrl+C to stop\n');
-
-    // Read initial content
-    const content = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
-    const allLines = content.split('\n');
-    const lastLines = allLines.slice(-lines);
-    process.stdout.write(lastLines.join('\n') + '\n');
-
-    // Watch for new content
-    const { watch } = await import('fs');
-    let lastSize = content.length;
-
-    const watcher = watch(SCHEDULER_LOG_FILE, (eventType) => {
-      if (eventType === 'change') {
-        const newContent = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
-        if (newContent.length > lastSize) {
-          process.stdout.write(newContent.slice(lastSize));
-          lastSize = newContent.length;
-        }
-      }
-    });
-
-    // Keep running until interrupted
-    await new Promise<void>((resolve) => {
-      let closed = false;
-      const closeWatcher = () => {
-        if (closed) return;
-        closed = true;
-        try {
-          watcher.close();
-        } catch {
-          // ignore
-        }
-      };
-
-      const stop = () => {
-        closeWatcher();
-        resolve();
-      };
-
-      process.once('exit', closeWatcher);
-      process.once('SIGINT', stop);
-      process.once('SIGTERM', stop);
-    });
-  } else {
-    // Read last N lines
-    const content = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
-    const allLines = content.split('\n').filter(l => l.trim());
-    const lastLines = allLines.slice(-lines);
-
-    for (const line of lastLines) {
-      log(line);
-    }
-
-    output({ logs: lastLines });
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SCHEDULER HISTORY
-// ═══════════════════════════════════════════════════════════════════════════
-
-interface SchedulerHistoryOptions {
-  limit?: number;
-}
-
-export async function schedulerHistoryCommand(routineName?: string, options: SchedulerHistoryOptions = {}): Promise<void> {
-  const limit = options.limit ?? 20;
-  const history = getRunHistory(routineName, limit);
-
-  if (history.length === 0) {
-    log(routineName
-      ? `No execution history found for routine: ${routineName}`
-      : 'No execution history found.');
-    output({ history: [] });
-    return;
-  }
-
-  log(routineName
-    ? `Execution history for ${routineName} (last ${history.length}):`
-    : `Execution history (last ${history.length}):`);
-  log('');
-
-  for (const record of history) {
-    const statusIcon = record.status === 'success' ? '✓' : '✗';
-    const duration = record.durationMs < 1000
-      ? `${record.durationMs}ms`
-      : `${(record.durationMs / 1000).toFixed(1)}s`;
-
-    log(`  ${statusIcon} ${record.routine}`);
-    log(`    Started: ${record.startedAt}`);
-    log(`    Duration: ${duration}`);
-    if (record.retryAttempt > 0) {
-      log(`    Retry: #${record.retryAttempt}`);
-    }
-    if (record.error) {
-      log(`    Error: ${record.error}`);
-    }
-    log('');
-  }
-
-  output({ history });
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// SCHEDULER RUN
-// ═══════════════════════════════════════════════════════════════════════════
-
-export async function schedulerRunCommand(routineName: string): Promise<void> {
-  // Check if routine exists and is scheduled
-  const scheduledRoutines = getScheduledRoutines(process.cwd());
-  const routine = scheduledRoutines.find(r => r.name === routineName);
-
-  if (!routine) {
-    // Check if it exists but isn't scheduled
-    const { resolveRoutine } = await import('../core/routines.js');
-    const exists = resolveRoutine(routineName, process.cwd());
-
-    if (exists) {
-      outputError('NOT_FOUND', `Routine "${routineName}" exists but has no schedule configured`, {
-        hint: 'Add a "schedule" field to enable scheduling, or use "cli4ai routines run" for one-time execution'
-      });
-    } else {
-      outputError('NOT_FOUND', `Routine not found: ${routineName}`);
-    }
-    return;
-  }
-
-  log(`Running routine: ${routineName}`);
-
-  const scheduler = new Scheduler({ projectDir: process.cwd() });
-  scheduler.refreshRoutines();
-
-  try {
-    const record = await scheduler.runNow(routineName);
-
-    if (record.status === 'success') {
-      log(`Routine completed successfully in ${record.durationMs}ms`);
-    } else {
-      log(`Routine failed (exit code ${record.exitCode})`);
-      if (record.error) {
-        log(`Error: ${record.error}`);
-      }
-    }
-
-    output(record);
-  } catch (err) {
-    outputError('API_ERROR', `Failed to run routine: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}

package/src/commands/search.ts

@@ -1,185 +0,0 @@
-/**
- * cli4ai search - Search for packages
- */
-
-import { readdirSync, existsSync } from 'fs';
-import { resolve } from 'path';
-import { spawnSync } from 'child_process';
-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 {
-  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();
-
-  // 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>();
-
-  // 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;
-}