praisonai 1.2.2 → 1.2.3

package/dist/cli/features/scheduler.js

@@ -0,0 +1,298 @@
+"use strict";
+/**
+ * Agent Scheduler - Cron-like scheduling for agent tasks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cronExpressions = exports.Scheduler = void 0;
+exports.createScheduler = createScheduler;
+/**
+ * Parse cron expression (simplified: minute hour day month weekday)
+ */
+function parseCron(cron) {
+    const parts = cron.split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error('Invalid cron expression. Expected: minute hour day month weekday');
+    }
+    const parseField = (field, min, max) => {
+        if (field === '*') {
+            return Array.from({ length: max - min + 1 }, (_, i) => min + i);
+        }
+        if (field.includes('/')) {
+            const [, step] = field.split('/');
+            const stepNum = parseInt(step);
+            return Array.from({ length: Math.ceil((max - min + 1) / stepNum) }, (_, i) => min + i * stepNum);
+        }
+        if (field.includes(',')) {
+            return field.split(',').map(n => parseInt(n));
+        }
+        if (field.includes('-')) {
+            const [start, end] = field.split('-').map(n => parseInt(n));
+            return Array.from({ length: end - start + 1 }, (_, i) => start + i);
+        }
+        return [parseInt(field)];
+    };
+    return {
+        minute: parseField(parts[0], 0, 59),
+        hour: parseField(parts[1], 0, 23),
+        day: parseField(parts[2], 1, 31),
+        month: parseField(parts[3], 1, 12),
+        weekday: parseField(parts[4], 0, 6)
+    };
+}
+/**
+ * Get next run time from cron expression
+ */
+function getNextCronRun(cron, from = new Date()) {
+    const parsed = parseCron(cron);
+    const next = new Date(from);
+    next.setSeconds(0);
+    next.setMilliseconds(0);
+    next.setMinutes(next.getMinutes() + 1);
+    for (let i = 0; i < 366 * 24 * 60; i++) { // Max 1 year search
+        const minute = next.getMinutes();
+        const hour = next.getHours();
+        const day = next.getDate();
+        const month = next.getMonth() + 1;
+        const weekday = next.getDay();
+        if (parsed.minute.includes(minute) &&
+            parsed.hour.includes(hour) &&
+            parsed.day.includes(day) &&
+            parsed.month.includes(month) &&
+            parsed.weekday.includes(weekday)) {
+            return next;
+        }
+        next.setMinutes(next.getMinutes() + 1);
+    }
+    throw new Error('Could not find next run time');
+}
+/**
+ * Scheduler class
+ */
+class Scheduler {
+    constructor() {
+        this.tasks = new Map();
+        this.running = false;
+        this.stats = {
+            totalTasks: 0,
+            activeTasks: 0,
+            totalRuns: 0,
+            errors: 0
+        };
+    }
+    /**
+     * Add a scheduled task
+     */
+    add(config) {
+        const id = config.id || `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        const task = {
+            id,
+            name: config.name,
+            cron: config.cron,
+            interval: config.interval,
+            enabled: config.enabled ?? true,
+            runCount: 0,
+            maxRuns: config.maxRuns,
+            status: 'idle'
+        };
+        if (config.cron) {
+            task.nextRun = getNextCronRun(config.cron);
+        }
+        else if (config.interval) {
+            task.nextRun = new Date(Date.now() + config.interval);
+        }
+        this.tasks.set(id, { config, task });
+        this.stats.totalTasks++;
+        if (this.running && task.enabled) {
+            this.scheduleTask(id);
+        }
+        return id;
+    }
+    /**
+     * Remove a task
+     */
+    remove(id) {
+        const entry = this.tasks.get(id);
+        if (!entry)
+            return false;
+        if (entry.timer) {
+            clearTimeout(entry.timer);
+        }
+        this.tasks.delete(id);
+        this.stats.totalTasks--;
+        return true;
+    }
+    /**
+     * Enable a task
+     */
+    enable(id) {
+        const entry = this.tasks.get(id);
+        if (!entry)
+            return false;
+        entry.task.enabled = true;
+        if (this.running) {
+            this.scheduleTask(id);
+        }
+        return true;
+    }
+    /**
+     * Disable a task
+     */
+    disable(id) {
+        const entry = this.tasks.get(id);
+        if (!entry)
+            return false;
+        entry.task.enabled = false;
+        if (entry.timer) {
+            clearTimeout(entry.timer);
+            entry.timer = undefined;
+        }
+        return true;
+    }
+    /**
+     * Start the scheduler
+     */
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        for (const [id, entry] of this.tasks) {
+            if (entry.task.enabled) {
+                this.scheduleTask(id);
+            }
+        }
+    }
+    /**
+     * Stop the scheduler
+     */
+    stop() {
+        this.running = false;
+        for (const entry of this.tasks.values()) {
+            if (entry.timer) {
+                clearTimeout(entry.timer);
+                entry.timer = undefined;
+            }
+        }
+    }
+    /**
+     * Schedule a task's next run
+     */
+    scheduleTask(id) {
+        const entry = this.tasks.get(id);
+        if (!entry || !entry.task.enabled || !this.running)
+            return;
+        // Check if max runs reached
+        if (entry.task.maxRuns && entry.task.runCount >= entry.task.maxRuns) {
+            entry.task.status = 'completed';
+            return;
+        }
+        let delay;
+        if (entry.config.cron) {
+            const nextRun = getNextCronRun(entry.config.cron);
+            entry.task.nextRun = nextRun;
+            delay = nextRun.getTime() - Date.now();
+        }
+        else if (entry.config.interval) {
+            entry.task.nextRun = new Date(Date.now() + entry.config.interval);
+            delay = entry.config.interval;
+        }
+        else {
+            return;
+        }
+        entry.timer = setTimeout(() => this.runTask(id), delay);
+        this.stats.activeTasks = Array.from(this.tasks.values()).filter(e => e.timer).length;
+    }
+    /**
+     * Run a task
+     */
+    async runTask(id) {
+        const entry = this.tasks.get(id);
+        if (!entry)
+            return;
+        entry.task.status = 'running';
+        entry.task.lastRun = new Date();
+        try {
+            const result = await entry.config.task();
+            entry.task.runCount++;
+            entry.task.status = 'idle';
+            entry.task.lastError = undefined;
+            this.stats.totalRuns++;
+            entry.config.onComplete?.(result);
+        }
+        catch (error) {
+            entry.task.status = 'error';
+            entry.task.lastError = error.message;
+            this.stats.errors++;
+            entry.config.onError?.(error);
+        }
+        // Schedule next run
+        this.scheduleTask(id);
+    }
+    /**
+     * Run a task immediately
+     */
+    async runNow(id) {
+        const entry = this.tasks.get(id);
+        if (!entry)
+            throw new Error(`Task ${id} not found`);
+        entry.task.status = 'running';
+        entry.task.lastRun = new Date();
+        try {
+            const result = await entry.config.task();
+            entry.task.runCount++;
+            entry.task.status = 'idle';
+            this.stats.totalRuns++;
+            return result;
+        }
+        catch (error) {
+            entry.task.status = 'error';
+            entry.task.lastError = error.message;
+            this.stats.errors++;
+            throw error;
+        }
+    }
+    /**
+     * Get task info
+     */
+    getTask(id) {
+        return this.tasks.get(id)?.task;
+    }
+    /**
+     * Get all tasks
+     */
+    getAllTasks() {
+        return Array.from(this.tasks.values()).map(e => e.task);
+    }
+    /**
+     * Get scheduler stats
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Check if scheduler is running
+     */
+    isRunning() {
+        return this.running;
+    }
+}
+exports.Scheduler = Scheduler;
+/**
+ * Create a scheduler instance
+ */
+function createScheduler() {
+    return new Scheduler();
+}
+/**
+ * Helper to create common cron expressions
+ */
+exports.cronExpressions = {
+    everyMinute: '* * * * *',
+    every5Minutes: '*/5 * * * *',
+    every15Minutes: '*/15 * * * *',
+    everyHour: '0 * * * *',
+    everyDay: '0 0 * * *',
+    everyWeek: '0 0 * * 0',
+    everyMonth: '0 0 1 * *',
+    weekdays: '0 9 * * 1-5',
+    weekends: '0 10 * * 0,6'
+};

package/dist/cli/features/slash-commands.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Slash Commands - Interactive command system for CLI
+ * Supports /help, /cost, /clear, /model, /tokens, /plan, /undo, /diff, /commit, /exit, /settings, /map
+ */
+export interface SlashCommand {
+    name: string;
+    aliases?: string[];
+    description: string;
+    usage?: string;
+    execute: (args: string[], context: SlashCommandContext) => Promise<SlashCommandResult>;
+}
+export interface SlashCommandContext {
+    sessionId?: string;
+    model?: string;
+    tokenCount?: number;
+    costTracker?: CostTracker;
+    history?: string[];
+    settings?: Record<string, any>;
+    onOutput?: (message: string) => void;
+}
+export interface SlashCommandResult {
+    success: boolean;
+    message?: string;
+    data?: any;
+    shouldExit?: boolean;
+}
+export interface CostTracker {
+    totalTokens: number;
+    totalCost: number;
+    requests: number;
+    addUsage(model: string, inputTokens: number, outputTokens: number, latencyMs?: number): any;
+    reset(): void;
+    getSummary(): string;
+}
+/**
+ * Slash Command Registry
+ */
+declare class SlashCommandRegistry {
+    private commands;
+    private aliases;
+    constructor();
+    register(command: SlashCommand): void;
+    get(name: string): SlashCommand | undefined;
+    getAll(): SlashCommand[];
+    has(name: string): boolean;
+}
+export declare function getRegistry(): SlashCommandRegistry;
+export declare function registerCommand(command: SlashCommand): void;
+/**
+ * Parse slash command from input
+ */
+export declare function parseSlashCommand(input: string): {
+    command: string;
+    args: string[];
+} | null;
+/**
+ * Execute a slash command
+ */
+export declare function executeSlashCommand(input: string, context: SlashCommandContext): Promise<SlashCommandResult>;
+/**
+ * Check if input is a slash command
+ */
+export declare function isSlashCommand(input: string): boolean;
+/**
+ * Slash Command Handler for CLI integration
+ */
+export declare class SlashCommandHandler {
+    private context;
+    constructor(initialContext?: Partial<SlashCommandContext>);
+    handle(input: string): Promise<SlashCommandResult>;
+    isCommand(input: string): boolean;
+    getContext(): SlashCommandContext;
+    updateContext(updates: Partial<SlashCommandContext>): void;
+    registerCommand(command: SlashCommand): void;
+}
+export declare function createSlashCommandHandler(context?: Partial<SlashCommandContext>): SlashCommandHandler;
+export {};

package/dist/cli/features/slash-commands.js

@@ -0,0 +1,316 @@
+"use strict";
+/**
+ * Slash Commands - Interactive command system for CLI
+ * Supports /help, /cost, /clear, /model, /tokens, /plan, /undo, /diff, /commit, /exit, /settings, /map
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlashCommandHandler = void 0;
+exports.getRegistry = getRegistry;
+exports.registerCommand = registerCommand;
+exports.parseSlashCommand = parseSlashCommand;
+exports.executeSlashCommand = executeSlashCommand;
+exports.isSlashCommand = isSlashCommand;
+exports.createSlashCommandHandler = createSlashCommandHandler;
+/**
+ * Built-in slash commands
+ */
+const BUILTIN_COMMANDS = [
+    {
+        name: 'help',
+        aliases: ['h', '?'],
+        description: 'Show available commands',
+        execute: async (_args, context) => {
+            const commands = getRegistry().getAll();
+            const lines = ['Available commands:', ''];
+            for (const cmd of commands) {
+                const aliases = cmd.aliases ? ` (${cmd.aliases.map(a => '/' + a).join(', ')})` : '';
+                lines.push(`  /${cmd.name}${aliases} - ${cmd.description}`);
+                if (cmd.usage) {
+                    lines.push(`    Usage: ${cmd.usage}`);
+                }
+            }
+            context.onOutput?.(lines.join('\n'));
+            return { success: true, message: lines.join('\n') };
+        }
+    },
+    {
+        name: 'cost',
+        aliases: ['c'],
+        description: 'Show token usage and cost',
+        execute: async (_args, context) => {
+            if (!context.costTracker) {
+                return { success: false, message: 'Cost tracking not enabled' };
+            }
+            const summary = context.costTracker.getSummary();
+            context.onOutput?.(summary);
+            return { success: true, message: summary };
+        }
+    },
+    {
+        name: 'clear',
+        description: 'Clear conversation history',
+        execute: async (_args, context) => {
+            if (context.history) {
+                context.history.length = 0;
+            }
+            context.onOutput?.('Conversation cleared');
+            return { success: true, message: 'Conversation cleared' };
+        }
+    },
+    {
+        name: 'model',
+        aliases: ['m'],
+        description: 'Show or change the current model',
+        usage: '/model [model-name]',
+        execute: async (args, context) => {
+            if (args.length === 0) {
+                const msg = `Current model: ${context.model || 'default'}`;
+                context.onOutput?.(msg);
+                return { success: true, message: msg, data: { model: context.model } };
+            }
+            const newModel = args[0];
+            context.model = newModel;
+            const msg = `Model changed to: ${newModel}`;
+            context.onOutput?.(msg);
+            return { success: true, message: msg, data: { model: newModel } };
+        }
+    },
+    {
+        name: 'tokens',
+        aliases: ['t'],
+        description: 'Show token count for current session',
+        execute: async (_args, context) => {
+            const count = context.tokenCount || 0;
+            const msg = `Token count: ${count}`;
+            context.onOutput?.(msg);
+            return { success: true, message: msg, data: { tokens: count } };
+        }
+    },
+    {
+        name: 'plan',
+        aliases: ['p'],
+        description: 'Show or manage task plan',
+        usage: '/plan [add|remove|clear] [task]',
+        execute: async (args, context) => {
+            const plans = context.settings?.plans || [];
+            if (args.length === 0) {
+                if (plans.length === 0) {
+                    context.onOutput?.('No plans set');
+                    return { success: true, message: 'No plans set' };
+                }
+                const msg = ['Current plan:', ...plans.map((p, i) => `  ${i + 1}. ${p}`)].join('\n');
+                context.onOutput?.(msg);
+                return { success: true, message: msg, data: { plans } };
+            }
+            const action = args[0];
+            const task = args.slice(1).join(' ');
+            if (action === 'add' && task) {
+                plans.push(task);
+                context.settings = { ...context.settings, plans };
+                context.onOutput?.(`Added: ${task}`);
+                return { success: true, message: `Added: ${task}` };
+            }
+            if (action === 'remove' && task) {
+                const index = parseInt(task) - 1;
+                if (index >= 0 && index < plans.length) {
+                    const removed = plans.splice(index, 1)[0];
+                    context.settings = { ...context.settings, plans };
+                    context.onOutput?.(`Removed: ${removed}`);
+                    return { success: true, message: `Removed: ${removed}` };
+                }
+            }
+            if (action === 'clear') {
+                context.settings = { ...context.settings, plans: [] };
+                context.onOutput?.('Plans cleared');
+                return { success: true, message: 'Plans cleared' };
+            }
+            return { success: false, message: 'Invalid plan command' };
+        }
+    },
+    {
+        name: 'undo',
+        aliases: ['u'],
+        description: 'Undo last action',
+        execute: async (_args, context) => {
+            if (context.history && context.history.length > 0) {
+                const removed = context.history.pop();
+                context.onOutput?.(`Undone: ${removed?.substring(0, 50)}...`);
+                return { success: true, message: 'Last action undone' };
+            }
+            return { success: false, message: 'Nothing to undo' };
+        }
+    },
+    {
+        name: 'diff',
+        aliases: ['d'],
+        description: 'Show pending changes',
+        execute: async (_args, context) => {
+            const diff = context.settings?.pendingDiff || 'No pending changes';
+            context.onOutput?.(diff);
+            return { success: true, message: diff };
+        }
+    },
+    {
+        name: 'commit',
+        description: 'Commit pending changes',
+        execute: async (args, context) => {
+            const message = args.join(' ') || 'Auto-commit';
+            context.onOutput?.(`Committed with message: ${message}`);
+            context.settings = { ...context.settings, pendingDiff: null };
+            return { success: true, message: `Committed: ${message}` };
+        }
+    },
+    {
+        name: 'exit',
+        aliases: ['quit', 'q'],
+        description: 'Exit the session',
+        execute: async (_args, context) => {
+            context.onOutput?.('Goodbye!');
+            return { success: true, message: 'Exiting', shouldExit: true };
+        }
+    },
+    {
+        name: 'settings',
+        aliases: ['s'],
+        description: 'Show or modify settings',
+        usage: '/settings [key] [value]',
+        execute: async (args, context) => {
+            if (args.length === 0) {
+                const settings = JSON.stringify(context.settings || {}, null, 2);
+                context.onOutput?.(settings);
+                return { success: true, message: settings, data: context.settings };
+            }
+            if (args.length === 1) {
+                const value = context.settings?.[args[0]];
+                const msg = `${args[0]}: ${JSON.stringify(value)}`;
+                context.onOutput?.(msg);
+                return { success: true, message: msg, data: { [args[0]]: value } };
+            }
+            const [key, ...valueParts] = args;
+            let value = valueParts.join(' ');
+            try {
+                value = JSON.parse(value);
+            }
+            catch {
+                // Keep as string
+            }
+            context.settings = { ...context.settings, [key]: value };
+            context.onOutput?.(`Set ${key} = ${JSON.stringify(value)}`);
+            return { success: true, message: `Set ${key}` };
+        }
+    },
+    {
+        name: 'map',
+        description: 'Show repository map',
+        execute: async (_args, context) => {
+            const map = context.settings?.repoMap || 'Repository map not available. Run /map refresh to generate.';
+            context.onOutput?.(map);
+            return { success: true, message: map };
+        }
+    }
+];
+/**
+ * Slash Command Registry
+ */
+class SlashCommandRegistry {
+    constructor() {
+        this.commands = new Map();
+        this.aliases = new Map();
+        // Register built-in commands
+        for (const cmd of BUILTIN_COMMANDS) {
+            this.register(cmd);
+        }
+    }
+    register(command) {
+        this.commands.set(command.name, command);
+        if (command.aliases) {
+            for (const alias of command.aliases) {
+                this.aliases.set(alias, command.name);
+            }
+        }
+    }
+    get(name) {
+        const resolved = this.aliases.get(name) || name;
+        return this.commands.get(resolved);
+    }
+    getAll() {
+        return Array.from(this.commands.values());
+    }
+    has(name) {
+        return this.commands.has(name) || this.aliases.has(name);
+    }
+}
+let registry = null;
+function getRegistry() {
+    if (!registry) {
+        registry = new SlashCommandRegistry();
+    }
+    return registry;
+}
+function registerCommand(command) {
+    getRegistry().register(command);
+}
+/**
+ * Parse slash command from input
+ */
+function parseSlashCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/')) {
+        return null;
+    }
+    const parts = trimmed.slice(1).split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    return { command, args };
+}
+/**
+ * Execute a slash command
+ */
+async function executeSlashCommand(input, context) {
+    const parsed = parseSlashCommand(input);
+    if (!parsed) {
+        return { success: false, message: 'Not a slash command' };
+    }
+    const command = getRegistry().get(parsed.command);
+    if (!command) {
+        return { success: false, message: `Unknown command: /${parsed.command}` };
+    }
+    return command.execute(parsed.args, context);
+}
+/**
+ * Check if input is a slash command
+ */
+function isSlashCommand(input) {
+    return input.trim().startsWith('/');
+}
+/**
+ * Slash Command Handler for CLI integration
+ */
+class SlashCommandHandler {
+    constructor(initialContext = {}) {
+        this.context = {
+            history: [],
+            settings: {},
+            ...initialContext
+        };
+    }
+    async handle(input) {
+        return executeSlashCommand(input, this.context);
+    }
+    isCommand(input) {
+        return isSlashCommand(input);
+    }
+    getContext() {
+        return this.context;
+    }
+    updateContext(updates) {
+        this.context = { ...this.context, ...updates };
+    }
+    registerCommand(command) {
+        registerCommand(command);
+    }
+}
+exports.SlashCommandHandler = SlashCommandHandler;
+function createSlashCommandHandler(context) {
+    return new SlashCommandHandler(context);
+}