praisonai 1.0.0 → 1.0.2

package/dist/llm/index.d.ts

@@ -0,0 +1,27 @@
+export interface LLMConfig {
+    model: string;
+    temperature?: number;
+    maxTokens?: number;
+    apiKey?: string;
+    baseURL?: string;
+}
+export interface LLMResponse {
+    text: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    metadata?: Record<string, any>;
+}
+export interface LLM {
+    config: LLMConfig;
+    generate(prompt: string): Promise<LLMResponse>;
+    generateStream(prompt: string): AsyncGenerator<string, void, unknown>;
+}
+export declare class BaseLLM implements LLM {
+    config: LLMConfig;
+    constructor(config: LLMConfig);
+    generate(prompt: string): Promise<LLMResponse>;
+    generateStream(prompt: string): AsyncGenerator<string, void, unknown>;
+}

package/dist/llm/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseLLM = void 0;
+class BaseLLM {
+    constructor(config) {
+        this.config = config;
+    }
+    async generate(prompt) {
+        throw new Error('Method not implemented.');
+    }
+    async *generateStream(prompt) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.BaseLLM = BaseLLM;

package/dist/llm/llm.js

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

package/dist/llm/openai.d.ts

@@ -0,0 +1,15 @@
+export interface LLMResponse {
+    content: string;
+    role: string;
+}
+export declare class OpenAIService {
+    private client;
+    private model;
+    constructor(model?: string);
+    generateText(prompt: string, systemPrompt?: string, temperature?: number): Promise<string>;
+    streamText(prompt: string, systemPrompt: string | undefined, temperature: number | undefined, onToken: (token: string) => void): Promise<void>;
+    chatCompletion(messages: Array<{
+        role: 'system' | 'user' | 'assistant';
+        content: string;
+    }>, temperature?: number): Promise<LLMResponse>;
+}

package/dist/llm/openai.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIService = void 0;
+const openai_1 = __importDefault(require("openai"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const logger_1 = require("../utils/logger");
+dotenv_1.default.config();
+class OpenAIService {
+    constructor(model = 'gpt-4o-mini') {
+        if (!process.env.OPENAI_API_KEY) {
+            throw new Error('OPENAI_API_KEY not found in environment variables');
+        }
+        this.client = new openai_1.default({
+            apiKey: process.env.OPENAI_API_KEY
+        });
+        this.model = model;
+        logger_1.Logger.debug(`OpenAIService initialized with model: ${model}`);
+    }
+    async generateText(prompt, systemPrompt = '', temperature = 0.7) {
+        logger_1.Logger.debug('Generating text with OpenAI', {
+            model: this.model,
+            temperature,
+            systemPrompt,
+            prompt
+        });
+        const completion = await this.client.chat.completions.create({
+            model: this.model,
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: prompt }
+            ],
+            temperature,
+        });
+        const response = completion.choices[0].message.content || '';
+        logger_1.Logger.debug('OpenAI response received', { response });
+        return response;
+    }
+    async streamText(prompt, systemPrompt = '', temperature = 0.7, onToken) {
+        logger_1.Logger.debug('Streaming text with OpenAI', {
+            model: this.model,
+            temperature,
+            systemPrompt,
+            prompt
+        });
+        const stream = await this.client.chat.completions.create({
+            model: this.model,
+            messages: [
+                { role: 'system', content: systemPrompt },
+                { role: 'user', content: prompt }
+            ],
+            temperature,
+            stream: true,
+        });
+        let fullResponse = '';
+        for await (const chunk of stream) {
+            const content = chunk.choices[0]?.delta?.content;
+            if (content) {
+                onToken(content);
+                fullResponse += content;
+            }
+        }
+        logger_1.Logger.debug('OpenAI streaming completed', { fullResponse });
+    }
+    async chatCompletion(messages, temperature = 0.7) {
+        logger_1.Logger.debug('Chat completion with OpenAI', {
+            model: this.model,
+            temperature,
+            messages
+        });
+        const completion = await this.client.chat.completions.create({
+            model: this.model,
+            messages,
+            temperature,
+        });
+        const response = {
+            content: completion.choices[0].message.content || '',
+            role: completion.choices[0].message.role
+        };
+        logger_1.Logger.debug('OpenAI chat completion response received', { response });
+        return response;
+    }
+}
+exports.OpenAIService = OpenAIService;

package/dist/main.js

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

package/dist/memory/index.d.ts

@@ -0,0 +1,24 @@
+export interface Memory {
+    id: string;
+    content: any;
+    timestamp: Date;
+    metadata: Record<string, any>;
+}
+export interface MemoryStore {
+    add(memory: Memory): void;
+    get(id: string): Memory | undefined;
+    search(query: string): Memory[];
+    update(id: string, memory: Partial<Memory>): boolean;
+    delete(id: string): boolean;
+    clear(): void;
+}
+export declare class BaseMemoryStore implements MemoryStore {
+    private memories;
+    constructor();
+    add(memory: Memory): void;
+    get(id: string): Memory | undefined;
+    search(query: string): Memory[];
+    update(id: string, update: Partial<Memory>): boolean;
+    delete(id: string): boolean;
+    clear(): void;
+}

package/dist/memory/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseMemoryStore = void 0;
+class BaseMemoryStore {
+    constructor() {
+        this.memories = new Map();
+    }
+    add(memory) {
+        this.memories.set(memory.id, memory);
+    }
+    get(id) {
+        return this.memories.get(id);
+    }
+    search(query) {
+        return Array.from(this.memories.values()).filter(m => JSON.stringify(m).toLowerCase().includes(query.toLowerCase()));
+    }
+    update(id, update) {
+        const existing = this.memories.get(id);
+        if (!existing)
+            return false;
+        this.memories.set(id, { ...existing, ...update });
+        return true;
+    }
+    delete(id) {
+        return this.memories.delete(id);
+    }
+    clear() {
+        this.memories.clear();
+    }
+}
+exports.BaseMemoryStore = BaseMemoryStore;

package/dist/memory/memory.js

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

package/dist/process/index.d.ts

@@ -0,0 +1,25 @@
+export interface ProcessConfig {
+    maxRetries?: number;
+    timeout?: number;
+    metadata?: Record<string, any>;
+}
+export interface Process {
+    id: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    config: ProcessConfig;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): string;
+    getResult(): any;
+}
+export declare class BaseProcess implements Process {
+    id: string;
+    status: 'pending' | 'running' | 'completed' | 'failed';
+    config: ProcessConfig;
+    private result;
+    constructor(id: string, config?: ProcessConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): string;
+    getResult(): any;
+}

