praisonai 1.0.18 → 1.1.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/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;

package/dist/tools/decorator.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Tool Decorator and Registry - Type-safe tool creation and management
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = exports.FunctionTool = void 0;
+exports.tool = tool;
+exports.getRegistry = getRegistry;
+exports.registerTool = registerTool;
+exports.getTool = getTool;
+/**
+ * Tool class - Represents an executable tool
+ */
+class FunctionTool {
+    constructor(config) {
+        this.name = config.name;
+        this.description = config.description || `Function ${config.name}`;
+        this.parameters = this.normalizeParameters(config.parameters);
+        this.category = config.category;
+        this.executeFn = config.execute;
+    }
+    normalizeParameters(params) {
+        if (!params) {
+            return { type: 'object', properties: {}, required: [] };
+        }
+        // Check if it's a Zod schema
+        if (params && typeof params.parse === 'function' && typeof params._def === 'object') {
+            return this.zodToJsonSchema(params);
+        }
+        // Already a JSON schema
+        return params;
+    }
+    zodToJsonSchema(zodSchema) {
+        // Basic Zod to JSON Schema conversion
+        // For full support, use zod-to-json-schema package
+        const def = zodSchema._def;
+        if (def.typeName === 'ZodObject') {
+            const properties = {};
+            const required = [];
+            for (const [key, value] of Object.entries(def.shape())) {
+                const fieldDef = value._def;
+                properties[key] = this.zodFieldToJsonSchema(fieldDef);
+                // Check if field is required (not optional)
+                if (fieldDef.typeName !== 'ZodOptional' && fieldDef.typeName !== 'ZodDefault') {
+                    required.push(key);
+                }
+            }
+            return { type: 'object', properties, required };
+        }
+        return { type: 'object', properties: {}, required: [] };
+    }
+    zodFieldToJsonSchema(def) {
+        const typeName = def.typeName;
+        switch (typeName) {
+            case 'ZodString':
+                return { type: 'string', description: def.description };
+            case 'ZodNumber':
+                return { type: 'number', description: def.description };
+            case 'ZodBoolean':
+                return { type: 'boolean', description: def.description };
+            case 'ZodArray':
+                return { type: 'array', items: this.zodFieldToJsonSchema(def.type._def) };
+            case 'ZodEnum':
+                return { type: 'string', enum: def.values };
+            case 'ZodOptional':
+                return this.zodFieldToJsonSchema(def.innerType._def);
+            case 'ZodDefault':
+                const inner = this.zodFieldToJsonSchema(def.innerType._def);
+                inner.default = def.defaultValue();
+                return inner;
+            default:
+                return { type: 'string' };
+        }
+    }
+    async execute(params, context) {
+        // Validate parameters if we have a schema
+        // For now, just execute - validation can be added later
+        return this.executeFn(params, context);
+    }
+    /**
+     * Get the tool definition for LLM
+     */
+    getDefinition() {
+        return {
+            name: this.name,
+            description: this.description,
+            parameters: this.parameters,
+            category: this.category,
+        };
+    }
+    /**
+     * Get OpenAI-compatible tool format
+     */
+    toOpenAITool() {
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: this.parameters,
+            },
+        };
+    }
+}
+exports.FunctionTool = FunctionTool;
+/**
+ * Create a tool from a configuration object
+ */
+function tool(config) {
+    return new FunctionTool(config);
+}
+/**
+ * Tool Registry - Manages tool registration and lookup
+ */
+class ToolRegistry {
+    constructor() {
+        this.tools = new Map();
+    }
+    register(tool, options) {
+        if (this.tools.has(tool.name) && !options?.overwrite) {
+            throw new Error(`Tool '${tool.name}' is already registered. Use { overwrite: true } to replace.`);
+        }
+        this.tools.set(tool.name, tool);
+        return this;
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    has(name) {
+        return this.tools.has(name);
+    }
+    list() {
+        return Array.from(this.tools.values());
+    }
+    getByCategory(category) {
+        return this.list().filter(t => t.category === category);
+    }
+    getDefinitions() {
+        return this.list().map(t => t.getDefinition());
+    }
+    toOpenAITools() {
+        return this.list().map(t => t.toOpenAITool());
+    }
+    delete(name) {
+        return this.tools.delete(name);
+    }
+    clear() {
+        this.tools.clear();
+    }
+}
+exports.ToolRegistry = ToolRegistry;
+// Global registry instance
+let globalRegistry = null;
+function getRegistry() {
+    if (!globalRegistry) {
+        globalRegistry = new ToolRegistry();
+    }
+    return globalRegistry;
+}
+function registerTool(tool, options) {
+    getRegistry().register(tool, options);
+}
+function getTool(name) {
+    return getRegistry().get(name);
+}

package/dist/tools/index.d.ts

@@ -9,4 +9,6 @@ export declare class BaseTool implements Tool {
     constructor(name: string, description: string);
     execute(...args: any[]): Promise<any>;
 }
+export * from './decorator';
 export * from './arxivTools';
+export * from './mcpSse';

package/dist/tools/index.js

@@ -25,5 +25,8 @@ class BaseTool {
     }
 }
 exports.BaseTool = BaseTool;
