praisonai 1.0.19 → 1.2.0

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/observability/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Observability - Tracing, logging, and metrics hooks
+ */
+export type SpanKind = 'llm' | 'tool' | 'agent' | 'workflow' | 'custom';
+export type SpanStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface SpanData {
+    id: string;
+    traceId: string;
+    parentId?: string;
+    name: string;
+    kind: SpanKind;
+    status: SpanStatus;
+    startTime: number;
+    endTime?: number;
+    attributes: Record<string, any>;
+    events: SpanEvent[];
+}
+export interface SpanEvent {
+    name: string;
+    timestamp: number;
+    attributes?: Record<string, any>;
+}
+export interface TraceData {
+    id: string;
+    name: string;
+    startTime: number;
+    endTime?: number;
+    status: SpanStatus;
+    spans: SpanData[];
+    metadata: Record<string, any>;
+}
+/**
+ * Observability Adapter Protocol
+ */
+export interface ObservabilityAdapter {
+    startTrace(name: string, metadata?: Record<string, any>): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, any>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, any>): void;
+    flush(): Promise<void>;
+}
+export interface TraceContext {
+    traceId: string;
+    startSpan(name: string, kind: SpanKind): SpanContext;
+    end(status?: SpanStatus): void;
+}
+export interface SpanContext {
+    spanId: string;
+    traceId: string;
+    addEvent(name: string, attributes?: Record<string, any>): void;
+    setAttributes(attributes: Record<string, any>): void;
+    end(status?: SpanStatus): void;
+}
+/**
+ * In-memory observability adapter for development
+ */
+export declare class MemoryObservabilityAdapter implements ObservabilityAdapter {
+    private traces;
+    private spans;
+    startTrace(name: string, metadata?: Record<string, any>): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, any>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, any>): void;
+    flush(): Promise<void>;
+    getTrace(traceId: string): TraceData | undefined;
+    getSpan(spanId: string): SpanData | undefined;
+    getAllTraces(): TraceData[];
+    clear(): void;
+    private generateId;
+}
+/**
+ * Console observability adapter for debugging
+ */
+export declare class ConsoleObservabilityAdapter implements ObservabilityAdapter {
+    private memory;
+    startTrace(name: string, metadata?: Record<string, any>): TraceContext;
+    endTrace(traceId: string, status?: SpanStatus): void;
+    startSpan(traceId: string, name: string, kind: SpanKind, parentId?: string): SpanContext;
+    endSpan(spanId: string, status?: SpanStatus, attributes?: Record<string, any>): void;
+    addEvent(spanId: string, name: string, attributes?: Record<string, any>): void;
+    flush(): Promise<void>;
+}
+export declare function setObservabilityAdapter(adapter: ObservabilityAdapter): void;
+export declare function getObservabilityAdapter(): ObservabilityAdapter;

package/dist/observability/index.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Observability - Tracing, logging, and metrics hooks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleObservabilityAdapter = exports.MemoryObservabilityAdapter = void 0;
+exports.setObservabilityAdapter = setObservabilityAdapter;
+exports.getObservabilityAdapter = getObservabilityAdapter;
+/**
+ * In-memory observability adapter for development
+ */
+class MemoryObservabilityAdapter {
+    constructor() {
+        this.traces = new Map();
+        this.spans = new Map();
+    }
+    startTrace(name, metadata = {}) {
+        const traceId = this.generateId();
+        const trace = {
+            id: traceId,
+            name,
+            startTime: Date.now(),
+            status: 'running',
+            spans: [],
+            metadata
+        };
+        this.traces.set(traceId, trace);
+        const self = this;
+        return {
+            traceId,
+            startSpan(spanName, kind) {
+                return self.startSpan(traceId, spanName, kind);
+            },
+            end(status = 'completed') {
+                self.endTrace(traceId, status);
+            }
+        };
+    }
+    endTrace(traceId, status = 'completed') {
+        const trace = this.traces.get(traceId);
+        if (trace) {
+            trace.endTime = Date.now();
+            trace.status = status;
+        }
+    }
+    startSpan(traceId, name, kind, parentId) {
+        const spanId = this.generateId();
+        const span = {
+            id: spanId,
+            traceId,
+            parentId,
+            name,
+            kind,
+            status: 'running',
+            startTime: Date.now(),
+            attributes: {},
+            events: []
+        };
+        this.spans.set(spanId, span);
+        const trace = this.traces.get(traceId);
+        if (trace) {
+            trace.spans.push(span);
+        }
+        const self = this;
+        return {
+            spanId,
+            traceId,
+            addEvent(eventName, attributes) {
+                self.addEvent(spanId, eventName, attributes);
+            },
+            setAttributes(attributes) {
+                const s = self.spans.get(spanId);
+                if (s) {
+                    s.attributes = { ...s.attributes, ...attributes };
+                }
+            },
+            end(status = 'completed') {
+                self.endSpan(spanId, status);
+            }
+        };
+    }
+    endSpan(spanId, status = 'completed', attributes) {
+        const span = this.spans.get(spanId);
+        if (span) {
+            span.endTime = Date.now();
+            span.status = status;
+            if (attributes) {
+                span.attributes = { ...span.attributes, ...attributes };
+            }
+        }
+    }
+    addEvent(spanId, name, attributes) {
+        const span = this.spans.get(spanId);
+        if (span) {
+            span.events.push({
+                name,
+                timestamp: Date.now(),
+                attributes
+            });
+        }
+    }
+    async flush() {
+        // No-op for memory adapter
+    }
+    // Utility methods
+    getTrace(traceId) {
+        return this.traces.get(traceId);
+    }
+    getSpan(spanId) {
+        return this.spans.get(spanId);
+    }
+    getAllTraces() {
+        return Array.from(this.traces.values());
+    }
+    clear() {
+        this.traces.clear();
+        this.spans.clear();
+    }
+    generateId() {
+        return Math.random().toString(36).substring(2, 15);
+    }
+}
+exports.MemoryObservabilityAdapter = MemoryObservabilityAdapter;
+/**
+ * Console observability adapter for debugging
+ */
+class ConsoleObservabilityAdapter {
+    constructor() {
+        this.memory = new MemoryObservabilityAdapter();
+    }
+    startTrace(name, metadata) {
+        console.log(`[TRACE START] ${name}`, metadata || '');
+        return this.memory.startTrace(name, metadata);
+    }
+    endTrace(traceId, status) {
+        console.log(`[TRACE END] ${traceId} - ${status || 'completed'}`);
+        this.memory.endTrace(traceId, status);
+    }
+    startSpan(traceId, name, kind, parentId) {
+        console.log(`  [SPAN START] ${name} (${kind})`);
+        return this.memory.startSpan(traceId, name, kind, parentId);
+    }
+    endSpan(spanId, status, attributes) {
+        console.log(`  [SPAN END] ${spanId} - ${status || 'completed'}`, attributes || '');
+        this.memory.endSpan(spanId, status, attributes);
+    }
+    addEvent(spanId, name, attributes) {
+        console.log(`    [EVENT] ${name}`, attributes || '');
+        this.memory.addEvent(spanId, name, attributes);
+    }
+    async flush() {
+        await this.memory.flush();
+    }
+}
+exports.ConsoleObservabilityAdapter = ConsoleObservabilityAdapter;
+// Global observability instance
+let globalAdapter = null;
+function setObservabilityAdapter(adapter) {
+    globalAdapter = adapter;
+}
+function getObservabilityAdapter() {
+    if (!globalAdapter) {
+        globalAdapter = new MemoryObservabilityAdapter();
+    }
+    return globalAdapter;
+}

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;