praisonai 1.0.19 → 1.2.0

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

@@ -0,0 +1,111 @@
+/**
+ * Session Management - Session, Run, and Trace tracking
+ */
+export interface SessionConfig {
+    id?: string;
+    metadata?: Record<string, any>;
+}
+export interface RunConfig {
+    id?: string;
+    metadata?: Record<string, any>;
+}
+export interface TraceConfig {
+    id?: string;
+    name: string;
+    attributes?: Record<string, any>;
+}
+export type RunStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type TraceStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface Message {
+    id: string;
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: any[];
+    timestamp: number;
+    runId?: string;
+}
+/**
+ * Trace represents a span within a run (e.g., LLM call, tool call)
+ */
+export declare class Trace {
+    readonly id: string;
+    readonly runId: string;
+    readonly name: string;
+    readonly parentId: string | null;
+    readonly startTime: number;
+    endTime: number | null;
+    status: TraceStatus;
+    attributes: Record<string, any>;
+    private children;
+    constructor(runId: string, config: TraceConfig, parentId?: string | null);
+    start(): this;
+    complete(attributes?: Record<string, any>): this;
+    fail(error?: Error): this;
+    get duration(): number | null;
+    createChild(config: TraceConfig): Trace;
+    getChildren(): Trace[];
+    toJSON(): Record<string, any>;
+}
+/**
+ * Run represents a single execution within a session (e.g., one chat call)
+ */
+export declare class Run {
+    readonly id: string;
+    readonly sessionId: string;
+    readonly startTime: number;
+    endTime: number | null;
+    status: RunStatus;
+    error: Error | null;
+    metadata: Record<string, any>;
+    private traces;
+    private messages;
+    constructor(sessionId: string, config?: RunConfig);
+    start(): this;
+    complete(metadata?: Record<string, any>): this;
+    fail(error: Error): this;
+    get duration(): number | null;
+    createTrace(config: TraceConfig): Trace;
+    addMessage(message: Omit<Message, 'id' | 'timestamp' | 'runId'>): Message;
+    getTraces(): Trace[];
+    getMessages(): Message[];
+    toJSON(): Record<string, any>;
+}
+/**
+ * Session represents a conversation session with message history
+ */
+export declare class Session {
+    readonly id: string;
+    readonly createdAt: number;
+    metadata: Record<string, any>;
+    private _runs;
+    private _messages;
+    constructor(config?: SessionConfig);
+    createRun(config?: RunConfig): Run;
+    get runs(): Run[];
+    get messages(): Message[];
+    addMessage(message: Omit<Message, 'id' | 'timestamp'>): Message;
+    getMessagesForLLM(): Array<{
+        role: string;
+        content: string | null;
+        tool_call_id?: string;
+        tool_calls?: any[];
+    }>;
+    clearMessages(): void;
+    toJSON(): Record<string, any>;
+}
+/**
+ * SessionManager for managing multiple sessions
+ */
+export declare class SessionManager {
+    private sessions;
+    create(config?: SessionConfig): Session;
+    get(id: string): Session | undefined;
+    getOrCreate(id: string, config?: Omit<SessionConfig, 'id'>): Session;
+    list(): Session[];
+    delete(id: string): boolean;
+    clear(): void;
+    toJSON(): Record<string, any>;
+}
+export declare function getSessionManager(): SessionManager;

package/dist/session/index.js

