praisonai 1.1.0 → 1.2.1

package/dist/memory/memory.js

@@ -1 +1,170 @@
 "use strict";
+/**
+ * Memory System - Conversation and context memory management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+exports.createMemory = createMemory;
+/**
+ * Memory class for managing conversation history and context
+ */
+class Memory {
+    constructor(config = {}) {
+        this.entries = new Map();
+        this.maxEntries = config.maxEntries ?? 1000;
+        this.maxTokens = config.maxTokens ?? 100000;
+        this.embeddingProvider = config.embeddingProvider;
+    }
+    /**
+     * Add a memory entry
+     */
+    async add(content, role, metadata) {
+        const id = this.generateId();
+        const entry = {
+            id,
+            content,
+            role,
+            timestamp: Date.now(),
+            metadata
+        };
+        if (this.embeddingProvider) {
+            entry.embedding = await this.embeddingProvider.embed(content);
+        }
+        this.entries.set(id, entry);
+        this.enforceLimit();
+        return entry;
+    }
+    /**
+     * Get a memory entry by ID
+     */
+    get(id) {
+        return this.entries.get(id);
+    }
+    /**
+     * Get all entries
+     */
+    getAll() {
+        return Array.from(this.entries.values())
+            .sort((a, b) => a.timestamp - b.timestamp);
+    }
+    /**
+     * Get recent entries
+     */
+    getRecent(count) {
+        return this.getAll().slice(-count);
+    }
+    /**
+     * Search memory by text similarity
+     */
+    async search(query, limit = 5) {
+        if (!this.embeddingProvider) {
+            // Fallback to simple text matching
+            return this.textSearch(query, limit);
+        }
+        const queryEmbedding = await this.embeddingProvider.embed(query);
+        const results = [];
+        for (const entry of this.entries.values()) {
+            if (entry.embedding) {
+                const score = this.cosineSimilarity(queryEmbedding, entry.embedding);
+                results.push({ entry, score });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Simple text search fallback
+     */
+    textSearch(query, limit) {
+        const queryLower = query.toLowerCase();
+        const results = [];
+        for (const entry of this.entries.values()) {
+            const contentLower = entry.content.toLowerCase();
+            if (contentLower.includes(queryLower)) {
+                const score = queryLower.length / contentLower.length;
+                results.push({ entry, score: Math.min(score * 10, 1) });
+            }
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Calculate cosine similarity
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+    /**
+     * Delete a memory entry
+     */
+    delete(id) {
+        return this.entries.delete(id);
+    }
+    /**
+     * Clear all memory
+     */
+    clear() {
+        this.entries.clear();
+    }
+    /**
+     * Get memory size
+     */
+    get size() {
+        return this.entries.size;
+    }
+    /**
+     * Build context string from recent memory
+     */
+    buildContext(count) {
+        const entries = count ? this.getRecent(count) : this.getAll();
+        return entries
+            .map(e => `${e.role}: ${e.content}`)
+            .join('\n');
+    }
+    /**
+     * Export memory to JSON
+     */
+    toJSON() {
+        return this.getAll();
+    }
+    /**
+     * Import memory from JSON
+     */
+    fromJSON(entries) {
+        this.entries.clear();
+        for (const entry of entries) {
+            this.entries.set(entry.id, entry);
+        }
+    }
+    generateId() {
+        return `mem_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    enforceLimit() {
+        while (this.entries.size > this.maxEntries) {
+            const oldest = this.getAll()[0];
+            if (oldest) {
+                this.entries.delete(oldest.id);
+            }
+        }
+    }
+}
+exports.Memory = Memory;
+/**
+ * Create a memory instance
+ */
+function createMemory(config) {
+    return new Memory(config);
+}

package/dist/planning/index.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Planning System - Plans, Steps, and TodoLists
+ */
+export type PlanStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export type TodoStatus = 'pending' | 'in_progress' | 'completed';
+export interface PlanConfig {
+    name: string;
+    description?: string;
+    metadata?: Record<string, any>;
+}
+export interface PlanStepConfig {
+    description: string;
+    status?: PlanStatus;
+    order?: number;
+    dependencies?: string[];
+    metadata?: Record<string, any>;
+}
+export interface TodoItemConfig {
+    content: string;
+    priority?: 'low' | 'medium' | 'high';
+    status?: TodoStatus;
+    dueDate?: Date;
+    metadata?: Record<string, any>;
+}
+/**
+ * PlanStep - A single step in a plan
+ */
+export declare class PlanStep {
+    readonly id: string;
+    description: string;
+    status: PlanStatus;
+    order: number;
+    dependencies: string[];
+    metadata: Record<string, any>;
+    startedAt?: number;
+    completedAt?: number;
+    constructor(config: PlanStepConfig);
+    start(): this;
+    complete(): this;
+    fail(): this;
+    cancel(): this;
+}
+/**
+ * Plan - A collection of steps to accomplish a goal
+ */
+export declare class Plan {
+    readonly id: string;
+    name: string;
+    description?: string;
+    steps: PlanStep[];
+    status: PlanStatus;
+    metadata: Record<string, any>;
+    createdAt: number;
+    updatedAt: number;
+    constructor(config: PlanConfig);
+    addStep(step: PlanStep): this;
+    removeStep(stepId: string): boolean;
+    getStep(stepId: string): PlanStep | undefined;
+    getNextStep(): PlanStep | undefined;
+    getProgress(): {
+        completed: number;
+        total: number;
+        percentage: number;
+    };
+    start(): this;
+    complete(): this;
+}
+/**
+ * TodoItem - A single todo item
+ */
+export declare class TodoItem {
+    readonly id: string;
+    content: string;
+    priority: 'low' | 'medium' | 'high';
+    status: TodoStatus;
+    dueDate?: Date;
+    metadata: Record<string, any>;
+    createdAt: number;
+    completedAt?: number;
+    constructor(config: TodoItemConfig);
+    start(): this;
+    complete(): this;
+    reset(): this;
+}
+/**
+ * TodoList - A collection of todo items
+ */
+export declare class TodoList {
+    readonly id: string;
+    name: string;
+    items: TodoItem[];
+    createdAt: number;
+    constructor(name?: string);
+    add(item: TodoItem): this;
+    remove(itemId: string): boolean;
+    get(itemId: string): TodoItem | undefined;
+    getPending(): TodoItem[];
+    getCompleted(): TodoItem[];
+    getByPriority(priority: 'low' | 'medium' | 'high'): TodoItem[];
+    getProgress(): {
+        completed: number;
+        total: number;
+        percentage: number;
+    };
+    clear(): this;
+}
+/**
+ * PlanStorage - Persist plans (in-memory implementation)
+ */
+export declare class PlanStorage {
+    private plans;
+    private todoLists;
+    savePlan(plan: Plan): void;
+    getPlan(planId: string): Plan | undefined;
+    deletePlan(planId: string): boolean;
+    listPlans(): Plan[];
+    saveTodoList(list: TodoList): void;
+    getTodoList(listId: string): TodoList | undefined;
+    deleteTodoList(listId: string): boolean;
+    listTodoLists(): TodoList[];
+}
+/**
+ * Create a Plan
+ */
+export declare function createPlan(config: PlanConfig): Plan;
+/**
+ * Create a TodoList
+ */
+export declare function createTodoList(name?: string): TodoList;
+/**
+ * Create a PlanStorage
+ */
+export declare function createPlanStorage(): PlanStorage;

package/dist/planning/index.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * Planning System - Plans, Steps, and TodoLists
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanStorage = exports.TodoList = exports.TodoItem = exports.Plan = exports.PlanStep = void 0;
+exports.createPlan = createPlan;
+exports.createTodoList = createTodoList;
+exports.createPlanStorage = createPlanStorage;
+/**
+ * PlanStep - A single step in a plan
+ */
+class PlanStep {
+    constructor(config) {
+        this.id = `step_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.description = config.description;
+        this.status = config.status ?? 'pending';
+        this.order = config.order ?? 0;
+        this.dependencies = config.dependencies ?? [];
+        this.metadata = config.metadata ?? {};
+    }
+    start() {
+        this.status = 'in_progress';
+        this.startedAt = Date.now();
+        return this;
+    }
+    complete() {
+        this.status = 'completed';
+        this.completedAt = Date.now();
+        return this;
+    }
+    fail() {
+        this.status = 'failed';
+        this.completedAt = Date.now();
+        return this;
+    }
+    cancel() {
+        this.status = 'cancelled';
+        return this;
+    }
+}
+exports.PlanStep = PlanStep;
+/**
+ * Plan - A collection of steps to accomplish a goal
+ */
+class Plan {
+    constructor(config) {
+        this.steps = [];
+        this.status = 'pending';
+        this.id = `plan_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.name = config.name;
+        this.description = config.description;
+        this.metadata = config.metadata ?? {};
+        this.createdAt = Date.now();
+        this.updatedAt = Date.now();
+    }
+    addStep(step) {
+        step.order = this.steps.length;
+        this.steps.push(step);
+        this.updatedAt = Date.now();
+        return this;
+    }
+    removeStep(stepId) {
+        const index = this.steps.findIndex(s => s.id === stepId);
+        if (index >= 0) {
+            this.steps.splice(index, 1);
+            this.updatedAt = Date.now();
+            return true;
+        }
+        return false;
+    }
+    getStep(stepId) {
+        return this.steps.find(s => s.id === stepId);
+    }
+    getNextStep() {
+        return this.steps.find(s => s.status === 'pending');
+    }
+    getProgress() {
+        const completed = this.steps.filter(s => s.status === 'completed').length;
+        const total = this.steps.length;
+        return {
+            completed,
+            total,
+            percentage: total > 0 ? Math.round((completed / total) * 100) : 0
+        };
+    }
+    start() {
+        this.status = 'in_progress';
+        this.updatedAt = Date.now();
+        return this;
+    }
+    complete() {
+        this.status = 'completed';
+        this.updatedAt = Date.now();
+        return this;
+    }
+}
+exports.Plan = Plan;
+/**
+ * TodoItem - A single todo item
+ */
+class TodoItem {
+    constructor(config) {
+        this.id = `todo_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.content = config.content;
+        this.priority = config.priority ?? 'medium';
+        this.status = config.status ?? 'pending';
+        this.dueDate = config.dueDate;
+        this.metadata = config.metadata ?? {};
+        this.createdAt = Date.now();
+    }
+    start() {
+        this.status = 'in_progress';
+        return this;
+    }
+    complete() {
+        this.status = 'completed';
+        this.completedAt = Date.now();
+        return this;
+    }
+    reset() {
+        this.status = 'pending';
+        this.completedAt = undefined;
+        return this;
+    }
+}
+exports.TodoItem = TodoItem;
+/**
+ * TodoList - A collection of todo items
+ */
+class TodoList {
+    constructor(name = 'Todo List') {
+        this.items = [];
+        this.id = `todolist_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.name = name;
+        this.createdAt = Date.now();
+    }
+    add(item) {
+        this.items.push(item);
+        return this;
+    }
+    remove(itemId) {
+        const index = this.items.findIndex(i => i.id === itemId);
+        if (index >= 0) {
+            this.items.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+    get(itemId) {
+        return this.items.find(i => i.id === itemId);
+    }
+    getPending() {
+        return this.items.filter(i => i.status === 'pending');
+    }
+    getCompleted() {
+        return this.items.filter(i => i.status === 'completed');
+    }
+    getByPriority(priority) {
+        return this.items.filter(i => i.priority === priority);
+    }
+    getProgress() {
+        const completed = this.items.filter(i => i.status === 'completed').length;
+        const total = this.items.length;
+        return {
+            completed,
+            total,
+            percentage: total > 0 ? Math.round((completed / total) * 100) : 0
+        };
+    }
+    clear() {
+        this.items = [];
+        return this;
+    }
+}
+exports.TodoList = TodoList;
+/**
+ * PlanStorage - Persist plans (in-memory implementation)
+ */
+class PlanStorage {
+    constructor() {
+        this.plans = new Map();
+        this.todoLists = new Map();
+    }
+    savePlan(plan) {
+        this.plans.set(plan.id, plan);
+    }
+    getPlan(planId) {
+        return this.plans.get(planId);
+    }
+    deletePlan(planId) {
+        return this.plans.delete(planId);
+    }
+    listPlans() {
+        return Array.from(this.plans.values());
+    }
+    saveTodoList(list) {
+        this.todoLists.set(list.id, list);
+    }
+    getTodoList(listId) {
+        return this.todoLists.get(listId);
+    }
+    deleteTodoList(listId) {
+        return this.todoLists.delete(listId);
+    }
+    listTodoLists() {
+        return Array.from(this.todoLists.values());
+    }
+}
+exports.PlanStorage = PlanStorage;
+/**
+ * Create a Plan
+ */
+function createPlan(config) {
+    return new Plan(config);
+}
+/**
+ * Create a TodoList
+ */
+function createTodoList(name) {
+    return new TodoList(name);
+}
+/**
+ * Create a PlanStorage
+ */
+function createPlanStorage() {
+    return new PlanStorage();
+}

package/dist/telemetry/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Telemetry - Usage tracking and analytics
+ */
+export interface TelemetryEvent {
+    name: string;
+    timestamp: number;
+    properties?: Record<string, any>;
+    userId?: string;
+    sessionId?: string;
+}
+export interface TelemetryConfig {
+    enabled?: boolean;
+    endpoint?: string;
+    batchSize?: number;
+    flushInterval?: number;
+}
+/**
+ * Telemetry collector for tracking usage
+ */
+export declare class TelemetryCollector {
+    private events;
+    private enabled;
+    private endpoint?;
+    private batchSize;
+    private flushInterval;
+    private flushTimer?;
+    private userId?;
+    private sessionId;
+    constructor(config?: TelemetryConfig);
+    private checkEnabled;
+    /**
+     * Track an event
+     */
+    track(name: string, properties?: Record<string, any>): void;
+    /**
+     * Track feature usage
+     */
+    trackFeatureUsage(feature: string, metadata?: Record<string, any>): void;
+    /**
+     * Track agent execution
+     */
+    trackAgentExecution(agentName: string, duration: number, success: boolean): void;
+    /**
+     * Track tool call
+     */
+    trackToolCall(toolName: string, duration: number, success: boolean): void;
+    /**
+     * Track LLM call
+     */
+    trackLLMCall(provider: string, model: string, tokens: number, duration: number): void;
+    /**
+     * Track error
+     */
+    trackError(error: string, context?: Record<string, any>): void;
+    /**
+     * Set user ID
+     */
+    setUserId(userId: string): void;
+    /**
+     * Flush events
+     */
+    flush(): Promise<void>;
+    /**
+     * Enable telemetry
+     */
+    enable(): void;
+    /**
+     * Disable telemetry
+     */
+    disable(): void;
+    /**
+     * Check if telemetry is enabled
+     */
+    isEnabled(): boolean;
+    /**
+     * Get pending events count
+     */
+    getPendingCount(): number;
+    /**
+     * Cleanup resources
+     */
+    cleanup(): void;
+    private startFlushTimer;
+    private stopFlushTimer;
+    private generateSessionId;
+}
+/**
+ * Get global telemetry instance
+ */
+export declare function getTelemetry(): TelemetryCollector;
+/**
+ * Enable telemetry
+ */
+export declare function enableTelemetry(): void;
+/**
+ * Disable telemetry
+ */
+export declare function disableTelemetry(): void;
+/**
+ * Cleanup telemetry resources
+ */
+export declare function cleanupTelemetry(): void;