overai 1.4.0

package/dist/integrations/postgres.js

@@ -0,0 +1,396 @@
+"use strict";
+/**
+ * Natural Language Postgres
+ *
+ * Provides NL->SQL capabilities for querying PostgreSQL databases.
+ */
+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.NLPostgresClient = void 0;
+exports.createNLPostgres = createNLPostgres;
+exports.createPostgresTool = createPostgresTool;
+/**
+ * Create a Natural Language Postgres client.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createNLPostgres } from 'praisonai/integrations/postgres';
+ *
+ * const db = await createNLPostgres({
+ *   connectionUrl: process.env.DATABASE_URL!,
+ *   readOnly: true
+ * });
+ *
+ * // Query with natural language
+ * const result = await db.query('Show me all users who signed up last month');
+ * console.log(result.rows);
+ * ```
+ *
+ * @example With schema introspection
+ * ```typescript
+ * const db = await createNLPostgres({ connectionUrl: '...' });
+ *
+ * // Get schema information
+ * const schema = await db.getSchema();
+ * console.log('Tables:', schema.map(t => t.name));
+ *
+ * // Query with context
+ * const result = await db.query('How many orders were placed today?');
+ * ```
+ */
+async function createNLPostgres(config) {
+    const client = new NLPostgresClient(config);
+    await client.connect();
+    return client;
+}
+class NLPostgresClient {
+    constructor(config) {
+        this.pool = null;
+        this.schema = [];
+        this.connected = false;
+        this.config = {
+            schema: 'public',
+            readOnly: true,
+            maxRows: 100,
+            timeout: 30000,
+            ...config,
+        };
+    }
+    /**
+     * Connect to the database.
+     */
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            // @ts-ignore - Optional dependency
+            const { Pool } = await Promise.resolve().then(() => __importStar(require('pg')));
+            this.pool = new Pool({
+                connectionString: this.config.connectionUrl,
+                statement_timeout: this.config.timeout,
+            });
+            // Test connection
+            await this.pool.query('SELECT 1');
+            this.connected = true;
+            // Load schema
+            await this.loadSchema();
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to PostgreSQL: ${error.message}. ` +
+                'Install with: npm install pg');
+        }
+    }
+    /**
+     * Disconnect from the database.
+     */
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.connected = false;
+        }
+    }
+    /**
+     * Load database schema.
+     */
+    async loadSchema() {
+        const schemaQuery = `
+      SELECT 
+        t.table_name,
+        c.column_name,
+        c.data_type,
+        c.is_nullable,
+        c.column_default,
+        pgd.description
+      FROM information_schema.tables t
+      JOIN information_schema.columns c 
+        ON t.table_name = c.table_name 
+        AND t.table_schema = c.table_schema
+      LEFT JOIN pg_catalog.pg_statio_all_tables st
+        ON st.relname = t.table_name
+      LEFT JOIN pg_catalog.pg_description pgd
+        ON pgd.objoid = st.relid
+        AND pgd.objsubid = c.ordinal_position
+      WHERE t.table_schema = $1
+        AND t.table_type = 'BASE TABLE'
+      ORDER BY t.table_name, c.ordinal_position
+    `;
+        const result = await this.pool.query(schemaQuery, [this.config.schema]);
+        const tableMap = new Map();
+        for (const row of result.rows) {
+            // Check allowed/blocked tables
+            if (this.config.allowedTables && !this.config.allowedTables.includes(row.table_name)) {
+                continue;
+            }
+            if (this.config.blockedTables && this.config.blockedTables.includes(row.table_name)) {
+                continue;
+            }
+            if (!tableMap.has(row.table_name)) {
+                tableMap.set(row.table_name, {
+                    name: row.table_name,
+                    columns: [],
+                });
+            }
+            const table = tableMap.get(row.table_name);
+            table.columns.push({
+                name: row.column_name,
+                type: row.data_type,
+                nullable: row.is_nullable === 'YES',
+                defaultValue: row.column_default,
+                description: row.description,
+            });
+        }
+        this.schema = Array.from(tableMap.values());
+    }
+    /**
+     * Get the database schema.
+     */
+    getSchema() {
+        return this.schema;
+    }
+    /**
+     * Get schema as a string for LLM context.
+     */
+    getSchemaContext() {
+        let context = 'Database Schema:\n\n';
+        for (const table of this.schema) {
+            context += `Table: ${table.name}\n`;
+            context += 'Columns:\n';
+            for (const col of table.columns) {
+                context += `  - ${col.name} (${col.type}${col.nullable ? ', nullable' : ''})`;
+                if (col.description) {
+                    context += ` - ${col.description}`;
+                }
+                context += '\n';
+            }
+            context += '\n';
+        }
+        return context;
+    }
+    /**
+     * Execute a raw SQL query.
+     */
+    async executeSQL(sql) {
+        if (!this.connected) {
+            throw new Error('Not connected to database');
+        }
+        // Safety check for read-only mode
+        if (this.config.readOnly) {
+            const normalizedSQL = sql.trim().toLowerCase();
+            const writeOperations = ['insert', 'update', 'delete', 'drop', 'alter', 'create', 'truncate'];
+            for (const op of writeOperations) {
+                if (normalizedSQL.startsWith(op)) {
+                    throw new Error(`Write operation '${op}' not allowed in read-only mode`);
+                }
+            }
+        }
+        // Add LIMIT if not present
+        const hasLimit = /\blimit\s+\d+/i.test(sql);
+        const finalSQL = hasLimit ? sql : `${sql} LIMIT ${this.config.maxRows}`;
+        const startTime = Date.now();
+        const result = await this.pool.query(finalSQL);
+        const executionTime = Date.now() - startTime;
+        return {
+            rows: result.rows,
+            rowCount: result.rowCount,
+            fields: result.fields?.map((f) => ({ name: f.name, type: f.dataTypeID?.toString() })) || [],
+            executionTime,
+        };
+    }
+    /**
+     * Query the database using natural language.
+     */
+    async query(naturalLanguageQuery, options) {
+        const model = options?.model || 'gpt-4o-mini';
+        // Generate SQL from natural language
+        const { generateText } = await Promise.resolve().then(() => __importStar(require('../ai/generate-text')));
+        const schemaContext = this.getSchemaContext();
+        const prompt = `You are a SQL expert. Convert the following natural language query to PostgreSQL SQL.
+
+${schemaContext}
+
+Rules:
+1. Only generate SELECT queries (read-only)
+2. Use proper PostgreSQL syntax
+3. Include appropriate JOINs when needed
+4. Add reasonable LIMIT if not specified
+5. Return ONLY the SQL query, no explanations
+
+Natural language query: ${naturalLanguageQuery}
+
+SQL:`;
+        const result = await generateText({
+            model,
+            prompt,
+            temperature: 0,
+        });
+        // Extract SQL from response
+        let sql = result.text.trim();
+        // Remove markdown code blocks if present
+        if (sql.startsWith('```')) {
+            sql = sql.replace(/```sql?\n?/g, '').replace(/```/g, '').trim();
+        }
+        // Execute the SQL
+        const queryResult = await this.executeSQL(sql);
+        return {
+            query: naturalLanguageQuery,
+            sql,
+            result: queryResult,
+        };
+    }
+    /**
+     * Chat with the database (conversational interface).
+     */
+    async chat(message, options) {
+        const model = options?.model || 'gpt-4o-mini';
+        const history = options?.history || [];
+        const { generateText } = await Promise.resolve().then(() => __importStar(require('../ai/generate-text')));
+        const schemaContext = this.getSchemaContext();
+        const systemPrompt = `You are a helpful database assistant. You can query a PostgreSQL database to answer questions.
+
+${schemaContext}
+
+When the user asks a question that requires database data:
+1. Generate a SQL query to get the data
+2. Execute it using the query tool
+3. Summarize the results in natural language
+
+Always be helpful and explain your findings clearly.`;
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            ...history.map(h => ({ role: h.role, content: h.content })),
+            { role: 'user', content: message },
+        ];
+        // Define the query tool
+        const tools = {
+            query_database: {
+                description: 'Execute a SQL query on the PostgreSQL database',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        sql: {
+                            type: 'string',
+                            description: 'The SQL query to execute (SELECT only)',
+                        },
+                    },
+                    required: ['sql'],
+                },
+                execute: async ({ sql }) => {
+                    try {
+                        const result = await this.executeSQL(sql);
+                        return JSON.stringify({
+                            rowCount: result.rowCount,
+                            rows: result.rows.slice(0, 10), // Limit for context
+                            hasMore: result.rowCount > 10,
+                        });
+                    }
+                    catch (error) {
+                        return JSON.stringify({ error: error.message });
+                    }
+                },
+            },
+        };
+        const result = await generateText({
+            model,
+            messages,
+            tools,
+            maxSteps: 3,
+        });
+        return result.text;
+    }
+    /**
+     * Inspect the database structure.
+     */
+    async inspect() {
+        const sampleData = {};
+        for (const table of this.schema) {
+            try {
+                const result = await this.executeSQL(`SELECT * FROM ${table.name} LIMIT 3`);
+                sampleData[table.name] = result.rows;
+            }
+            catch {
+                sampleData[table.name] = [];
+            }
+        }
+        return {
+            tables: this.schema.length,
+            schema: this.schema,
+            sampleData,
+        };
+    }
+}
+exports.NLPostgresClient = NLPostgresClient;
+/**
+ * Create a tool for querying Postgres with natural language.
+ *
+ * @example Use with an agent
+ * ```typescript
+ * import { Agent } from 'praisonai';
+ * import { createPostgresTool } from 'praisonai/integrations/postgres';
+ *
+ * const dbTool = await createPostgresTool({
+ *   connectionUrl: process.env.DATABASE_URL!
+ * });
+ *
+ * const agent = new Agent({
+ *   instructions: 'You can query the database',
+ *   tools: [dbTool]
+ * });
+ * ```
+ */
+async function createPostgresTool(config) {
+    const client = await createNLPostgres(config);
+    return {
+        name: 'query_database',
+        description: `Query the PostgreSQL database using natural language. Available tables: ${client.getSchema().map(t => t.name).join(', ')}`,
+        parameters: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Natural language query describing what data you want',
+                },
+            },
+            required: ['query'],
+        },
+        execute: async ({ query }) => {
+            const result = await client.query(query);
+            return JSON.stringify({
+                sql: result.sql,
+                rowCount: result.result.rowCount,
+                rows: result.result.rows,
+            });
+        },
+    };
+}

