cli4ai 1.1.5 → 1.2.1

package/dist/core/routines.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Routine discovery and resolution.
+ *
+ * Routines live in:
+ * - local:  <project>/.cli4ai/routines
+ * - global: ~/.cli4ai/routines
+ *
+ * Resolution order:
+ * - local before global (unless globalOnly)
+ * - within a scope: .routine.yaml > .routine.yml > .routine.json > .routine.sh
+ */
+import { type RoutineSchedule } from './routine-engine.js';
+export type RoutineKind = 'yaml' | 'json' | 'bash';
+export type RoutineScope = 'local' | 'global';
+export interface RoutineInfo {
+    name: string;
+    kind: RoutineKind;
+    scope: RoutineScope;
+    path: string;
+}
+export interface ResolveRoutineOptions {
+    globalOnly?: boolean;
+}
+export declare function validateRoutineName(name: string): void;
+export declare function getLocalRoutines(projectDir: string): RoutineInfo[];
+export declare function getGlobalRoutines(): RoutineInfo[];
+export declare function resolveRoutine(name: string, projectDir: string, options?: ResolveRoutineOptions): RoutineInfo | null;
+export interface ScheduledRoutineInfo extends RoutineInfo {
+    schedule: RoutineSchedule;
+}
+/**
+ * Get all routines that have a schedule defined.
+ * Only JSON routines can have schedules (bash scripts cannot).
+ * Searches both local (if projectDir provided) and global routines.
+ */
+export declare function getScheduledRoutines(projectDir?: string): ScheduledRoutineInfo[];

package/dist/core/routines.js

