@wangzhizhi/remi 0.1.224 → 0.1.225

package/README.md

@@ -3,7 +3,7 @@
 Remi AI coding agent CLI.
 
 ```bash
-npm install -g @wangzhizhi/remi@0.1.224
+npm install -g @wangzhizhi/remi@0.1.225
 remi setup
 remi
 ```

package/dist/version.js

@@ -1,5 +1,5 @@
 import { t } from './i18n.js';
-export const version = '0.1.224';
+export const version = '0.1.225';
 export function formatVersionMessage(language) {
     return t(language, 'version.message', { version });
 }

package/node_modules/@remi/compact/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/compact",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/config/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/config",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/core",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/hooks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/hooks",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/llm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/llm",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/mcp/dist/index.js

@@ -0,0 +1,643 @@
+import { evaluateToolPermission } from '@remi/permissions';
+import { createToolPermissionRequest, createToolRegistry, } from '@remi/tools';
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+export const mcpPackageName = '@remi/mcp';
+const mcpProtocolVersion = '2025-11-25';
+const defaultMcpRequestTimeoutMs = 15_000;
+const maxMcpListPages = 20;
+export class StdioMcpClient {
+    serverName;
+    config;
+    options;
+    child;
+    buffer = '';
+    nextRequestId = 1;
+    pending = new Map();
+    closed = false;
+    constructor(serverName, config, options) {
+        this.serverName = serverName;
+        this.config = config;
+        this.options = options;
+    }
+    async connect() {
+        if (this.child) {
+            return;
+        }
+        const command = this.config.command.trim();
+        if (!command) {
+            throw new Error('MCP stdio server command must not be empty.');
+        }
+        const args = Array.isArray(this.config.args) ? this.config.args : [];
+        const cwd = this.config.cwd ? resolve(this.options.cwd, this.config.cwd) : this.options.cwd;
+        const child = spawn(command, args, {
+            cwd,
+            env: mcpProcessEnv(this.options.env ?? process.env, this.config.env),
+            stdio: 'pipe',
+            shell: false,
+        });
+        this.child = child;
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', chunk => this.handleStdout(String(chunk)));
+        child.on('error', error => this.closeWithError(error instanceof Error ? error : new Error(String(error))));
+        child.on('close', () => this.closeWithError(new Error(`MCP stdio server ${this.serverName} exited.`)));
+        if (this.options.signal) {
+            this.options.signal.addEventListener('abort', () => void this.close(), { once: true });
+        }
+        await this.initialize();
+    }
+    async initialize() {
+        const result = await this.request('initialize', {
+            protocolVersion: mcpProtocolVersion,
+            capabilities: {},
+            clientInfo: {
+                name: 'Remi',
+                version: '0.1',
+            },
+        });
+        this.notify('notifications/initialized');
+        return result;
+    }
+    async listTools() {
+        return await this.listToolsPage();
+    }
+    async listToolsPage(cursor) {
+        return normalizeToolsListResult(await this.request('tools/list', cursor ? { cursor } : undefined));
+    }
+    async callTool(name, args) {
+        return await this.request('tools/call', { name, arguments: args });
+    }
+    async close() {
+        this.closed = true;
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`MCP request ${id} was cancelled because the client closed.`));
+        }
+        this.pending.clear();
+        if (this.child && !this.child.killed) {
+            this.child.kill();
+        }
+        this.child = undefined;
+    }
+    request(method, params) {
+        const child = this.requireChild();
+        const id = this.nextRequestId++;
+        const timeoutMs = normalizedTimeoutMs(this.config.timeoutMs);
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            ...(params !== undefined ? { params } : {}),
+        };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP request timed out: ${method}`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            child.stdin.write(`${JSON.stringify(request)}\n`);
+        });
+    }
+    notify(method, params) {
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            ...(params !== undefined ? { params } : {}),
+        };
+        this.requireChild().stdin.write(`${JSON.stringify(notification)}\n`);
+    }
+    requireChild() {
+        if (!this.child || this.closed) {
+            throw new Error(`MCP stdio server ${this.serverName} is not connected.`);
+        }
+        return this.child;
+    }
+    handleStdout(chunk) {
+        this.buffer += chunk;
+        while (true) {
+            const newline = this.buffer.indexOf('\n');
+            if (newline < 0) {
+                return;
+            }
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (!line) {
+                continue;
+            }
+            this.handleMessage(line);
+        }
+    }
+    handleMessage(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!isJsonRpcResponse(parsed)) {
+            return;
+        }
+        const pending = this.pending.get(parsed.id);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(parsed.id);
+        clearTimeout(pending.timer);
+        if (parsed.error) {
+            pending.reject(new Error(parsed.error.message || `MCP request failed with code ${parsed.error.code ?? 'unknown'}.`));
+            return;
+        }
+        pending.resolve(parsed.result);
+    }
+    closeWithError(error) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.child = undefined;
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(`${error.message} Pending MCP request id=${id} failed.`));
+        }
+        this.pending.clear();
+    }
+}
+export async function createMcpRuntime(config, options, baseExecutor) {
+    const sessions = [];
+    const diagnostics = [];
+    const tools = [];
+    const usedNames = new Set();
+    for (const [serverName, serverConfig] of enabledMcpServers(config)) {
+        const client = new StdioMcpClient(serverName, serverConfig, options);
+        try {
+            await client.connect();
+            sessions.push(client);
+            const discovered = await discoverToolsForClient(serverName, client, usedNames);
+            tools.push(...discovered);
+        }
+        catch (error) {
+            diagnostics.push({
+                server: serverName,
+                level: 'error',
+                message: error instanceof Error ? error.message : 'MCP server discovery failed.',
+            });
+            await client.close();
+        }
+    }
+    const registry = createToolRegistry(tools.map(tool => tool.definition));
+    return {
+        tools,
+        diagnostics,
+        registry,
+        executor: createMcpToolExecutor(tools, baseExecutor),
+        close: async () => {
+            await Promise.all(sessions.map(session => session.close()));
+        },
+    };
+}
+export function createMcpAwareToolRegistry(base, mcpTools) {
+    const registry = createToolRegistry(base.list());
+    for (const tool of mcpTools) {
+        registry.register(tool.definition);
+    }
+    return registry;
+}
+export function createMcpToolExecutor(mcpTools, baseExecutor) {
+    const byName = new Map(mcpTools.map(tool => [tool.remiName, tool]));
+    return {
+        async execute(request) {
+            const tool = byName.get(request.call.toolName);
+            if (!tool) {
+                if (baseExecutor) {
+                    return await baseExecutor.execute(request);
+                }
+                return unknownMcpToolOutcome(request);
+            }
+            return await executeMcpTool(tool, request);
+        },
+    };
+}
+async function discoverToolsForClient(serverName, client, usedNames) {
+    const tools = [];
+    let cursor;
+    for (let page = 0; page < maxMcpListPages; page += 1) {
+        const result = await client.listToolsPage(cursor);
+        for (const rawTool of result.tools ?? []) {
+            const remoteTool = normalizeRemoteTool(rawTool);
+            if (!remoteTool) {
+                continue;
+            }
+            const remiName = uniqueToolName(mcpToolName(serverName, remoteTool.name), usedNames);
+            const definition = createMcpToolDefinition(serverName, remoteTool.name, remiName, remoteTool);
+            tools.push({
+                serverName,
+                remoteName: remoteTool.name,
+                remiName,
+                description: remoteTool.description,
+                inputSchema: definition.inputSchema,
+                ...(remoteTool.rawInputSchema ? { rawInputSchema: remoteTool.rawInputSchema } : {}),
+                ...(remoteTool.annotations ? { annotations: remoteTool.annotations } : {}),
+                client,
+                definition,
+            });
+        }
+        cursor = result.nextCursor;
+        if (!cursor) {
+            break;
+        }
+    }
+    return tools;
+}
+function normalizeRemoteTool(rawTool) {
+    if (!rawTool || typeof rawTool !== 'object' || Array.isArray(rawTool)) {
+        return undefined;
+    }
+    const record = rawTool;
+    const name = typeof record['name'] === 'string' ? record['name'].trim() : '';
+    if (!name) {
+        return undefined;
+    }
+    const description = typeof record['description'] === 'string' && record['description'].trim() ? record['description'].trim() : `MCP tool ${name}.`;
+    const inputSchema = normalizeMcpInputSchema(record['inputSchema']);
+    const annotations = normalizeMcpToolAnnotations(record['annotations']);
+    return {
+        name,
+        description,
+        inputSchema,
+        ...(isRecord(record['inputSchema']) ? { rawInputSchema: record['inputSchema'] } : {}),
+        ...(annotations ? { annotations } : {}),
+    };
+}
+function createMcpToolDefinition(serverName, remoteName, remiName, remoteTool) {
+    const riskLevel = mcpToolRiskLevel(remoteTool.annotations);
+    return {
+        name: remiName,
+        description: `Call MCP server "${serverName}" tool "${remoteName}". ${remoteTool.description}`,
+        inputSchema: remoteTool.inputSchema,
+        outputSchema: mcpOutputSchema,
+        riskLevel,
+        permissionPolicy: {
+            mode: 'ask',
+            requirements: mcpPermissionRequirements(riskLevel),
+            reason: `Calls external MCP tool ${serverName}/${remoteName}. Requires MCP permission review before execution.`,
+        },
+        outputLimit: { maxBytes: 128 * 1024, truncate: 'tail' },
+    };
+}
+async function executeMcpTool(tool, request) {
+    const permissionRequest = createToolPermissionRequest(tool.definition, request.call, request.context);
+    const initialDecision = evaluateToolPermission(permissionRequest);
+    let permissionDecision = applyMcpPermissionMode(request.context, initialDecision);
+    if (permissionDecision.status === 'ask' && request.context.requestPermission) {
+        try {
+            permissionDecision = await request.context.requestPermission(permissionRequest, permissionDecision);
+        }
+        catch (error) {
+            permissionDecision = {
+                status: 'deny',
+                reason: error instanceof Error ? error.message : 'Permission request was rejected.',
+                requirements: permissionDecision.requirements,
+            };
+        }
+    }
+    const callEvent = {
+        type: 'tool_call',
+        callId: request.call.id,
+        toolName: tool.definition.name,
+        input: request.call.input,
+        riskLevel: tool.definition.riskLevel,
+        permissionPolicy: tool.definition.permissionPolicy,
+        status: permissionDecision.status === 'deny' ? 'denied' : 'running',
+    };
+    if (permissionDecision.status !== 'allow') {
+        const result = {
+            ok: false,
+            callId: request.call.id,
+            toolName: tool.definition.name,
+            error: {
+                code: permissionDecision.status === 'ask' ? 'PERMISSION_REQUIRED' : 'PERMISSION_DENIED',
+                message: permissionDecision.reason,
+            },
+        };
+        return {
+            dryRun: false,
+            callId: request.call.id,
+            toolName: tool.definition.name,
+            permissionRequest,
+            permissionDecision,
+            transcriptEvents: [{ ...callEvent, status: 'denied' }, toolResultTranscriptEvent(result)],
+            result,
+        };
+    }
+    const result = await callMcpTool(tool, request);
+    return {
+        dryRun: false,
+        callId: request.call.id,
+        toolName: tool.definition.name,
+        permissionRequest,
+        permissionDecision,
+        transcriptEvents: [callEvent, toolResultTranscriptEvent(result)],
+        result,
+    };
+}
+async function callMcpTool(tool, request) {
+    try {
+        const rawResult = await tool.client.callTool(tool.remoteName, request.call.input);
+        const normalized = normalizeMcpCallResult(tool.serverName, tool.remoteName, rawResult);
+        if (normalized.isError) {
+            return {
+                ok: false,
+                callId: request.call.id,
+                toolName: tool.definition.name,
+                error: {
+                    code: 'MCP_TOOL_ERROR',
+                    message: normalized.text || `MCP tool ${tool.serverName}/${tool.remoteName} returned an error result.`,
+                },
+            };
+        }
+        return boundedJsonResult(request, normalized);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            callId: request.call.id,
+            toolName: tool.definition.name,
+            error: {
+                code: 'MCP_TOOL_CALL_FAILED',
+                message: error instanceof Error ? error.message : 'MCP tool call failed.',
+            },
+        };
+    }
+}
+function applyMcpPermissionMode(context, decision) {
+    if (decision.status === 'ask' && context.permissionMode === 'bypass') {
+        return {
+            status: 'allow',
+            reason: 'full-access permission profile allows MCP tool execution without prompting.',
+            requirements: decision.requirements,
+        };
+    }
+    return decision;
+}
+function enabledMcpServers(config) {
+    return Object.entries(config?.servers ?? {})
+        .filter(([, server]) => server.enabled !== false)
+        .filter(([, server]) => server.type === undefined || server.type === 'stdio');
+}
+function mcpToolName(serverName, toolName) {
+    return `mcp__${safeToolNameSegment(serverName)}__${safeToolNameSegment(toolName)}`;
+}
+function safeToolNameSegment(value) {
+    const normalized = value.toLowerCase().replace(/[^a-z0-9_]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 48);
+    const segment = normalized || 'tool';
+    return /^[a-z]/.test(segment) ? segment : `x_${segment}`;
+}
+function uniqueToolName(baseName, usedNames) {
+    let candidate = baseName;
+    let suffix = 2;
+    while (usedNames.has(candidate)) {
+        candidate = `${baseName}_${suffix}`;
+        suffix += 1;
+    }
+    usedNames.add(candidate);
+    return candidate;
+}
+function mcpToolRiskLevel(annotations) {
+    if (annotations?.openWorldHint) {
+        return 'network';
+    }
+    if (annotations?.destructiveHint) {
+        return 'write';
+    }
+    if (annotations?.readOnlyHint) {
+        return 'read';
+    }
+    return 'execute';
+}
+function mcpPermissionRequirements(riskLevel) {
+    return riskLevel === 'network' ? ['mcp', 'network'] : ['mcp'];
+}
+const mcpOutputSchema = {
+    type: 'object',
+    properties: {
+        server: { type: 'string', description: 'MCP server name.' },
+        tool: { type: 'string', description: 'Remote MCP tool name.' },
+        text: { type: 'string', description: 'Text extracted from MCP content blocks.' },
+        content: {
+            type: 'array',
+            description: 'Bounded MCP content blocks.',
+            items: {
+                type: 'object',
+                description: 'One MCP content block.',
+                additionalProperties: true,
+            },
+        },
+        structuredContent: {
+            type: 'object',
+            description: 'Structured MCP tool output when provided by the server.',
+            additionalProperties: true,
+        },
+        isError: { type: 'boolean', description: 'Whether the MCP server marked the result as an error.' },
+    },
+    required: ['server', 'tool', 'text', 'content', 'isError'],
+    additionalProperties: false,
+};
+function normalizeMcpInputSchema(rawSchema) {
+    if (!isRecord(rawSchema) || rawSchema['type'] !== 'object') {
+        return {
+            type: 'object',
+            properties: {},
+            additionalProperties: true,
+        };
+    }
+    const rawProperties = isRecord(rawSchema['properties']) ? rawSchema['properties'] : {};
+    const properties = {};
+    for (const [name, property] of Object.entries(rawProperties)) {
+        properties[name] = normalizeMcpSchemaProperty(property);
+    }
+    return {
+        type: 'object',
+        ...(typeof rawSchema['description'] === 'string' ? { description: rawSchema['description'] } : {}),
+        properties,
+        ...(Array.isArray(rawSchema['required']) ? { required: rawSchema['required'].filter((item) => typeof item === 'string') } : {}),
+        additionalProperties: rawSchema['additionalProperties'] === false ? false : true,
+    };
+}
+function normalizeMcpSchemaProperty(rawProperty) {
+    const record = isRecord(rawProperty) ? rawProperty : {};
+    const type = normalizeMcpSchemaType(record);
+    const description = typeof record['description'] === 'string' && record['description'].trim() ? record['description'] : `MCP ${type} value.`;
+    const property = { type, description };
+    const enumValues = Array.isArray(record['enum']) ? record['enum'].filter((item) => typeof item === 'string') : [];
+    if (enumValues.length > 0) {
+        property.enum = enumValues;
+    }
+    if (type === 'array') {
+        property.items = normalizeMcpSchemaProperty(record['items']);
+    }
+    if (type === 'object') {
+        const rawProperties = isRecord(record['properties']) ? record['properties'] : {};
+        property.properties = Object.fromEntries(Object.entries(rawProperties).map(([name, nested]) => [name, normalizeMcpSchemaProperty(nested)]));
+        const required = Array.isArray(record['required']) ? record['required'].filter((item) => typeof item === 'string') : [];
+        if (required.length > 0) {
+            property.required = required;
+        }
+        property.additionalProperties = record['additionalProperties'] === false ? false : true;
+    }
+    return property;
+}
+function normalizeMcpSchemaType(record) {
+    const rawType = Array.isArray(record['type']) ? record['type'].find(item => item !== 'null') : record['type'];
+    if (rawType === 'number' || rawType === 'integer' || rawType === 'boolean' || rawType === 'object' || rawType === 'array' || rawType === 'string') {
+        return rawType;
+    }
+    if (isRecord(record['properties'])) {
+        return 'object';
+    }
+    if (record['items']) {
+        return 'array';
+    }
+    if (Array.isArray(record['enum']) && record['enum'].every(item => typeof item === 'string')) {
+        return 'string';
+    }
+    return 'string';
+}
+function normalizeMcpToolAnnotations(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const annotations = {};
+    if (typeof value['readOnlyHint'] === 'boolean')
+        annotations.readOnlyHint = value['readOnlyHint'];
+    if (typeof value['destructiveHint'] === 'boolean')
+        annotations.destructiveHint = value['destructiveHint'];
+    if (typeof value['idempotentHint'] === 'boolean')
+        annotations.idempotentHint = value['idempotentHint'];
+    if (typeof value['openWorldHint'] === 'boolean')
+        annotations.openWorldHint = value['openWorldHint'];
+    return Object.keys(annotations).length > 0 ? annotations : undefined;
+}
+function normalizeMcpCallResult(server, tool, rawResult) {
+    const record = isRecord(rawResult) ? rawResult : {};
+    const content = Array.isArray(record['content']) ? record['content'].map(normalizeMcpContentBlock) : [];
+    const text = content
+        .map(block => (isRecord(block) && typeof block['text'] === 'string' ? block['text'] : ''))
+        .filter(Boolean)
+        .join('\n');
+    return {
+        server,
+        tool,
+        text,
+        content,
+        ...(record['structuredContent'] !== undefined ? { structuredContent: record['structuredContent'] } : {}),
+        isError: record['isError'] === true,
+    };
+}
+function normalizeMcpContentBlock(block) {
+    if (!isRecord(block)) {
+        return { type: 'unknown' };
+    }
+    return block;
+}
+function normalizeToolsListResult(result) {
+    if (!isRecord(result)) {
+        return {};
+    }
+    return {
+        ...(Array.isArray(result['tools']) ? { tools: result['tools'] } : {}),
+        ...(typeof result['nextCursor'] === 'string' && result['nextCursor'] ? { nextCursor: result['nextCursor'] } : {}),
+    };
+}
+function boundedJsonResult(request, payload) {
+    const raw = JSON.stringify(payload);
+    const maxBytes = Math.max(1, Math.min(request.context.maxOutputBytes, 128 * 1024));
+    const bounded = truncateStringBytes(raw, maxBytes);
+    return {
+        ok: true,
+        callId: request.call.id,
+        toolName: request.call.toolName,
+        output: bounded.text,
+        truncated: bounded.truncated,
+        bytes: Buffer.byteLength(bounded.text, 'utf8'),
+    };
+}
+function toolResultTranscriptEvent(result) {
+    if (result.ok) {
+        return {
+            type: 'tool_result',
+            callId: result.callId,
+            toolName: result.toolName,
+            ok: true,
+            summary: result.output,
+            bytes: result.bytes,
+            truncated: result.truncated,
+        };
+    }
+    return {
+        type: 'tool_result',
+        callId: result.callId,
+        toolName: result.toolName,
+        ok: false,
+        summary: result.error.message,
+        errorCode: result.error.code,
+    };
+}
+function unknownMcpToolOutcome(request) {
+    const decision = {
+        status: 'deny',
+        reason: `Unknown tool: ${request.call.toolName}`,
+        requirements: [],
+    };
+    const result = {
+        ok: false,
+        callId: request.call.id,
+        toolName: request.call.toolName,
+        error: {
+            code: 'UNKNOWN_TOOL',
+            message: decision.reason,
+        },
+    };
+    return {
+        dryRun: false,
+        callId: request.call.id,
+        toolName: request.call.toolName,
+        permissionDecision: decision,
+        transcriptEvents: [toolResultTranscriptEvent(result)],
+        result,
+    };
+}
+function isJsonRpcResponse(value) {
+    return isRecord(value) && value['jsonrpc'] === '2.0' && typeof value['id'] === 'number';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizedTimeoutMs(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? Math.min(value, 120_000) : defaultMcpRequestTimeoutMs;
+}
+function mcpProcessEnv(baseEnv, extraEnv) {
+    const env = { ...baseEnv };
+    for (const [name, value] of Object.entries(extraEnv ?? {})) {
+        env[name] = interpolateEnvValue(value, baseEnv);
+    }
+    return env;
+}
+function interpolateEnvValue(value, env) {
+    const match = /^\$\{([A-Z0-9_]+)\}$/.exec(value);
+    if (!match) {
+        return value;
+    }
+    return env[match[1] ?? ''] ?? '';
+}
+function truncateStringBytes(text, maxBytes) {
+    const buffer = Buffer.from(text, 'utf8');
+    if (buffer.byteLength <= maxBytes) {
+        return { text, truncated: false };
+    }
+    return {
+        text: buffer.subarray(0, maxBytes).toString('utf8'),
+        truncated: true,
+    };
+}

package/node_modules/@remi/mcp/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@remi/mcp",
+  "version": "0.1.225",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  }
+}

package/node_modules/@remi/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/memory",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/permissions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/permissions",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/sessions/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/sessions",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/skills",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/terminal-markdown/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/terminal-markdown",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/node_modules/@remi/tools/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remi/tools",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "type": "module",
   "exports": {
     ".": "./dist/index.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wangzhizhi/remi",
-  "version": "0.1.224",
+  "version": "0.1.225",
   "description": "Remi AI coding agent CLI.",
   "type": "module",
   "bin": {
@@ -10,17 +10,18 @@
     "node": ">=24 <25"
   },
   "dependencies": {
-    "@remi/compact": "0.1.224",
-    "@remi/config": "0.1.224",
-    "@remi/core": "0.1.224",
-    "@remi/hooks": "0.1.224",
-    "@remi/llm": "0.1.224",
-    "@remi/memory": "0.1.224",
-    "@remi/permissions": "0.1.224",
-    "@remi/sessions": "0.1.224",
-    "@remi/skills": "0.1.224",
-    "@remi/terminal-markdown": "0.1.224",
-    "@remi/tools": "0.1.224",
+    "@remi/compact": "0.1.225",
+    "@remi/config": "0.1.225",
+    "@remi/core": "0.1.225",
+    "@remi/hooks": "0.1.225",
+    "@remi/llm": "0.1.225",
+    "@remi/memory": "0.1.225",
+    "@remi/mcp": "0.1.225",
+    "@remi/permissions": "0.1.225",
+    "@remi/sessions": "0.1.225",
+    "@remi/skills": "0.1.225",
+    "@remi/terminal-markdown": "0.1.225",
+    "@remi/tools": "0.1.225",
     "highlight.js": "11.11.1",
     "ink": "7.0.4",
     "marked": "17.0.1",
@@ -33,6 +34,7 @@
     "@remi/hooks",
     "@remi/llm",
     "@remi/memory",
+    "@remi/mcp",
     "@remi/permissions",
     "@remi/sessions",
     "@remi/skills",