@saber2pr/ai-agent 0.0.3

package/README.md

@@ -0,0 +1,74 @@
+# @saber2pr/ai-agent
+
+A lightweight local AI assistant based on the **MCP (Model Context Protocol)**. It automatically loads your local tools (from Cursor or VSCode MCP configurations) and provides an intelligent orchestration layer via OpenAI-compatible APIs.
+
+## ✨ Features
+
+* **Native MCP Support**: Seamlessly connects to local MCP servers using Stdio transport.
+* **Auto-Discovery**: Automatically reads tool definitions from `~/.cursor/mcp.json` and `~/.vscode/mcp.json`.
+* **Persistent Configuration**: On the first run, it guides you through setting up your API endpoint, key, and model name, saving them to `~/.saber2pr-agent.json`.
+* **Namespace Management**: Prevents tool name conflicts by automatically prefixing functions (e.g., `serverName__toolName`).
+* **Interactive CLI**: Built-in REPL for multi-turn conversations and complex tool-chaining.
+
+## 📦 Installation
+
+Install globally via npm:
+
+```bash
+npm install -g @saber2pr/ai-agent
+```
+
+Or run directly using `npx`:
+
+```bash
+npx @saber2pr/ai-agent
+```
+
+## 🚀 Quick Start
+
+### 1. Launch the Agent
+
+Start the assistant by running the binary command:
+
+```bash
+sagent
+```
+
+### 2. Initialize Configuration
+
+If it's your first time running the agent, you will be prompted to provide:
+
+* **API Base URL**: e.g., `https://api.openai.com/v1` or your custom proxy.
+* **API Key**: Your model provider's API key.
+* **Model Name**: e.g., `gpt-4o`, `claude-3-5-sonnet`, or `deepseek-v3`.
+
+Your settings will be stored in `~/.saber2pr-agent.json` for future use.
+
+### 3. Connect Local Tools
+
+The agent automatically scans the following paths for MCP configurations:
+
+* `~/.cursor/mcp.json`
+* `~/.vscode/mcp.json`
+
+Ensure your MCP servers are configured in these files, and `sagent` will gain the ability to call them immediately.
+
+## 🛠️ Usage
+
+| Command                  | Description                                     |
+| ------------------------ | ----------------------------------------------- |
+| `~/.saber2pr-agent.json` | Manually edit this file to update API settings. |
+| `exit`                   | Type during a chat to quit the program.         |
+| `sagent`                 | Enter interactive chat mode.                    |
+
+## 🏗️ Tech Stack
+
+Built with:
+
+* [@modelcontextprotocol/sdk](https://www.google.com/search?q=https://github.com/modelcontextprotocol/typescript-sdk) - Official MCP SDK.
+* [openai](https://www.google.com/search?q=https://github.com/openai/openai-node) - Client for API interactions.
+* [TypeScript](https://www.google.com/search?q=https://www.typescriptlang.org/) - Ensuring type safety and robustness.
+
+## 📄 License
+
+[ISC](https://www.google.com/search?q=./LICENSE) © saber2pr

package/lib/agent.d.ts

@@ -0,0 +1,31 @@
+export default class McpAgent {
+    private openai;
+    private modelName;
+    private clients;
+    private allTools;
+    private messages;
+    constructor();
+    /**
+     * 1. API Configuration Management
+     * Checks for existing config or prompts user for input.
+     */
+    private ensureApiConfig;
+    /**
+     * 2. Load MCP server configs from common IDE paths
+     */
+    private loadMcpConfigs;
+    /**
+     * 3. Initialization
+     * Validates API credentials and connects to MCP servers.
+     */
+    init(): Promise<void>;
+    /**
+     * 4. Core Chat Logic
+     * Handles user input and recursive tool calls.
+     */
+    private processChat;
+    /**
+     * 5. Start the Interactive Shell
+     */
+    start(): Promise<void>;
+}

package/lib/agent.js

@@ -0,0 +1,259 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const openai_1 = __importDefault(require("openai"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const readline = __importStar(require("readline"));
+const CONFIG_FILE = path_1.default.join(os_1.default.homedir(), ".saber2pr-agent.json");
+// --- Core Class ---
+class McpAgent {
+    constructor() {
+        this.modelName = "";
+        this.clients = [];
+        this.allTools = [];
+        this.messages = [];
+        this.messages.push({
+            role: "system",
+            content: "You are a powerful local assistant. You can access local tools provided by the user via the MCP protocol. Please answer questions by combining tool outputs and context.",
+        });
+    }
+    /**
+     * 1. API Configuration Management
+     * Checks for existing config or prompts user for input.
+     */
+    async ensureApiConfig() {
+        if (fs_1.default.existsSync(CONFIG_FILE)) {
+            try {
+                const config = JSON.parse(fs_1.default.readFileSync(CONFIG_FILE, "utf-8"));
+                if (config.baseURL && config.apiKey && config.model) {
+                    return config;
+                }
+            }
+            catch (e) {
+                console.error(`[Error] Failed to read ${CONFIG_FILE}, re-initializing...`);
+            }
+        }
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const question = (query) => new Promise((resolve) => rl.question(query, resolve));
+        console.log("\n🔑 API Configuration not found. Please provide the following details:");
+        const baseURL = await question("? API Base URL: ");
+        const apiKey = await question("? API Key: ");
+        const model = await question("? Model Name: ");
+        if (!baseURL || !apiKey || !model) {
+            console.error("❌ Error: All fields (Base URL, API Key, Model Name) are required!");
+            process.exit(1);
+        }
+        const config = { baseURL, apiKey, model };
+        fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+        console.log(`✅ Configuration saved to ${CONFIG_FILE}\n`);
+        rl.close();
+        return config;
+    }
+    /**
+     * 2. Load MCP server configs from common IDE paths
+     */
+    loadMcpConfigs() {
+        const combinedConfig = { mcpServers: {} };
+        const configPaths = [
+            path_1.default.join(os_1.default.homedir(), ".cursor", "mcp.json"),
+            path_1.default.join(os_1.default.homedir(), ".vscode", "mcp.json"),
+        ];
+        for (const p of configPaths) {
+            if (fs_1.default.existsSync(p)) {
+                try {
+                    const content = JSON.parse(fs_1.default.readFileSync(p, "utf-8"));
+                    if (content.mcpServers) {
+                        combinedConfig.mcpServers = { ...combinedConfig.mcpServers, ...content.mcpServers };
+                        console.log(`[MCP] Config loaded from: ${p}`);
+                    }
+                }
+                catch (e) {
+                    console.error(`[Error] Failed to parse MCP config ${p}:`, e);
+                }
+            }
+        }
+        return combinedConfig;
+    }
+    /**
+     * 3. Initialization
+     * Validates API credentials and connects to MCP servers.
+     */
+    async init() {
+        // A. Setup & Validate OpenAI
+        const apiConfig = await this.ensureApiConfig();
+        this.openai = new openai_1.default({
+            baseURL: apiConfig.baseURL,
+            apiKey: apiConfig.apiKey,
+        });
+        this.modelName = apiConfig.model;
+        console.log("🔍 Validating API configuration...");
+        try {
+            // Perform a lightweight check to verify URL and Key
+            await this.openai.models.list();
+            console.log("✅ API validation successful.");
+        }
+        catch (e) {
+            console.error("\n❌ API Connection Failed!");
+            console.error(`Reason: ${e.message}`);
+            console.log(`\nSuggestion: If you made a mistake, please delete or edit: ${CONFIG_FILE}`);
+            process.exit(1);
+        }
+        // B. Setup MCP Clients
+        const mcpConfig = this.loadMcpConfigs();
+        const serverEntries = Object.entries(mcpConfig.mcpServers);
+        if (serverEntries.length === 0) {
+            console.warn("⚠️ No MCP server configurations found.");
+        }
+        for (const [name, server] of serverEntries) {
+            try {
+                const transport = new stdio_js_1.StdioClientTransport({
+                    command: server.command,
+                    args: server.args || [],
+                    env: { ...process.env, ...(server.env || {}) },
+                });
+                const client = new index_js_1.Client({ name, version: "1.0.0" }, { capabilities: {} });
+                await client.connect(transport);
+                const { tools } = await client.listTools();
+                const formatted = tools.map((t) => ({
+                    type: "function",
+                    function: {
+                        name: `${name}__${t.name}`,
+                        description: t.description,
+                        parameters: t.inputSchema,
+                    },
+                    _originalName: t.name,
+                    _client: client,
+                }));
+                this.allTools.push(...formatted);
+                this.clients.push(client);
+                console.log(`✅ [${name}] Connected, loaded ${tools.length} tools`);
+            }
+            catch (e) {
+                console.error(`❌ [${name}] Failed to start:`, e);
+            }
+        }
+    }
+    /**
+     * 4. Core Chat Logic
+     * Handles user input and recursive tool calls.
+     */
+    async processChat(userInput) {
+        this.messages.push({ role: "user", content: userInput });
+        let isThinking = true;
+        while (isThinking) {
+            const apiTools = this.allTools.map(({ _originalName, _client, ...rest }) => rest);
+            const response = await this.openai.chat.completions.create({
+                model: this.modelName,
+                messages: this.messages,
+                tools: apiTools.length > 0 ? apiTools : undefined,
+                tool_choice: "auto",
+            });
+            const message = response.choices[0].message;
+            // If no more tool calls, exit loop and show final response
+            if (!message.tool_calls || message.tool_calls.length === 0) {
+                this.messages.push(message);
+                console.log(`\n🤖 Agent: ${message.content}`);
+                isThinking = false;
+                break;
+            }
+            // Handle tool calls requested by the model
+            this.messages.push(message);
+            console.log(`\n⚙️  Model requested ${message.tool_calls.length} tool calls...`);
+            for (const toolCall of message.tool_calls) {
+                const toolInfo = this.allTools.find((t) => t.function.name === toolCall.function.name);
+                if (toolInfo) {
+                    const args = JSON.parse(toolCall.function.arguments);
+                    console.log(`   - Executing: ${toolInfo.function.name}`);
+                    try {
+                        const result = await toolInfo._client.callTool({
+                            name: toolInfo._originalName,
+                            arguments: args,
+                        });
+                        this.messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: JSON.stringify(result.content),
+                        });
+                    }
+                    catch (error) {
+                        console.error(`   - Execution failed: ${error.message}`);
+                        this.messages.push({
+                            role: "tool",
+                            tool_call_id: toolCall.id,
+                            content: `Error: ${error.message}`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * 5. Start the Interactive Shell
+     */
+    async start() {
+        await this.init();
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        console.log(`\n🚀 Agent Started (Model: ${this.modelName})! Type 'exit' to quit.`);
+        const chatLoop = () => {
+            rl.question("\n👤 You: ", async (input) => {
+                if (input.toLowerCase() === "exit") {
+                    console.log("Goodbye!");
+                    rl.close();
+                    process.exit(0);
+                }
+                try {
+                    await this.processChat(input);
+                }
+                catch (err) {
+                    console.error("\n❌ System Error during chat:", err.message);
+                    console.log("Try checking your API configuration or network connection.");
+                }
+                chatLoop();
+            });
+        };
+        chatLoop();
+    }
+}
+exports.default = McpAgent;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/index.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const agent_1 = __importDefault(require("./agent"));
+const manager = new agent_1.default();
+manager.start();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@saber2pr/ai-agent",
+  "version": "0.0.3",
+  "description": "AI Assistant CLI.",
+  "author": "saber2pr",
+  "license": "ISC",
+  "files": [
+    "lib"
+  ],
+  "bin": {
+    "sagent": "./lib/index.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./lib/index.js",
+  "scripts": {
+    "test": "node lib/index",
+    "start": "tsc --watch",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "openai": "^6.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^16.3.3",
+    "prettier": "^2.4.1",
+    "typescript": "^5.9.3"
+  }
+}