package/dist/process/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseProcess = void 0;
+class BaseProcess {
+    constructor(id, config = {}) {
+        this.id = id;
+        this.status = 'pending';
+        this.config = {
+            maxRetries: 3,
+            timeout: 30000,
+            ...config
+        };
+    }
+    async start() {
+        this.status = 'running';
+        try {
+            // Implement process logic here
+            this.status = 'completed';
+        }
+        catch (error) {
+            this.status = 'failed';
+            throw error;
+        }
+    }
+    async stop() {
+        if (this.status === 'running') {
+            this.status = 'failed';
+        }
+    }
+    getStatus() {
+        return this.status;
+    }
+    getResult() {
+        return this.result;
+    }
+}
+exports.BaseProcess = BaseProcess;

package/dist/process/process.js

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

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

package/dist/tools/arxivTools.d.ts

@@ -0,0 +1,19 @@
+import { BaseTool } from './index';
+export interface ArxivPaper {
+    id: string;
+    title: string;
+    authors: string[];
+    summary: string;
+    published: string;
+    updated: string;
+    link: string;
+}
+export declare class ArxivSearchTool extends BaseTool {
+    private parser;
+    constructor();
+    execute(query: string, maxResults?: number): Promise<ArxivPaper[]>;
+}
+export declare class ArxivDownloadTool extends BaseTool {
+    constructor();
+    execute(paperId: string): Promise<Buffer>;
+}

package/dist/tools/arxivTools.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArxivDownloadTool = exports.ArxivSearchTool = void 0;
+const axios_1 = __importDefault(require("axios"));
+const index_1 = require("./index");
+const fast_xml_parser_1 = require("fast-xml-parser");
+class ArxivSearchTool extends index_1.BaseTool {
+    constructor() {
+        super('arxiv-search', 'Search for academic papers on arXiv');
+        this.parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '@_'
+        });
+    }
+    async execute(query, maxResults = 10) {
+        try {
+            const response = await axios_1.default.get(`http://export.arxiv.org/api/query`, {
+                params: {
+                    search_query: encodeURIComponent(query),
+                    max_results: maxResults,
+                    sortBy: 'lastUpdatedDate',
+                    sortOrder: 'descending'
+                }
+            });
+            const parsed = this.parser.parse(response.data);
+            const entries = parsed.feed.entry;
+            if (!entries) {
+                return [];
+            }
+            // Handle both single and multiple entries
+            const entriesArray = Array.isArray(entries) ? entries : [entries];
+            return entriesArray.map((entry) => ({
+                id: entry.id.split('/abs/')[1],
+                title: entry.title.replace(/\s+/g, ' ').trim(),
+                authors: Array.isArray(entry.author)
+                    ? entry.author.map((a) => a.name)
+                    : [entry.author.name],
+                summary: entry.summary.replace(/\s+/g, ' ').trim(),
+                published: entry.published,
+                updated: entry.updated,
+                link: entry.id
+            }));
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to search arXiv: ${error.message}`);
+            }
+            throw new Error('Failed to search arXiv: Unknown error');
+        }
+    }
+}
+exports.ArxivSearchTool = ArxivSearchTool;
+class ArxivDownloadTool extends index_1.BaseTool {
+    constructor() {
+        super('arxiv-download', 'Download PDF of an arXiv paper');
+    }
+    async execute(paperId) {
+        try {
+            const response = await axios_1.default.get(`https://arxiv.org/pdf/${paperId}.pdf`, {
+                responseType: 'arraybuffer'
+            });
+            return Buffer.from(response.data);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`Failed to download paper: ${error.message}`);
+            }
+            throw new Error('Failed to download paper: Unknown error');
+        }
+    }
+}
+exports.ArxivDownloadTool = ArxivDownloadTool;