package/dist/integrations/slack.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Slack Integration
+ *
+ * Provides Slack bot adapters for building AI-powered Slack bots.
+ */
+export interface SlackConfig {
+    /** Slack Bot Token (xoxb-...) */
+    botToken: string;
+    /** Slack App Token for Socket Mode (xapp-...) */
+    appToken?: string;
+    /** Slack Signing Secret for webhook verification */
+    signingSecret?: string;
+    /** Enable Socket Mode (default: false, uses webhooks) */
+    socketMode?: boolean;
+}
+export interface SlackMessage {
+    /** Channel ID */
+    channel: string;
+    /** User ID */
+    user: string;
+    /** Message text */
+    text: string;
+    /** Thread timestamp (for replies) */
+    threadTs?: string;
+    /** Message timestamp */
+    ts: string;
+    /** Bot ID (if from a bot) */
+    botId?: string;
+}
+export interface SlackResponse {
+    /** Response text */
+    text: string;
+    /** Blocks for rich formatting */
+    blocks?: any[];
+    /** Thread timestamp (to reply in thread) */
+    threadTs?: string;
+    /** Unfurl links */
+    unfurlLinks?: boolean;
+    /** Unfurl media */
+    unfurlMedia?: boolean;
+}
+export interface SlackEventHandler {
+    /** Handle a message event */
+    onMessage: (message: SlackMessage) => Promise<SlackResponse | null>;
+    /** Handle an app mention event */
+    onAppMention?: (message: SlackMessage) => Promise<SlackResponse | null>;
+    /** Handle a reaction added event */
+    onReactionAdded?: (event: any) => Promise<void>;
+}
+/**
+ * Create a Slack bot adapter.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createSlackBot } from 'praisonai/integrations/slack';
+ * import { Agent } from 'praisonai';
+ *
+ * const agent = new Agent({ instructions: 'You are a helpful Slack bot' });
+ *
+ * const bot = createSlackBot({
+ *   botToken: process.env.SLACK_BOT_TOKEN!,
+ *   signingSecret: process.env.SLACK_SIGNING_SECRET!
+ * });
+ *
+ * bot.onMessage(async (message) => {
+ *   const response = await agent.chat(message.text);
+ *   return { text: response, threadTs: message.ts };
+ * });
+ *
+ * // Start webhook server
+ * bot.listen(3000);
+ * ```
+ *
+ * @example With Socket Mode
+ * ```typescript
+ * const bot = createSlackBot({
+ *   botToken: process.env.SLACK_BOT_TOKEN!,
+ *   appToken: process.env.SLACK_APP_TOKEN!,
+ *   socketMode: true
+ * });
+ *
+ * bot.onMessage(async (message) => {
+ *   return { text: 'Hello!' };
+ * });
+ *
+ * await bot.start();
+ * ```
+ */
+export declare function createSlackBot(config: SlackConfig): SlackBot;
+export declare class SlackBot {
+    private config;
+    private messageHandler?;
+    private mentionHandler?;
+    private reactionHandler?;
+    private boltApp;
+    constructor(config: SlackConfig);
+    /**
+     * Set the message handler.
+     */
+    onMessage(handler: (message: SlackMessage) => Promise<SlackResponse | null>): this;
+    /**
+     * Set the app mention handler.
+     */
+    onAppMention(handler: (message: SlackMessage) => Promise<SlackResponse | null>): this;
+    /**
+     * Set the reaction handler.
+     */
+    onReactionAdded(handler: (event: any) => Promise<void>): this;
+    /**
+     * Initialize the Bolt app (lazy load).
+     */
+    private initBolt;
+    /**
+     * Start the bot (Socket Mode).
+     */
+    start(): Promise<void>;
+    /**
+     * Start webhook server.
+     */
+    listen(port?: number): Promise<void>;
+    /**
+     * Stop the bot.
+     */
+    stop(): Promise<void>;
+    /**
+     * Send a message to a channel.
+     */
+    sendMessage(channel: string, text: string, options?: Partial<SlackResponse>): Promise<void>;
+    /**
+     * Get an Express middleware for webhook handling.
+     */
+    getExpressMiddleware(): any;
+}
+/**
+ * Verify Slack request signature.
+ */
+export declare function verifySlackSignature(signingSecret: string, signature: string, timestamp: string, body: string): boolean;
+/**
+ * Parse Slack message text to extract mentions and links.
+ */
+export declare function parseSlackMessage(text: string): {
+    mentions: string[];
+    links: string[];
+    cleanText: string;
+};