praisonai 1.2.2 → 1.2.3

package/dist/cli/features/autonomy-mode.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Autonomy Modes - Control automatic execution behavior
+ */
+export type AutonomyMode = 'suggest' | 'auto_edit' | 'full_auto';
+export type ActionType = 'file_read' | 'file_write' | 'file_delete' | 'shell_command' | 'network_request' | 'git_operation' | 'install_package';
+export interface ApprovalPolicy {
+    action: ActionType;
+    requiresApproval: boolean;
+    autoApprovePatterns?: string[];
+    autoDenyPatterns?: string[];
+}
+export interface AutonomyConfig {
+    mode: AutonomyMode;
+    policies?: ApprovalPolicy[];
+    rememberDecisions?: boolean;
+    maxAutoActions?: number;
+}
+export interface ActionRequest {
+    type: ActionType;
+    description: string;
+    target?: string;
+    details?: Record<string, any>;
+}
+export interface ActionDecision {
+    approved: boolean;
+    reason?: string;
+    remembered?: boolean;
+}
+/**
+ * Default policies for each mode
+ */
+export declare const MODE_POLICIES: Record<AutonomyMode, ApprovalPolicy[]>;
+/**
+ * Autonomy Manager class
+ */
+export declare class AutonomyManager {
+    private config;
+    private rememberedDecisions;
+    private actionCount;
+    private promptCallback?;
+    constructor(config?: Partial<AutonomyConfig>);
+    /**
+     * Set the prompt callback for user approval
+     */
+    setPromptCallback(callback: (request: ActionRequest) => Promise<boolean>): void;
+    /**
+     * Request approval for an action
+     */
+    requestApproval(request: ActionRequest): Promise<ActionDecision>;
+    /**
+     * Get policy for an action type
+     */
+    private getPolicy;
+    /**
+     * Generate decision key for remembering
+     */
+    private getDecisionKey;
+    /**
+     * Match a target against a pattern
+     */
+    private matchPattern;
+    /**
+     * Get current mode
+     */
+    getMode(): AutonomyMode;
+    /**
+     * Set mode
+     */
+    setMode(mode: AutonomyMode): void;
+    /**
+     * Add custom policy
+     */
+    addPolicy(policy: ApprovalPolicy): void;
+    /**
+     * Clear remembered decisions
+     */
+    clearRemembered(): void;
+    /**
+     * Reset action count
+     */
+    resetActionCount(): void;
+    /**
+     * Get action count
+     */
+    getActionCount(): number;
+    /**
+     * Get summary of current settings
+     */
+    getSummary(): string;
+}
+/**
+ * Create an autonomy manager
+ */
+export declare function createAutonomyManager(config?: Partial<AutonomyConfig>): AutonomyManager;
+/**
+ * Simple approval prompt for CLI
+ */
+export declare function cliApprovalPrompt(request: ActionRequest): Promise<boolean>;