@@ -0,0 +1,250 @@
+"use strict";
+/**
+ * Session Management - Session, Run, and Trace tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = exports.Session = exports.Run = exports.Trace = void 0;
+exports.getSessionManager = getSessionManager;
+const crypto_1 = require("crypto");
+/**
+ * Trace represents a span within a run (e.g., LLM call, tool call)
+ */
+class Trace {
+    constructor(runId, config, parentId = null) {
+        this.endTime = null;
+        this.status = 'pending';
+        this.children = [];
+        this.id = config.id || (0, crypto_1.randomUUID)();
+        this.runId = runId;
+        this.name = config.name;
+        this.parentId = parentId;
+        this.startTime = Date.now();
+        this.attributes = config.attributes || {};
+    }
+    start() {
+        this.status = 'running';
+        return this;
+    }
+    complete(attributes) {
+        this.status = 'completed';
+        this.endTime = Date.now();
+        if (attributes) {
+            this.attributes = { ...this.attributes, ...attributes };
+        }
+        return this;
+    }
+    fail(error) {
+        this.status = 'failed';
+        this.endTime = Date.now();
+        if (error) {
+            this.attributes.error = error.message;
+            this.attributes.errorStack = error.stack;
+        }
+        return this;
+    }
+    get duration() {
+        if (this.endTime === null)
+            return null;
+        return this.endTime - this.startTime;
+    }
+    createChild(config) {
+        const child = new Trace(this.runId, config, this.id);
+        this.children.push(child);
+        return child;
+    }
+    getChildren() {
+        return [...this.children];
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            runId: this.runId,
+            name: this.name,
+            parentId: this.parentId,
+            startTime: this.startTime,
+            endTime: this.endTime,
+            duration: this.duration,
+            status: this.status,
+            attributes: this.attributes,
+            children: this.children.map(c => c.toJSON()),
+        };
+    }
+}
+exports.Trace = Trace;
+/**
+ * Run represents a single execution within a session (e.g., one chat call)
+ */
+class Run {
+    constructor(sessionId, config = {}) {
+        this.endTime = null;
+        this.status = 'pending';
+        this.error = null;
+        this.traces = [];
+        this.messages = [];
+        this.id = config.id || (0, crypto_1.randomUUID)();
+        this.sessionId = sessionId;
+        this.startTime = Date.now();
+        this.metadata = config.metadata || {};
+    }
+    start() {
+        this.status = 'running';
+        return this;
+    }
+    complete(metadata) {
+        this.status = 'completed';
+        this.endTime = Date.now();
+        if (metadata) {
+            this.metadata = { ...this.metadata, ...metadata };
+        }
+        return this;
+    }
+    fail(error) {
+        this.status = 'failed';
+        this.endTime = Date.now();
+        this.error = error;
+        return this;
+    }
+    get duration() {
+        if (this.endTime === null)
+            return null;
+        return this.endTime - this.startTime;
+    }
+    createTrace(config) {
+        const trace = new Trace(this.id, config);
+        this.traces.push(trace);
+        return trace;
+    }
+    addMessage(message) {
+        const msg = {
+            ...message,
+            id: (0, crypto_1.randomUUID)(),
+            timestamp: Date.now(),
+            runId: this.id,
+        };
+        this.messages.push(msg);
+        return msg;
+    }
+    getTraces() {
+        return [...this.traces];
+    }
+    getMessages() {
+        return [...this.messages];
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            sessionId: this.sessionId,
+            startTime: this.startTime,
+            endTime: this.endTime,
+            duration: this.duration,
+            status: this.status,
+            error: this.error?.message,
+            metadata: this.metadata,
+            traces: this.traces.map(t => t.toJSON()),
+            messageCount: this.messages.length,
+        };
+    }
+}
+exports.Run = Run;
+/**
+ * Session represents a conversation session with message history
+ */
+class Session {
+    constructor(config = {}) {
+        this._runs = [];
+        this._messages = [];
+        this.id = config.id || (0, crypto_1.randomUUID)();
+        this.createdAt = Date.now();
+        this.metadata = config.metadata || {};
+    }
+    createRun(config = {}) {
+        const run = new Run(this.id, config);
+        this._runs.push(run);
+        return run;
+    }
+    get runs() {
+        return [...this._runs];
+    }
+    get messages() {
+        return [...this._messages];
+    }
+    addMessage(message) {
+        const msg = {
+            ...message,
+            id: (0, crypto_1.randomUUID)(),
+            timestamp: Date.now(),
+        };
+        this._messages.push(msg);
+        return msg;
+    }
+    getMessagesForLLM() {
+        return this._messages.map(m => ({
+            role: m.role,
+            content: m.content,
+            ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {}),
+            ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
+        }));
+    }
+    clearMessages() {
+        this._messages = [];
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            createdAt: this.createdAt,
+            metadata: this.metadata,
+            runCount: this._runs.length,
+            messageCount: this._messages.length,
+            runs: this._runs.map(r => r.toJSON()),
+        };
+    }
+}
+exports.Session = Session;
+/**
+ * SessionManager for managing multiple sessions
+ */
+class SessionManager {
+    constructor() {
+        this.sessions = new Map();
+    }
+    create(config = {}) {
+        const session = new Session(config);
+        this.sessions.set(session.id, session);
+        return session;
+    }
+    get(id) {
+        return this.sessions.get(id);
+    }
+    getOrCreate(id, config = {}) {
+        let session = this.sessions.get(id);
+        if (!session) {
+            session = new Session({ ...config, id });
+            this.sessions.set(id, session);
+        }
+        return session;
+    }
+    list() {
+        return Array.from(this.sessions.values());
+    }
+    delete(id) {
+        return this.sessions.delete(id);
+    }
+    clear() {
+        this.sessions.clear();
+    }
+    toJSON() {
+        return {
+            sessionCount: this.sessions.size,
+            sessions: this.list().map(s => s.toJSON()),
+        };
+    }
+}
+exports.SessionManager = SessionManager;
+// Default session manager instance
+let defaultManager = null;
+function getSessionManager() {
+    if (!defaultManager) {
+        defaultManager = new SessionManager();
+    }
+    return defaultManager;
+}

package/dist/skills/index.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Skills System - Agent Skills standard implementation
+ */
+export interface SkillMetadata {
+    name: string;
+    description: string;
+    license?: string;
+    compatibility?: string;
+    allowedTools?: string[];
+    metadata?: Record<string, string>;
+}
+export interface Skill {
+    metadata: SkillMetadata;
+    instructions: string;
+    path?: string;
+}
+export interface SkillDiscoveryOptions {
+    paths?: string[];
+    includeSystem?: boolean;
+    includeUser?: boolean;
+    includeProject?: boolean;
+}
+/**
+ * Parse SKILL.md file
+ */
+export declare function parseSkillFile(content: string): Skill;
+/**
+ * Skill Manager - Load and manage skills
+ */
+export declare class SkillManager {
+    private skills;
+    private discoveryPaths;
+    constructor(options?: SkillDiscoveryOptions);
+    private setupDiscoveryPaths;
+    /**
+     * Discover and load skills from configured paths
+     */
+    discover(): Promise<Skill[]>;
+    /**
+     * Load a skill from a SKILL.md file
+     */
+    loadSkill(skillPath: string): Promise<Skill>;
+    /**
+     * Register a skill manually
+     */
+    register(skill: Skill): void;
+    /**
+     * Get a skill by name
+     */
+    get(name: string): Skill | undefined;
+    /**
+     * List all loaded skills
+     */
+    list(): Skill[];
+    /**
+     * Generate XML prompt for skills
+     */
+    generatePrompt(skillNames?: string[]): string;
+    /**
+     * Validate a skill
+     */
+    validate(skill: Skill): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+/**
+ * Create a skill manager
+ */
+export declare function createSkillManager(options?: SkillDiscoveryOptions): SkillManager;