@oflow-ai/core 0.1.0

package/dist/tools/web-fetch.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebFetchTool = void 0;
+const base_1 = require("./base");
+const axios_1 = __importDefault(require("axios"));
+class WebFetchTool extends base_1.BaseTool {
+    name = 'web_fetch';
+    description = 'Fetches and extracts content from a URL.';
+    parameters = {
+        type: 'object',
+        properties: {
+            url: {
+                type: 'string',
+                description: 'The URL to fetch'
+            },
+            prompt: {
+                type: 'string',
+                description: 'Instructions on how to process the fetched content'
+            }
+        },
+        required: ['url']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['url']);
+        try {
+            const response = await axios_1.default.get(params.url, {
+                timeout: 30000,
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                }
+            });
+            let content = response.data;
+            // If HTML, extract text content
+            if (typeof content === 'string' && content.includes('<html')) {
+                content = this.extractTextFromHtml(content);
+            }
+            // Truncate if too long
+            if (content.length > 50000) {
+                content = content.substring(0, 50000) + '\n\n... [Content truncated]';
+            }
+            const prompt = params.prompt || 'Summarize the content';
+            return `URL: ${params.url}\nPrompt: ${prompt}\n\nContent:\n${content}`;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+    extractTextFromHtml(html) {
+        // Simple HTML to text conversion
+        let text = html;
+        // Remove scripts and styles
+        text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '');
+        text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+        // Remove comments
+        text = text.replace(/<!--[\s\S]*?-->/g, '');
+        // Replace common block elements with newlines
+        text = text.replace(/<\/p>/gi, '\n');
+        text = text.replace(/<\/div>/gi, '\n');
+        text = text.replace(/<\/h[1-6]>/gi, '\n');
+        text = text.replace(/<\/li>/gi, '\n');
+        text = text.replace(/<br\s*\/>/gi, '\n');
+        // Remove remaining HTML tags
+        text = text.replace(/<[^>]+>/g, '');
+        // Decode HTML entities
+        text = text.replace(/&nbsp;/g, ' ');
+        text = text.replace(/&amp;/g, '&');
+        text = text.replace(/&lt;/g, '<');
+        text = text.replace(/&gt;/g, '>');
+        text = text.replace(/&quot;/g, '"');
+        // Clean up whitespace
+        text = text.replace(/\n\s*\n/g, '\n\n');
+        text = text.replace(/[ \t]+/g, ' ');
+        text = text.trim();
+        return text;
+    }
+}
+exports.WebFetchTool = WebFetchTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/web-search.d.ts

@@ -0,0 +1,35 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface WebSearchParams {
+    query: string;
+    intent?: string;
+    expected?: string;
+    num?: number;
+}
+export declare class WebSearchTool extends BaseTool<WebSearchParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            intent: {
+                type: string;
+                description: string;
+            };
+            expected: {
+                type: string;
+                description: string;
+            };
+            num: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: WebSearchParams, options?: ToolExecuteOptions): Promise<string>;
+}
+export {};

package/dist/tools/web-search.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.WebSearchTool = void 0;
+const base_1 = require("./base");
+const axios_1 = __importDefault(require("axios"));
+class WebSearchTool extends base_1.BaseTool {
+    name = 'web_search';
+    description = 'Performs a web search and returns results similar to a Google results page.';
+    parameters = {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'The search query'
+            },
+            intent: {
+                type: 'string',
+                description: 'The intent of this search'
+            },
+            expected: {
+                type: 'string',
+                description: 'Expected results'
+            },
+            num: {
+                type: 'number',
+                description: 'Number of results to return (default: 10)'
+            }
+        },
+        required: ['query']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['query']);
+        try {
+            // Use DuckDuckGo API for web search (no API key required)
+            const response = await axios_1.default.get('https://api.duckduckgo.com/', {
+                params: {
+                    q: params.query,
+                    format: 'json',
+                    no_html: 1,
+                    skip_disambig: 1
+                },
+                timeout: 30000
+            });
+            const data = response.data;
+            const results = [];
+            // Add abstract if available
+            if (data.Abstract) {
+                results.push({
+                    title: data.Heading || 'Summary',
+                    link: data.AbstractURL || '',
+                    snippet: data.Abstract,
+                    date: ''
+                });
+            }
+            // Add related topics
+            if (data.RelatedTopics) {
+                for (const topic of data.RelatedTopics.slice(0, params.num || 10)) {
+                    if (topic.Text && topic.FirstURL) {
+                        results.push({
+                            title: topic.Text.split(' - ')[0] || 'Related',
+                            link: topic.FirstURL,
+                            snippet: topic.Text,
+                            date: ''
+                        });
+                    }
+                }
+            }
+            if (results.length === 0) {
+                return `No results found for: ${params.query}`;
+            }
+            const output = results.map((r, i) => {
+                return `[${i + 1}] ${r.title}\n    ${r.link}\n    ${r.snippet}`;
+            }).join('\n\n');
+            return `Search results for "${params.query}":\n\n${output}`;
+        }
+        catch (error) {
+            // Fallback: provide helpful message
+            return `Web search is not available. Error: ${error instanceof Error ? error.message : String(error)}\n\nPlease note: For full web search functionality, configure a search API key in settings.`;
+        }
+    }
+}
+exports.WebSearchTool = WebSearchTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tools/write-file.d.ts

