praisonai 1.0.19 → 1.2.0

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/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;

package/dist/telemetry/index.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Telemetry - Usage tracking and analytics
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryCollector = void 0;
+exports.getTelemetry = getTelemetry;
+exports.enableTelemetry = enableTelemetry;
+exports.disableTelemetry = disableTelemetry;
+exports.cleanupTelemetry = cleanupTelemetry;
+/**
+ * Telemetry collector for tracking usage
+ */
+class TelemetryCollector {
+    constructor(config = {}) {
+        this.events = [];
+        this.enabled = config.enabled ?? this.checkEnabled();
+        this.endpoint = config.endpoint;
+        this.batchSize = config.batchSize ?? 100;
+        this.flushInterval = config.flushInterval ?? 60000;
+        this.sessionId = this.generateSessionId();
+        if (this.enabled && this.flushInterval > 0) {
+            this.startFlushTimer();
+        }
+    }
+    checkEnabled() {
+        const disabled = process.env.PRAISONAI_TELEMETRY_DISABLED === 'true' ||
+            process.env.PRAISONAI_DISABLE_TELEMETRY === 'true' ||
+            process.env.DO_NOT_TRACK === 'true';
+        return !disabled;
+    }
+    /**
+     * Track an event
+     */
+    track(name, properties) {
+        if (!this.enabled)
+            return;
+        const event = {
+            name,
+            timestamp: Date.now(),
+            properties,
+            userId: this.userId,
+            sessionId: this.sessionId
+        };
+        this.events.push(event);
+        if (this.events.length >= this.batchSize) {
+            this.flush();
+        }
+    }
+    /**
+     * Track feature usage
+     */
+    trackFeatureUsage(feature, metadata) {
+        this.track('feature_usage', { feature, ...metadata });
+    }
+    /**
+     * Track agent execution
+     */
+    trackAgentExecution(agentName, duration, success) {
+        this.track('agent_execution', { agentName, duration, success });
+    }
+    /**
+     * Track tool call
+     */
+    trackToolCall(toolName, duration, success) {
+        this.track('tool_call', { toolName, duration, success });
+    }
+    /**
+     * Track LLM call
+     */
+    trackLLMCall(provider, model, tokens, duration) {
+        this.track('llm_call', { provider, model, tokens, duration });
+    }
+    /**
+     * Track error
+     */
+    trackError(error, context) {
+        this.track('error', { error, ...context });
+    }
+    /**
+     * Set user ID
+     */
+    setUserId(userId) {
+        this.userId = userId;
+    }
+    /**
+     * Flush events
+     */
+    async flush() {
+        if (this.events.length === 0)
+            return;
+        const eventsToSend = [...this.events];
+        this.events = [];
+        if (this.endpoint) {
+            try {
+                await fetch(this.endpoint, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ events: eventsToSend })
+                });
+            }
+            catch (error) {
+                // Silently fail - never break user applications
+            }
+        }
+    }
+    /**
+     * Enable telemetry
+     */
+    enable() {
+        this.enabled = true;
+        this.startFlushTimer();
+    }
+    /**
+     * Disable telemetry
+     */
+    disable() {
+        this.enabled = false;
+        this.stopFlushTimer();
+        this.events = [];
+    }
+    /**
+     * Check if telemetry is enabled
+     */
+    isEnabled() {
+        return this.enabled;
+    }
+    /**
+     * Get pending events count
+     */
+    getPendingCount() {
+        return this.events.length;
+    }
+    /**
+     * Cleanup resources
+     */
+    cleanup() {
+        this.stopFlushTimer();
+        this.flush();
+    }
+    startFlushTimer() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setInterval(() => this.flush(), this.flushInterval);
+    }
+    stopFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+    }
+    generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+}
+exports.TelemetryCollector = TelemetryCollector;
+// Global telemetry instance
+let globalTelemetry = null;
+/**
+ * Get global telemetry instance
+ */
+function getTelemetry() {
+    if (!globalTelemetry) {
+        globalTelemetry = new TelemetryCollector();
+    }
+    return globalTelemetry;
+}
+/**
+ * Enable telemetry
+ */
+function enableTelemetry() {
+    getTelemetry().enable();
+}
+/**
+ * Disable telemetry
+ */
+function disableTelemetry() {
+    getTelemetry().disable();
+}
+/**
+ * Cleanup telemetry resources
+ */
+function cleanupTelemetry() {
+    if (globalTelemetry) {
+        globalTelemetry.cleanup();
+    }
+}

package/dist/tools/decorator.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Tool Decorator and Registry - Type-safe tool creation and management
+ */
+export interface ToolParameters {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        description?: string;
+        enum?: string[];
+        default?: any;
+    }>;
+    required?: string[];
+}
+export interface ToolConfig<TParams = any, TResult = any> {
+    name: string;
+    description?: string;
+    parameters?: ToolParameters | any;
+    category?: string;
+    execute: (params: TParams, context?: ToolContext) => Promise<TResult> | TResult;
+}
+export interface ToolContext {
+    agentName?: string;
+    sessionId?: string;
+    runId?: string;
+    signal?: AbortSignal;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    parameters: ToolParameters;
+    category?: string;
+}
+/**
+ * Tool class - Represents an executable tool
+ */
+export declare class FunctionTool<TParams = any, TResult = any> {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: ToolParameters;
+    readonly category?: string;
+    private readonly executeFn;
+    constructor(config: ToolConfig<TParams, TResult>);
+    private normalizeParameters;
+    private zodToJsonSchema;
+    private zodFieldToJsonSchema;
+    execute(params: TParams, context?: ToolContext): Promise<TResult>;
+    /**
+     * Get the tool definition for LLM
+     */
+    getDefinition(): ToolDefinition;
+    /**
+     * Get OpenAI-compatible tool format
+     */
+    toOpenAITool(): {
+        type: 'function';
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    };
+}
+/**
+ * Create a tool from a configuration object
+ */
+export declare function tool<TParams = any, TResult = any>(config: ToolConfig<TParams, TResult>): FunctionTool<TParams, TResult>;
+/**
+ * Tool Registry - Manages tool registration and lookup
+ */
+export declare class ToolRegistry {
+    private tools;
+    register(tool: FunctionTool, options?: {
+        overwrite?: boolean;
+    }): this;
+    get(name: string): FunctionTool | undefined;
+    has(name: string): boolean;
+    list(): FunctionTool[];
+    getByCategory(category: string): FunctionTool[];
+    getDefinitions(): ToolDefinition[];
+    toOpenAITools(): Array<{
+        type: 'function';
+        function: any;
+    }>;
+    delete(name: string): boolean;
+    clear(): void;
+}
+export declare function getRegistry(): ToolRegistry;
+export declare function registerTool(tool: FunctionTool, options?: {
+    overwrite?: boolean;
+}): void;
+export declare function getTool(name: string): FunctionTool | undefined;