package/dist/cli/features/autonomy-mode.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * Autonomy Modes - Control automatic execution behavior
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutonomyManager = exports.MODE_POLICIES = void 0;
+exports.createAutonomyManager = createAutonomyManager;
+exports.cliApprovalPrompt = cliApprovalPrompt;
+/**
+ * Default policies for each mode
+ */
+exports.MODE_POLICIES = {
+    suggest: [
+        { action: 'file_read', requiresApproval: false },
+        { action: 'file_write', requiresApproval: true },
+        { action: 'file_delete', requiresApproval: true },
+        { action: 'shell_command', requiresApproval: true },
+        { action: 'network_request', requiresApproval: true },
+        { action: 'git_operation', requiresApproval: true },
+        { action: 'install_package', requiresApproval: true }
+    ],
+    auto_edit: [
+        { action: 'file_read', requiresApproval: false },
+        { action: 'file_write', requiresApproval: false },
+        { action: 'file_delete', requiresApproval: true },
+        { action: 'shell_command', requiresApproval: true },
+        { action: 'network_request', requiresApproval: false },
+        { action: 'git_operation', requiresApproval: true },
+        { action: 'install_package', requiresApproval: true }
+    ],
+    full_auto: [
+        { action: 'file_read', requiresApproval: false },
+        { action: 'file_write', requiresApproval: false },
+        { action: 'file_delete', requiresApproval: false },
+        { action: 'shell_command', requiresApproval: false },
+        { action: 'network_request', requiresApproval: false },
+        { action: 'git_operation', requiresApproval: false },
+        { action: 'install_package', requiresApproval: true }
+    ]
+};
+/**
+ * Autonomy Manager class
+ */
+class AutonomyManager {
+    constructor(config = {}) {
+        this.rememberedDecisions = new Map();
+        this.actionCount = 0;
+        this.config = {
+            mode: 'suggest',
+            rememberDecisions: true,
+            maxAutoActions: 100,
+            ...config
+        };
+    }
+    /**
+     * Set the prompt callback for user approval
+     */
+    setPromptCallback(callback) {
+        this.promptCallback = callback;
+    }
+    /**
+     * Request approval for an action
+     */
+    async requestApproval(request) {
+        // Check if we've exceeded max auto actions
+        if (this.config.maxAutoActions && this.actionCount >= this.config.maxAutoActions) {
+            return {
+                approved: false,
+                reason: 'Maximum auto actions exceeded'
+            };
+        }
+        // Check remembered decisions
+        const decisionKey = this.getDecisionKey(request);
+        if (this.config.rememberDecisions && this.rememberedDecisions.has(decisionKey)) {
+            const remembered = this.rememberedDecisions.get(decisionKey);
+            if (remembered)
+                this.actionCount++;
+            return {
+                approved: remembered,
+                reason: 'Remembered decision',
+                remembered: true
+            };
+        }
+        // Get policy for this action type
+        const policy = this.getPolicy(request.type);
+        // Check auto-approve patterns
+        if (policy.autoApprovePatterns && request.target) {
+            for (const pattern of policy.autoApprovePatterns) {
+                if (this.matchPattern(request.target, pattern)) {
+                    this.actionCount++;
+                    return { approved: true, reason: `Matched auto-approve pattern: ${pattern}` };
+                }
+            }
+        }
+        // Check auto-deny patterns
+        if (policy.autoDenyPatterns && request.target) {
+            for (const pattern of policy.autoDenyPatterns) {
+                if (this.matchPattern(request.target, pattern)) {
+                    return { approved: false, reason: `Matched auto-deny pattern: ${pattern}` };
+                }
+            }
+        }
+        // If no approval required, auto-approve
+        if (!policy.requiresApproval) {
+            this.actionCount++;
+            return { approved: true, reason: 'No approval required' };
+        }
+        // Prompt user for approval
+        if (this.promptCallback) {
+            const approved = await this.promptCallback(request);
+            // Remember decision if enabled
+            if (this.config.rememberDecisions) {
+                this.rememberedDecisions.set(decisionKey, approved);
+            }
+            if (approved)
+                this.actionCount++;
+            return { approved, reason: 'User decision' };
+        }
+        // No prompt callback, deny by default
+        return { approved: false, reason: 'No approval mechanism available' };
+    }
+    /**
+     * Get policy for an action type
+     */
+    getPolicy(actionType) {
+        // Check custom policies first
+        if (this.config.policies) {
+            const custom = this.config.policies.find(p => p.action === actionType);
+            if (custom)
+                return custom;
+        }
+        // Fall back to mode defaults
+        const modePolicy = exports.MODE_POLICIES[this.config.mode].find(p => p.action === actionType);
+        return modePolicy || { action: actionType, requiresApproval: true };
+    }
+    /**
+     * Generate decision key for remembering
+     */
+    getDecisionKey(request) {
+        return `${request.type}:${request.target || 'default'}`;
+    }
+    /**
+     * Match a target against a pattern
+     */
+    matchPattern(target, pattern) {
+        // Simple glob-like matching
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*').replace(/\?/g, '.') + '$');
+        return regex.test(target);
+    }
+    /**
+     * Get current mode
+     */
+    getMode() {
+        return this.config.mode;
+    }
+    /**
+     * Set mode
+     */
+    setMode(mode) {
+        this.config.mode = mode;
+    }
+    /**
+     * Add custom policy
+     */
+    addPolicy(policy) {
+        if (!this.config.policies) {
+            this.config.policies = [];
+        }
+        // Remove existing policy for this action
+        this.config.policies = this.config.policies.filter(p => p.action !== policy.action);
+        this.config.policies.push(policy);
+    }
+    /**
+     * Clear remembered decisions
+     */
+    clearRemembered() {
+        this.rememberedDecisions.clear();
+    }
+    /**
+     * Reset action count
+     */
+    resetActionCount() {
+        this.actionCount = 0;
+    }
+    /**
+     * Get action count
+     */
+    getActionCount() {
+        return this.actionCount;
+    }
+    /**
+     * Get summary of current settings
+     */
+    getSummary() {
+        const lines = [
+            `Autonomy Mode: ${this.config.mode}`,
+            `Actions taken: ${this.actionCount}/${this.config.maxAutoActions || 'unlimited'}`,
+            `Remembered decisions: ${this.rememberedDecisions.size}`,
+            '',
+            'Current policies:'
+        ];
+        const policies = exports.MODE_POLICIES[this.config.mode];
+        for (const policy of policies) {
+            const status = policy.requiresApproval ? '⚠️ requires approval' : '✓ auto-approved';
+            lines.push(`  ${policy.action}: ${status}`);
+        }
+        return lines.join('\n');
+    }
+}
+exports.AutonomyManager = AutonomyManager;
+/**
+ * Create an autonomy manager
+ */
+function createAutonomyManager(config) {
+    return new AutonomyManager(config);
+}
+/**
+ * Simple approval prompt for CLI
+ */
+async function cliApprovalPrompt(request) {
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        const message = `\n⚠️  Action requires approval:\n  Type: ${request.type}\n  ${request.description}\n  Target: ${request.target || 'N/A'}\n\nApprove? (y/n): `;
+        rl.question(message, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}

package/dist/cli/features/background-jobs.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Background Jobs - Persisted job queue with adapter support
+ */
+export type JobStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export type JobPriority = 'low' | 'normal' | 'high' | 'critical';
+export interface Job<T = any> {
+    id: string;
+    name: string;
+    data: T;
+    status: JobStatus;
+    priority: JobPriority;
+    attempts: number;
+    maxAttempts: number;
+    createdAt: Date;
+    startedAt?: Date;
+    completedAt?: Date;
+    result?: any;
+    error?: string;
+    progress?: number;
+    metadata?: Record<string, any>;
+}
+export interface JobQueueConfig {
+    name?: string;
+    concurrency?: number;
+    maxAttempts?: number;
+    retryDelay?: number;
+    storage?: JobStorageAdapter;
+}
+export interface JobStorageAdapter {
+    save(job: Job): Promise<void>;
+    get(id: string): Promise<Job | null>;
+    getAll(): Promise<Job[]>;
+    getByStatus(status: JobStatus): Promise<Job[]>;
+    update(id: string, updates: Partial<Job>): Promise<void>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export type JobHandler<T = any, R = any> = (job: Job<T>, context: JobContext) => Promise<R>;
+export interface JobContext {
+    updateProgress: (progress: number) => Promise<void>;
+    log: (message: string) => void;
+}
+/**
+ * In-memory job storage adapter
+ */
+export declare class MemoryJobStorage implements JobStorageAdapter {
+    private jobs;
+    save(job: Job): Promise<void>;
+    get(id: string): Promise<Job | null>;
+    getAll(): Promise<Job[]>;
+    getByStatus(status: JobStatus): Promise<Job[]>;
+    update(id: string, updates: Partial<Job>): Promise<void>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * File-based job storage adapter
+ */
+export declare class FileJobStorage implements JobStorageAdapter {
+    private filePath;
+    private jobs;
+    private initialized;
+    constructor(filePath: string);
+    private init;
+    private persist;
+    save(job: Job): Promise<void>;
+    get(id: string): Promise<Job | null>;
+    getAll(): Promise<Job[]>;
+    getByStatus(status: JobStatus): Promise<Job[]>;
+    update(id: string, updates: Partial<Job>): Promise<void>;
+    delete(id: string): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * Job Queue class
+ */
+export declare class JobQueue {
+    private config;
+    private storage;
+    private handlers;
+    private running;
+    private activeJobs;
+    private processInterval?;
+    constructor(config?: JobQueueConfig);
+    /**
+     * Register a job handler
+     */
+    register<T = any, R = any>(name: string, handler: JobHandler<T, R>): void;
+    /**
+     * Add a job to the queue
+     */
+    add<T = any>(name: string, data: T, options?: Partial<Job<T>>): Promise<Job<T>>;
+    /**
+     * Get a job by ID
+     */
+    get(id: string): Promise<Job | null>;
+    /**
+     * Get all jobs
+     */
+    getAll(): Promise<Job[]>;
+    /**
+     * Get jobs by status
+     */
+    getByStatus(status: JobStatus): Promise<Job[]>;
+    /**
+     * Cancel a job
+     */
+    cancel(id: string): Promise<boolean>;
+    /**
+     * Retry a failed job
+     */
+    retry(id: string): Promise<boolean>;
+    /**
+     * Start processing jobs
+     */
+    start(): void;
+    /**
+     * Stop processing jobs
+     */
+    stop(): void;
+    /**
+     * Process pending jobs
+     */
+    private process;
+    /**
+     * Run a single job
+     */
+    private runJob;
+    /**
+     * Process a job immediately (bypass queue)
+     */
+    processNow(id: string): Promise<any>;
+    /**
+     * Get queue stats
+     */
+    getStats(): Promise<{
+        pending: number;
+        running: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+    }>;
+    /**
+     * Clear completed/failed jobs
+     */
+    cleanup(olderThan?: Date): Promise<number>;
+}
+/**
+ * Create a job queue
+ */
+export declare function createJobQueue(config?: JobQueueConfig): JobQueue;
+/**
+ * Create a file-based job storage
+ */
+export declare function createFileJobStorage(filePath: string): FileJobStorage;