@@ -0,0 +1,132 @@
+/**
+ * Routine discovery and resolution.
+ *
+ * Routines live in:
+ * - local:  <project>/.cli4ai/routines
+ * - global: ~/.cli4ai/routines
+ *
+ * Resolution order:
+ * - local before global (unless globalOnly)
+ * - within a scope: .routine.yaml > .routine.yml > .routine.json > .routine.sh
+ */
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
+import { resolve } from 'path';
+import { parse as parseYaml } from 'yaml';
+import { ensureCli4aiHome, ensureLocalDir, ROUTINES_DIR, LOCAL_ROUTINES_DIR } from './config.js';
+import { validateScheduleConfig } from './routine-engine.js';
+const ROUTINE_FILES = [
+    { kind: 'yaml', suffix: '.routine.yaml' },
+    { kind: 'yaml', suffix: '.routine.yml' },
+    { kind: 'json', suffix: '.routine.json' },
+    { kind: 'bash', suffix: '.routine.sh' }
+];
+const NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+export function validateRoutineName(name) {
+    if (!NAME_PATTERN.test(name)) {
+        throw new Error(`Invalid routine name: ${name}`);
+    }
+}
+function listRoutinesInDir(dir, scope) {
+    if (!existsSync(dir))
+        return [];
+    const results = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isFile())
+            continue;
+        for (const def of ROUTINE_FILES) {
+            if (!entry.name.endsWith(def.suffix))
+                continue;
+            const name = entry.name.slice(0, -def.suffix.length);
+            if (!NAME_PATTERN.test(name))
+                continue;
+            const fullPath = resolve(dir, entry.name);
+            // Best-effort: ensure it's a regular file
+            try {
+                if (!statSync(fullPath).isFile())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            results.push({
+                name,
+                kind: def.kind,
+                scope,
+                path: fullPath
+            });
+        }
+    }
+    return results;
+}
+export function getLocalRoutines(projectDir) {
+    ensureLocalDir(projectDir);
+    const dir = resolve(projectDir, LOCAL_ROUTINES_DIR);
+    return listRoutinesInDir(dir, 'local');
+}
+export function getGlobalRoutines() {
+    ensureCli4aiHome();
+    return listRoutinesInDir(ROUTINES_DIR, 'global');
+}
+export function resolveRoutine(name, projectDir, options = {}) {
+    validateRoutineName(name);
+    const candidates = options.globalOnly
+        ? [{ scope: 'global', baseDir: ROUTINES_DIR }]
+        : [
+            { scope: 'local', baseDir: resolve(projectDir, LOCAL_ROUTINES_DIR) },
+            { scope: 'global', baseDir: ROUTINES_DIR }
+        ];
+    for (const { scope, baseDir } of candidates) {
+        for (const def of ROUTINE_FILES) {
+            const routinePath = resolve(baseDir, `${name}${def.suffix}`);
+            if (existsSync(routinePath)) {
+                return { name, kind: def.kind, scope, path: routinePath };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Get all routines that have a schedule defined.
+ * Only JSON routines can have schedules (bash scripts cannot).
+ * Searches both local (if projectDir provided) and global routines.
+ */
+export function getScheduledRoutines(projectDir) {
+    const results = [];
+    const seen = new Set();
+    // Collect all structured routines (YAML and JSON - bash scripts cannot have schedules)
+    const allRoutines = [];
+    if (projectDir) {
+        allRoutines.push(...getLocalRoutines(projectDir).filter(r => r.kind === 'yaml' || r.kind === 'json'));
+    }
+    allRoutines.push(...getGlobalRoutines().filter(r => r.kind === 'yaml' || r.kind === 'json'));
+    for (const routine of allRoutines) {
+        // Skip if we've already processed a routine with this name (local takes precedence)
+        if (seen.has(routine.name))
+            continue;
+        seen.add(routine.name);
+        try {
+            const content = readFileSync(routine.path, 'utf-8');
+            const data = routine.kind === 'yaml' ? parseYaml(content) : JSON.parse(content);
+            if (data.schedule && typeof data.schedule === 'object') {
+                // Check if schedule is enabled (defaults to true)
+                const enabled = data.schedule.enabled !== false;
+                if (!enabled)
+                    continue;
+                try {
+                    const schedule = validateScheduleConfig(data.schedule, routine.path);
+                    results.push({
+                        ...routine,
+                        schedule
+                    });
+                }
+                catch {
+                    // Skip routines with invalid schedule configs (don't crash the scheduler)
+                }
+            }
+        }
+        catch {
+            // Skip invalid JSON files
+        }
+    }
+    return results;
+}

package/dist/core/scheduler-daemon.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env npx tsx
+/**
+ * Scheduler daemon entry point.
+ *
+ * This script runs as a background process and manages scheduled routine execution.
+ * It's spawned by `cli4ai scheduler start` with detached mode.
+ *
+ * Usage: npx tsx scheduler-daemon.ts [--project-dir <dir>]
+ */
+export {};

package/dist/core/scheduler-daemon.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env npx tsx
+/**
+ * Scheduler daemon entry point.
+ *
+ * This script runs as a background process and manages scheduled routine execution.
+ * It's spawned by `cli4ai scheduler start` with detached mode.
+ *
+ * Usage: npx tsx scheduler-daemon.ts [--project-dir <dir>]
+ */
+import { Scheduler, writeDaemonPid, removeDaemonPid, appendSchedulerLog, SCHEDULER_LOG_FILE, ensureSchedulerDirs } from './scheduler.js';
+import { createWriteStream } from 'fs';
+import { ensureCli4aiHome } from './config.js';
+// Parse arguments
+const args = process.argv.slice(2);
+let projectDir;
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--project-dir' && args[i + 1]) {
+        projectDir = args[i + 1];
+        i++;
+    }
+}
+// Ensure directories exist
+ensureCli4aiHome();
+ensureSchedulerDirs();
+// Redirect stdout/stderr to log file (when running detached)
+if (process.env.CLI4AI_DAEMON === 'true') {
+    const logStream = createWriteStream(SCHEDULER_LOG_FILE, { flags: 'a' });
+    // Redirect console output
+    const originalLog = console.log;
+    const originalError = console.error;
+    console.log = (...args) => {
+        const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+        logStream.write(`[${new Date().toISOString()}] [STDOUT] ${message}\n`);
+    };
+    console.error = (...args) => {
+        const message = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
+        logStream.write(`[${new Date().toISOString()}] [STDERR] ${message}\n`);
+    };
+    // Handle uncaught errors
+    process.on('uncaughtException', (err) => {
+        appendSchedulerLog('error', `Uncaught exception: ${err.message}\n${err.stack}`);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason) => {
+        appendSchedulerLog('error', `Unhandled rejection: ${reason}`);
+    });
+}
+// Write PID file
+writeDaemonPid(process.pid);
+appendSchedulerLog('info', `Daemon started with PID ${process.pid}`);
+// Create and start scheduler
+const scheduler = new Scheduler({ projectDir });
+// Handle shutdown signals
+let shuttingDown = false;
+async function shutdown(signal) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    appendSchedulerLog('info', `Received ${signal}, shutting down...`);
+    try {
+        await scheduler.stop();
+        removeDaemonPid();
+        appendSchedulerLog('info', 'Daemon stopped gracefully');
+    }
+    catch (err) {
+        appendSchedulerLog('error', `Error during shutdown: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    process.exit(0);
+}
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));
+// Start the scheduler
+scheduler.start().catch(err => {
+    appendSchedulerLog('error', `Failed to start scheduler: ${err instanceof Error ? err.message : String(err)}`);
+    removeDaemonPid();
+    process.exit(1);
+});

package/dist/core/scheduler.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Scheduler core - manages scheduled routine execution.
+ *
+ * Storage structure:
+ * ~/.cli4ai/scheduler/
+ * ├── scheduler.pid          # Daemon PID
+ * ├── state.json             # Next runs, last results
+ * ├── runs/                  # Execution records
+ * │   └── <routine>-<ts>.json
+ * └── logs/
+ *     └── scheduler.log      # Daemon logs
+ */
+import { type RoutineSchedule } from './routine-engine.js';
+export declare const SCHEDULER_PID_FILE: string;
+export declare const SCHEDULER_STATE_FILE: string;
+export declare const SCHEDULER_RUNS_DIR: string;
+export declare const SCHEDULER_LOGS_DIR: string;
+export declare const SCHEDULER_LOG_FILE: string;
+export interface ScheduledRoutineState {
+    name: string;
+    path: string;
+    schedule: RoutineSchedule;
+    nextRunAt: string | null;
+    lastRunAt: string | null;
+    lastStatus: 'success' | 'failed' | null;
+    running: boolean;
+    retryCount: number;
+}
+export interface SchedulerState {
+    version: 1;
+    startedAt: string;
+    routines: Record<string, ScheduledRoutineState>;
+}
+export interface SchedulerRunRecord {
+    routine: string;
+    startedAt: string;
+    finishedAt: string;
+    status: 'success' | 'failed';
+    exitCode: number;
+    durationMs: number;
+    retryAttempt: number;
+    error?: string;
+}
+/**
+ * Parse an interval string like "30s", "5m", "1h", "1d" into milliseconds.
+ */
+export declare function parseInterval(interval: string): number;
+/**
+ * Calculate the next run time for a schedule.
+ * If both cron and interval are specified, returns the earlier of the two.
+ */
+export declare function getNextRunTime(schedule: RoutineSchedule, after?: Date): Date | null;
+/**
+ * Get the PID of the running daemon, or null if not running.
+ */
+export declare function getDaemonPid(): number | null;
+/**
+ * Check if the scheduler daemon is running.
+ */
+export declare function isDaemonRunning(): boolean;
+/**
+ * Write the daemon PID file.
+ */
+export declare function writeDaemonPid(pid: number): void;
+/**
+ * Remove the daemon PID file.
+ */
+export declare function removeDaemonPid(): void;
+export declare function ensureSchedulerDirs(): void;
+/**
+ * Load scheduler state from disk.
+ */
+export declare function loadSchedulerState(): SchedulerState | null;
+/**
+ * Save scheduler state to disk.
+ */
+export declare function saveSchedulerState(state: SchedulerState): void;
+/**
+ * Save a run record to disk.
+ */
+export declare function saveRunRecord(record: SchedulerRunRecord): void;
+/**
+ * Get run history for a routine (or all routines).
+ */
+export declare function getRunHistory(routineName?: string, limit?: number): SchedulerRunRecord[];
+export type LogLevel = 'info' | 'warn' | 'error' | 'debug';
+export declare function appendSchedulerLog(level: LogLevel, message: string): void;
+export interface SchedulerOptions {
+    tickIntervalMs?: number;
+    projectDir?: string;
+}
+export declare class Scheduler {
+    private state;
+    private tickIntervalMs;
+    private projectDir;
+    private running;
+    private tickTimer;
+    private routineChainByName;
+    constructor(options?: SchedulerOptions);
+    /**
+     * Refresh the list of scheduled routines from disk.
+     */
+    refreshRoutines(): void;
+    /**
+     * Start the scheduler loop.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the scheduler loop.
+     */
+    stop(): Promise<void>;
+    /**
+     * Get current scheduler state (for status display).
+     */
+    getState(): SchedulerState;
+    private scheduleTick;
+    private isRoutineActive;
+    private enqueueRoutineExecution;
+    /**
+     * Execute one tick - check for routines that need to run.
+     */
+    private tick;
+    /**
+     * Execute a routine (async, doesn't block the tick loop).
+     */
+    private executeRoutine;
+    /**
+     * Manually trigger a routine to run now.
+     */
+    runNow(routineName: string): Promise<SchedulerRunRecord>;
+}