+// Export decorator and registry
+__exportStar(require("./decorator"), exports);
 // Export all tool modules
 __exportStar(require("./arxivTools"), exports);
+__exportStar(require("./mcpSse"), exports);

package/dist/tools/mcpSse.d.ts

@@ -0,0 +1,41 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { BaseTool } from './index';
+export interface MCPToolInfo {
+    name: string;
+    description?: string;
+    inputSchema?: any;
+}
+export declare class MCPTool extends BaseTool {
+    private client;
+    private inputSchema;
+    constructor(info: MCPToolInfo, client: Client);
+    get schemaProperties(): Record<string, any> | undefined;
+    execute(args?: any): Promise<any>;
+    toOpenAITool(): {
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    };
+}
+export declare class MCP implements Iterable<MCPTool> {
+    private url;
+    private debug;
+    tools: MCPTool[];
+    private client;
+    constructor(url: string, debug?: boolean);
+    initialize(): Promise<void>;
+    [Symbol.iterator](): Iterator<MCPTool>;
+    toOpenAITools(): {
+        type: string;
+        function: {
+            name: string;
+            description: string;
+            parameters: any;
+        };
+    }[];
+    close(): Promise<void>;
+    get isConnected(): boolean;
+}

package/dist/tools/mcpSse.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP = exports.MCPTool = void 0;
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const sse_js_1 = require("@modelcontextprotocol/sdk/client/sse.js");
+const index_1 = require("./index");
+class MCPTool extends index_1.BaseTool {
+    constructor(info, client) {
+        super(info.name, info.description || `Call the ${info.name} tool`);
+        this.client = client;
+        this.inputSchema = info.inputSchema || { type: 'object', properties: {}, required: [] };
+    }
+    get schemaProperties() {
+        return this.inputSchema?.properties;
+    }
+    async execute(args = {}) {
+        try {
+            const result = await this.client.callTool({ name: this.name, arguments: args });
+            if (result.structuredContent) {
+                return result.structuredContent;
+            }
+            if (Array.isArray(result.content) && result.content.length > 0) {
+                const item = result.content[0];
+                if (typeof item.text === 'string')
+                    return item.text;
+            }
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to execute tool ${this.name}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    toOpenAITool() {
+        return {
+            type: 'function',
+            function: {
+                name: this.name,
+                description: this.description,
+                parameters: this.inputSchema
+            }
+        };
+    }
+}
+exports.MCPTool = MCPTool;
+class MCP {
+    constructor(url, debug = false) {
+        this.url = url;
+        this.debug = debug;
+        this.tools = [];
+        this.client = null;
+        if (debug) {
+            console.log(`MCP client initialized for URL: ${url}`);
+        }
+    }
+    async initialize() {
+        if (this.client) {
+            if (this.debug)
+                console.log('MCP client already initialized');
+            return;
+        }
+        try {
+            this.client = new index_js_1.Client({ name: 'praisonai-ts-mcp', version: '1.0.0' });
+            const transport = new sse_js_1.SSEClientTransport(new URL(this.url));
+            await this.client.connect(transport);
+            const { tools } = await this.client.listTools();
+            this.tools = tools.map((t) => new MCPTool({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema
+            }, this.client));
+            if (this.debug)
+                console.log(`Initialized MCP with ${this.tools.length} tools`);
+        }
+        catch (error) {
+            if (this.client) {
+                await this.client.close().catch(() => { });
+                this.client = null;
+            }
+            throw new Error(`Failed to initialize MCP client: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    [Symbol.iterator]() {
+        return this.tools[Symbol.iterator]();
+    }
+    toOpenAITools() {
+        return this.tools.map(t => t.toOpenAITool());
+    }
+    async close() {
+        if (this.client) {
+            try {
+                await this.client.close();
+            }
+            catch (error) {
+                if (this.debug) {
+                    console.warn('Error closing MCP client:', error);
+                }
+            }
+            finally {
+                this.client = null;
+                this.tools = [];
+            }
+        }
+    }
+    get isConnected() {
+        return this.client !== null;
+    }
+}
+exports.MCP = MCP;