package/dist/tools/index.d.ts

@@ -0,0 +1,12 @@
+export interface Tool {
+    name: string;
+    description: string;
+    execute(...args: any[]): Promise<any>;
+}
+export declare class BaseTool implements Tool {
+    name: string;
+    description: string;
+    constructor(name: string, description: string);
+    execute(...args: any[]): Promise<any>;
+}
+export * from './arxivTools';

package/dist/tools/index.js

@@ -0,0 +1,29 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTool = void 0;
+class BaseTool {
+    constructor(name, description) {
+        this.name = name;
+        this.description = description;
+    }
+    async execute(...args) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.BaseTool = BaseTool;
+// Export all tool modules
+__exportStar(require("./arxivTools"), exports);

package/dist/tools/test.js

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

package/dist/utils/logger.d.ts

@@ -0,0 +1,15 @@
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export declare class Logger {
+    private static level;
+    private static getCircularReplacer;
+    private static formatContext;
+    static debug(message: string, context?: any): void;
+    static info(message: string, context?: any): void;
+    static warn(message: string, context?: any): void;
+    static error(message: string, context?: any): void;
+}

package/dist/utils/logger.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    static getCircularReplacer() {
+        const seen = new WeakSet();
+        return (key, value) => {
+            if (typeof value === 'object' && value !== null) {
+                if (seen.has(value)) {
+                    return '[Circular]';
+                }
+                seen.add(value);
+            }
+            return value;
+        };
+    }
+    static formatContext(context) {
+        try {
+            return JSON.stringify(context, this.getCircularReplacer(), 2);
+        }
+        catch (error) {
+            return '[Unable to stringify context]';
+        }
+    }
+    static debug(message, context) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.log(`[DEBUG] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+        }
+    }
+    static info(message, context) {
+        if (this.level <= LogLevel.INFO) {
+            console.log(`[INFO] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+        }
+    }
+    static warn(message, context) {
+        if (this.level <= LogLevel.WARN) {
+            console.warn(`[WARN] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+        }
+    }
+    static error(message, context) {
+        if (this.level <= LogLevel.ERROR) {
+            console.error(`[ERROR] ${message}${context ? '\nContext: ' + this.formatContext(context) : ''}`);
+        }
+    }
+}
+exports.Logger = Logger;
+Logger.level = process.env.LOGLEVEL === 'debug' ? LogLevel.DEBUG : LogLevel.INFO;

package/package.json

@@ -1,12 +1,73 @@
 {
   "name": "praisonai",
-  "version": "1.0.0",
-  "description": "AI development tools and utilities for modern JavaScript applications",
-  "main": "index.js",
+  "version": "1.0.2",
+  "description": "PraisonAI TypeScript AI Agents Framework - Node.js, npm, and Javascript AI Agents Framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint . --ext .ts",
+    "prepare": "npm run build",
+    "start": "ts-node src/main.ts",
+    "dev": "ts-node-dev --respawn src/main.ts",
+    "example:arxiv": "ts-node examples/tools/arxiv-tools.ts",
+    "clean": "rimraf dist",
+    "prebuild": "npm run clean"
   },
-  "keywords": ["ai", "development", "tools", "javascript"],
-  "author": "mervinpraison",
-  "license": "MIT"
+  "keywords": [
+    "ai",
+    "agent",
+    "ai agent",
+    "ai agents",
+    "typescript ai",
+    "typescript ai agent",
+    "javascript ai agent",
+    "typescript ai agents",
+    "javascript ai agents",
+    "npm ai agent framework",
+    "npm ai agents framework",
+    "node ai agent framework",
+    "node ai agents framework",
+    "praisonai",
+    "ai agents framework",
+    "typescript ai agents framework",
+    "javascript ai agents framework",
+    "ai framework",
+    "typescript ai framework",
+    "javascript ai framework",
+    "ai agent framework",
+    "typescript ai agent framework",
+    "javascript ai agent framework"
+  ],
+  "author": "Mervin Praison",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.12.0",
+    "@typescript-eslint/eslint-plugin": "^8.22.0",
+    "@typescript-eslint/parser": "^8.22.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "rimraf": "^5.0.5",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "axios": "^1.6.7",
+    "dotenv": "^16.4.1",
+    "fast-xml-parser": "^4.3.4",
+    "openai": "^4.24.7",
+    "praisonai": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ]
 }