overai 1.4.0

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;

package/dist/skills/index.js

@@ -0,0 +1,233 @@
+"use strict";
+/**
+ * Skills System - Agent Skills standard implementation
+ */
+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.SkillManager = void 0;
+exports.parseSkillFile = parseSkillFile;
+exports.createSkillManager = createSkillManager;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Parse SKILL.md file
+ */
+function parseSkillFile(content) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!frontmatterMatch) {
+        throw new Error('Invalid SKILL.md format: missing frontmatter');
+    }
+    const [, frontmatter, instructions] = frontmatterMatch;
+    const metadata = parseYamlFrontmatter(frontmatter);
+    if (!metadata.name || !metadata.description) {
+        throw new Error('Invalid SKILL.md: name and description are required');
+    }
+    return {
+        metadata: {
+            name: metadata.name,
+            description: metadata.description,
+            license: metadata.license,
+            compatibility: metadata.compatibility,
+            allowedTools: metadata['allowed-tools']?.split(/\s+/),
+            metadata: metadata.metadata
+        },
+        instructions: instructions.trim()
+    };
+}
+/**
+ * Simple YAML frontmatter parser
+ */
+function parseYamlFrontmatter(yaml) {
+    const result = {};
+    const lines = yaml.split('\n');
+    let currentKey = '';
+    let inMetadata = false;
+    const metadataObj = {};
+    for (const line of lines) {
+        if (line.startsWith('metadata:')) {
+            inMetadata = true;
+            continue;
+        }
+        if (inMetadata && line.startsWith('  ')) {
+            const match = line.match(/^\s+(\w+):\s*(.*)$/);
+            if (match) {
+                metadataObj[match[1]] = match[2].replace(/^["']|["']$/g, '');
+            }
+            continue;
+        }
+        else if (inMetadata && !line.startsWith('  ')) {
+            inMetadata = false;
+            result.metadata = metadataObj;
+        }
+        const match = line.match(/^(\S+):\s*(.*)$/);
+        if (match) {
+            currentKey = match[1];
+            result[currentKey] = match[2].replace(/^["']|["']$/g, '');
+        }
+    }
+    if (inMetadata) {
+        result.metadata = metadataObj;
+    }
+    return result;
+}
+/**
+ * Skill Manager - Load and manage skills
+ */
+class SkillManager {
+    constructor(options = {}) {
+        this.skills = new Map();
+        this.discoveryPaths = [];
+        this.setupDiscoveryPaths(options);
+    }
+    setupDiscoveryPaths(options) {
+        if (options.paths) {
+            this.discoveryPaths.push(...options.paths);
+        }
+        if (options.includeProject !== false) {
+            this.discoveryPaths.push('./.praison/skills');
+            this.discoveryPaths.push('./.claude/skills');
+        }
+        if (options.includeUser !== false) {
+            const home = process.env.HOME || process.env.USERPROFILE || '';
+            if (home) {
+                this.discoveryPaths.push(path.join(home, '.praison/skills'));
+            }
+        }
+        if (options.includeSystem) {
+            this.discoveryPaths.push('/etc/praison/skills');
+        }
+    }
+    /**
+     * Discover and load skills from configured paths
+     */
+    async discover() {
+        const discovered = [];
+        for (const basePath of this.discoveryPaths) {
+            if (!fs.existsSync(basePath))
+                continue;
+            const entries = fs.readdirSync(basePath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const skillPath = path.join(basePath, entry.name, 'SKILL.md');
+                    if (fs.existsSync(skillPath)) {
+                        try {
+                            const skill = await this.loadSkill(skillPath);
+                            skill.path = path.join(basePath, entry.name);
+                            discovered.push(skill);
+                            this.skills.set(skill.metadata.name, skill);
+                        }
+                        catch (e) {
+                            // Skip invalid skills
+                        }
+                    }
+                }
+            }
+        }
+        return discovered;
+    }
+    /**
+     * Load a skill from a SKILL.md file
+     */
+    async loadSkill(skillPath) {
+        const content = fs.readFileSync(skillPath, 'utf-8');
+        return parseSkillFile(content);
+    }
+    /**
+     * Register a skill manually
+     */
+    register(skill) {
+        this.skills.set(skill.metadata.name, skill);
+    }
+    /**
+     * Get a skill by name
+     */
+    get(name) {
+        return this.skills.get(name);
+    }
+    /**
+     * List all loaded skills
+     */
+    list() {
+        return Array.from(this.skills.values());
+    }
+    /**
+     * Generate XML prompt for skills
+     */
+    generatePrompt(skillNames) {
+        const skillsToInclude = skillNames
+            ? skillNames.map(n => this.skills.get(n)).filter(Boolean)
+            : this.list();
+        if (skillsToInclude.length === 0)
+            return '';
+        const parts = ['<skills>'];
+        for (const skill of skillsToInclude) {
+            parts.push(`  <skill name="${skill.metadata.name}">`);
+            parts.push(`    <description>${skill.metadata.description}</description>`);
+            parts.push(`    <instructions>${skill.instructions}</instructions>`);
+            parts.push('  </skill>');
+        }
+        parts.push('</skills>');
+        return parts.join('\n');
+    }
+    /**
+     * Validate a skill
+     */
+    validate(skill) {
+        const errors = [];
+        if (!skill.metadata.name) {
+            errors.push('Missing required field: name');
+        }
+        else if (!/^[a-z0-9-]{1,64}$/.test(skill.metadata.name)) {
+            errors.push('Invalid name: must be 1-64 lowercase chars, numbers, or hyphens');
+        }
+        if (!skill.metadata.description) {
+            errors.push('Missing required field: description');
+        }
+        else if (skill.metadata.description.length > 1024) {
+            errors.push('Description too long: max 1024 characters');
+        }
+        if (skill.instructions.length > 5000) {
+            errors.push('Instructions too long: max 5000 characters');
+        }
+        return { valid: errors.length === 0, errors };
+    }
+}
+exports.SkillManager = SkillManager;
+/**
+ * Create a skill manager
+ */
+function createSkillManager(options) {
+    return new SkillManager(options);
+}

package/dist/task/index.d.ts

@@ -0,0 +1,25 @@
+export interface TaskConfig {
+    priority?: number;
+    deadline?: Date;
+    dependencies?: string[];
+    metadata?: Record<string, any>;
+}
+export interface Task {
+    id: string;
+    name: string;
+    description: string;
+    status: 'pending' | 'in-progress' | 'completed' | 'failed';
+    config: TaskConfig;
+    execute(): Promise<void>;
+    cancel(): Promise<void>;
+}
+export declare class BaseTask implements Task {
+    id: string;
+    name: string;
+    description: string;
+    status: 'pending' | 'in-progress' | 'completed' | 'failed';
+    config: TaskConfig;
+    constructor(id: string, name: string, description: string, config?: TaskConfig);
+    execute(): Promise<void>;
+    cancel(): Promise<void>;
+}

package/dist/task/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTask = void 0;
+class BaseTask {
+    constructor(id, name, description, config = {}) {
+        this.id = id;
+        this.name = name;
+        this.description = description;
+        this.status = 'pending';
+        this.config = {
+            priority: 1,
+            ...config
+        };
+    }
+    async execute() {
+        this.status = 'in-progress';
+        try {
+            // Implement task execution logic here
+            this.status = 'completed';
+        }
+        catch (error) {
+            this.status = 'failed';
+            throw error;
+        }
+    }
+    async cancel() {
+        if (this.status === 'in-progress') {
+            this.status = 'failed';
+        }
+    }
+}
+exports.BaseTask = BaseTask;

package/dist/task/task.js

@@ -0,0 +1 @@
+"use strict";