@@ -0,0 +1,25 @@
+import { BaseTool, ToolExecuteOptions } from './base';
+interface WriteFileParams {
+    file_path: string;
+    content: string;
+}
+export declare class WriteFileTool extends BaseTool<WriteFileParams> {
+    name: string;
+    description: string;
+    parameters: {
+        type: string;
+        properties: {
+            file_path: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(params: WriteFileParams, options?: ToolExecuteOptions): Promise<string>;
+}
+export {};

package/dist/tools/write-file.js

@@ -0,0 +1,76 @@
+"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 __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.WriteFileTool = void 0;
+const base_1 = require("./base");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class WriteFileTool extends base_1.BaseTool {
+    name = 'write_file';
+    description = 'Writes content to a specified file in the local filesystem. Creates the file if it does not exist, or overwrites it if it does.';
+    parameters = {
+        type: 'object',
+        properties: {
+            file_path: {
+                type: 'string',
+                description: 'The absolute path to the file to write to'
+            },
+            content: {
+                type: 'string',
+                description: 'The content to write to the file'
+            }
+        },
+        required: ['file_path', 'content']
+    };
+    async execute(params, options) {
+        this.validateRequired(params, ['file_path', 'content']);
+        const filePath = params.file_path;
+        const workingDir = options?.workingDirectory || process.cwd();
+        const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(workingDir, filePath);
+        try {
+            // Ensure directory exists
+            const dir = path.dirname(resolvedPath);
+            await fs.mkdir(dir, { recursive: true });
+            // Write file
+            await fs.writeFile(resolvedPath, params.content, 'utf-8');
+            return `Successfully wrote ${params.content.length} characters to ${resolvedPath}`;
+        }
+        catch (error) {
+            return (0, base_1.formatToolError)(error);
+        }
+    }
+}
+exports.WriteFileTool = WriteFileTool;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types/index.d.ts

@@ -0,0 +1,166 @@
+export type ChineseProvider = 'deepseek' | 'qwen' | 'zhipu' | 'baichuan' | 'yi' | 'moonshot' | 'siliconflow';
+export interface Message {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | MessageContent[];
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+}
+export interface MessageContent {
+    type: 'text' | 'image';
+    text?: string;
+    imageUrl?: {
+        url: string;
+    };
+}
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export interface ToolResult {
+    toolCallId: string;
+    content: string;
+    isError?: boolean;
+}
+export interface ChatCompletionOptions {
+    messages: Message[];
+    tools?: ToolDefinition[];
+    toolChoice?: 'auto' | 'none' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    stream?: boolean;
+    maxTokens?: number;
+    temperature?: number;
+}
+export interface ChatCompletionResponse {
+    id: string;
+    content: string | null;
+    toolCalls?: ToolCall[];
+    finishReason: string;
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    reasoning?: string;
+}
+export interface StreamChunk {
+    id: string;
+    delta: {
+        content?: string;
+        toolCalls?: Partial<ToolCall>[];
+        role?: string;
+        reasoning?: string;
+    };
+    finishReason: string | null;
+}
+export interface AIProvider {
+    name: string;
+    chat(options: ChatCompletionOptions): Promise<ChatCompletionResponse>;
+    chatStream(options: ChatCompletionOptions, onChunk: (chunk: StreamChunk) => void): Promise<void>;
+    getModels(): Promise<string[]>;
+}
+export interface AuthConfig {
+    provider: 'openai' | 'custom' | 'oflow' | ChineseProvider;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+}
+export interface Config {
+    auth: AuthConfig;
+    defaultModel?: string;
+    maxTokens?: number;
+    temperature?: number;
+    sandbox?: boolean;
+    showThinking?: boolean;
+    mcpServers?: Record<string, MCPServerConfig>;
+}
+export interface MCPServerConfig {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface Tool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (params: Record<string, unknown>) => Promise<string>;
+}
+export interface Skill {
+    id: string;
+    name: string;
+    description: string;
+    version: string;
+    path: string;
+    mainFile: string;
+}
+export interface ConversationHistory {
+    messages: Message[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface FileInfo {
+    path: string;
+    type: 'file' | 'directory';
+    size?: number;
+    modifiedAt?: Date;
+}
+export interface SearchResult {
+    path: string;
+    line: number;
+    column: number;
+    content: string;
+    match: string;
+}
+export declare const CHINESE_MODELS: {
+    deepseek: {
+        name: string;
+        baseUrl: string;
+        models: string[];
+    };
+    qwen: {
+        name: string;
+        baseUrl: string;
+        models: string[];
+    };
+    zhipu: {
+        name: string;
+        baseUrl: string;
+        models: string[];
+    };
+    baichuan: {
+        name: string;
+        baseUrl: string;
+        models: string[];
+    };
+    yi: {
+        name: string;
+        baseUrl: string;
+        models: string[];
+    };
+    moonshot: {
+        name: string;
+        baseUrl: string;
+        models: string[];
+    };
+    siliconflow: {
+        name: string;
+        baseUrl: string;
+        models: string[];
+    };
+};

package/dist/types/index.js

@@ -0,0 +1,43 @@
+"use strict";
+// Type definitions for oflow core
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHINESE_MODELS = void 0;
+// 预定义的国内模型
+exports.CHINESE_MODELS = {
+    deepseek: {
+        name: 'DeepSeek (深度求索)',
+        baseUrl: 'https://api.deepseek.com/v1',
+        models: ['deepseek-chat', 'deepseek-coder', 'deepseek-reasoner']
+    },
+    qwen: {
+        name: 'Qwen (通义千问)',
+        baseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
+        models: ['qwen-turbo', 'qwen-plus', 'qwen-max', 'qwen-max-longcontext']
+    },
+    zhipu: {
+        name: 'GLM (智谱)',
+        baseUrl: 'https://open.bigmodel.cn/api/paas/v4',
+        models: ['glm-4', 'glm-4-flash', 'glm-4-plus', 'glm-4-long']
+    },
+    baichuan: {
+        name: 'Baichuan (百川)',
+        baseUrl: 'https://api.baichuan-ai.com/v1',
+        models: ['Baichuan4', 'Baichuan3-Turbo', 'Baichuan3-Turbo-128k']
+    },
+    yi: {
+        name: 'Yi (零一万物)',
+        baseUrl: 'https://api.lingyiwanwu.com/v1',
+        models: ['yi-large', 'yi-medium', 'yi-spark']
+    },
+    moonshot: {
+        name: 'Moonshot (月之暗面)',
+        baseUrl: 'https://api.moonshot.cn/v1',
+        models: ['moonshot-v1-8k', 'moonshot-v1-32k', 'moonshot-v1-128k']
+    },
+    siliconflow: {
+        name: 'SiliconFlow (硅基流动)',
+        baseUrl: 'https://api.siliconflow.cn/v1',
+        models: ['Qwen/Qwen2.5-72B-Instruct', 'deepseek-ai/DeepSeek-V2.5', 'meta-llama/Llama-3.1-70B-Instruct']
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@oflow-ai/core",
+  "version": "0.1.0",
+  "description": "Core library for oFlow CLI - AI providers, tools, and utilities",
+  "keywords": [
+    "ai",
+    "openai",
+    "deepseek",
+    "qwen",
+    "llm",
+    "tools",
+    "agent"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "test": "echo \"No tests yet\"",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "openai": "^4.20.0",
+    "axios": "^1.6.2",
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "inquirer": "^8.2.6",
+    "conf": "^10.2.0",
+    "glob": "^10.3.10",
+    "fs-extra": "^11.2.0",
+    "ignore": "^5.3.0",
+    "marked": "^11.1.0",
+    "marked-terminal": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^8.2.10",
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "author": "oFlow Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}