@erllecta/coding-helper 1.0.0

package/dist/components/McpSetup.js

@@ -0,0 +1,109 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { writeClaudeMcpConfig, getClaudeUserConfigPath, } from '../tools/claude-code.js';
+import { writeOpenCodeMcpConfig, getOpenCodeConfigPath, } from '../tools/opencode.js';
+import { getApiKey, getAssistantId, getAssistantName } from '../store.js';
+const ALL_TOOLS = ['claude-code', 'opencode'];
+export default function McpSetup({ onBack, onComplete }) {
+    const [selectedTools, setSelectedTools] = useState(new Set());
+    const [done, setDone] = useState(false);
+    const apiKey = getApiKey();
+    const assistantId = getAssistantId();
+    const assistantName = getAssistantName();
+    const toggleTool = (tool) => {
+        const newSet = new Set(selectedTools);
+        if (newSet.has(tool)) {
+            newSet.delete(tool);
+        }
+        else {
+            newSet.add(tool);
+        }
+        setSelectedTools(newSet);
+    };
+    const applyConfig = () => {
+        if (!apiKey || !assistantId)
+            return;
+        for (const tool of selectedTools) {
+            if (tool === 'claude-code') {
+                writeClaudeMcpConfig(assistantId, apiKey);
+            }
+            else if (tool === 'opencode') {
+                writeOpenCodeMcpConfig(assistantId, apiKey);
+            }
+        }
+        setDone(true);
+    };
+    const items = [
+        ...ALL_TOOLS.map(tool => ({
+            key: tool,
+            label: `${selectedTools.has(tool) ? '✓' : ' '} ${tool === 'claude-code' ? 'Claude Code' : 'OpenCode'}`,
+            value: tool,
+        })),
+        { key: 'apply', label: '→ Применить', value: 'apply' },
+        { key: 'back', label: '← Назад', value: 'back' },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'back') {
+            onBack();
+        }
+        else if (item.value === 'apply') {
+            if (selectedTools.size === 0 || !apiKey || !assistantId)
+                return;
+            applyConfig();
+        }
+        else {
+            toggleTool(item.value);
+        }
+    };
+    if (done) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { bold: true, color: "green" }, "MCP \u0441\u0435\u0440\u0432\u0435\u0440 \u043D\u0430\u0441\u0442\u0440\u043E\u0435\u043D!")),
+            React.createElement(Box, { flexDirection: "column", marginBottom: 1 },
+                React.createElement(Text, null, "URL: https://api.er-gpt.ru/mcp/sse"),
+                React.createElement(Text, null,
+                    "Assistant: ",
+                    assistantName),
+                React.createElement(Text, { dimColor: true }, "Headers:"),
+                React.createElement(Text, { dimColor: true }, " Authorization: Bearer ***"),
+                React.createElement(Text, { dimColor: true },
+                    " X-Assistant-Id: ",
+                    assistantId)),
+            React.createElement(Box, { flexDirection: "column" },
+                selectedTools.has('claude-code') && (React.createElement(Text, null,
+                    " \u2022 Claude Code: ",
+                    getClaudeUserConfigPath())),
+                selectedTools.has('opencode') && (React.createElement(Text, null,
+                    " \u2022 OpenCode: ",
+                    getOpenCodeConfigPath()))),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { dimColor: true }, "\u041D\u0430\u0436\u043C\u0438\u0442\u0435 Enter \u0434\u043B\u044F \u0432\u043E\u0437\u0432\u0440\u0430\u0442\u0430 \u0432 \u043C\u0435\u043D\u044E")),
+            React.createElement(SelectInput, { items: [{ key: 'done', label: 'Готово', value: 'done' }], onSelect: onComplete })));
+    }
+    if (!apiKey) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" }, "\u0421\u043D\u0430\u0447\u0430\u043B\u0430 \u0432\u0432\u0435\u0434\u0438\u0442\u0435 API \u043A\u043B\u044E\u0447")),
+            React.createElement(SelectInput, { items: [{ key: 'back', label: '← Назад', value: 'back' }], onSelect: onBack })));
+    }
+    if (!assistantId) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Text, { color: "red" }, "\u0421\u043D\u0430\u0447\u0430\u043B\u0430 \u0432\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0430\u0441\u0441\u0438\u0441\u0442\u0435\u043D\u0442\u0430")),
+            React.createElement(SelectInput, { items: [{ key: 'back', label: '← Назад', value: 'back' }], onSelect: onBack })));
+    }
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "\u041D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0430 MCP \u0441\u0435\u0440\u0432\u0435\u0440\u0430")),
+        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { dimColor: true }, "URL: https://api.er-gpt.ru/mcp/sse"),
+            React.createElement(Text, { dimColor: true },
+                "Assistant: ",
+                assistantName)),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u0434\u043B\u044F \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438:")),
+        React.createElement(SelectInput, { items: items, onSelect: handleSelect }),
+        selectedTools.size === 0 && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "yellow" }, "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0445\u043E\u0442\u044F \u0431\u044B \u043E\u0434\u0438\u043D \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442")))));
+}

package/dist/components/ModeSelect.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface Props {
+    onSelect: (withAssistant: boolean) => void;
+    onBack: () => void;
+}
+export default function ModeSelect({ onSelect, onBack }: Props): React.JSX.Element;
+export {};

package/dist/components/ModeSelect.js

@@ -0,0 +1,26 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+export default function ModeSelect({ onSelect, onBack }) {
+    const items = [
+        { key: 'with', label: 'Выбрать ассистента', value: 'with' },
+        { key: 'without', label: 'Без ассистента (обычный режим)', value: 'without' },
+        { key: 'back', label: '← Назад', value: 'back' },
+    ];
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0440\u0435\u0436\u0438\u043C")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0441\u043F\u043E\u0441\u043E\u0431 \u043D\u0430\u0441\u0442\u0440\u043E\u0439\u043A\u0438 API:")),
+        React.createElement(SelectInput, { items: items, onSelect: (item) => {
+                if (item.value === 'back') {
+                    onBack();
+                }
+                else if (item.value === 'with') {
+                    onSelect(true);
+                }
+                else {
+                    onSelect(false);
+                }
+            } })));
+}

package/dist/components/ReviewScreen.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { Tool } from '../types.js';
+interface Props {
+    apiKey: string;
+    assistantId: string | null;
+    assistantName: string | null;
+    targets: Tool[];
+    onApply: () => void;
+    onBack: () => void;
+}
+export default function ReviewScreen({ apiKey, assistantId, assistantName, targets, onApply, onBack, }: Props): React.JSX.Element;
+export {};

package/dist/components/ReviewScreen.js

@@ -0,0 +1,77 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+import { getAnthropicBaseUrl, getAssistant } from '../api/ergpt.js';
+import { getClaudeConfigPath } from '../tools/claude-code.js';
+import { getOpenCodeConfigPath } from '../tools/opencode.js';
+export default function ReviewScreen({ apiKey, assistantId, assistantName, targets, onApply, onBack, }) {
+    const [assistant, setAssistant] = useState(null);
+    const [loading, setLoading] = useState(false);
+    useEffect(() => {
+        if (assistantId && apiKey) {
+            setLoading(true);
+            getAssistant(apiKey, assistantId)
+                .then(setAssistant)
+                .catch(() => setAssistant(null))
+                .finally(() => setLoading(false));
+        }
+        else {
+            setAssistant(null);
+        }
+    }, [assistantId, apiKey]);
+    const baseUrl = getAnthropicBaseUrl(assistantId ?? undefined);
+    const maskedKey = `${apiKey.slice(0, 8)}...${apiKey.slice(-4)}`;
+    const items = [
+        { key: 'apply', label: '✓ Применить конфигурацию', value: 'apply' },
+        { key: 'back', label: '← Назад', value: 'back' },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'back') {
+            onBack();
+        }
+        else {
+            onApply();
+        }
+    };
+    const activeTools = assistant?.tools?.filter(t => t.active && t.tool) ?? [];
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "cyan" }, "\u041F\u0440\u043E\u0432\u0435\u0440\u043A\u0430 \u043A\u043E\u043D\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u0438")),
+        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "API \u041A\u043B\u044E\u0447:"),
+            React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { dimColor: true }, maskedKey))),
+        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "\u0420\u0435\u0436\u0438\u043C:"),
+            React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, null, assistantName
+                    ? `Ассистент: ${assistantName}`
+                    : 'Обычный (без ассистента)'))),
+        assistantId && (React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "\u0418\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B \u0430\u0441\u0441\u0438\u0441\u0442\u0435\u043D\u0442\u0430:"),
+            loading ? (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { dimColor: true }, "\u0417\u0430\u0433\u0440\u0443\u0437\u043A\u0430..."))) : activeTools.length > 0 ? (activeTools.map(t => (React.createElement(Box, { key: t.id, marginLeft: 2 },
+                React.createElement(Text, { dimColor: true },
+                    "\u2022 ",
+                    t.tool?.name))))) : (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { dimColor: true }, "\u041D\u0435\u0442 \u0430\u043A\u0442\u0438\u0432\u043D\u044B\u0445 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u043E\u0432"))))),
+        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "Base URL:"),
+            React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { dimColor: true }, baseUrl))),
+        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "\u0426\u0435\u043B\u0435\u0432\u044B\u0435 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B:"),
+            targets.map(tool => (React.createElement(Box, { key: tool, marginLeft: 2 },
+                React.createElement(Text, { dimColor: true },
+                    "\u2022 ",
+                    tool === 'claude-code' ? 'Claude Code' : 'OpenCode'),
+                React.createElement(Box, { marginLeft: 2 },
+                    React.createElement(Text, { dimColor: true },
+                        "\u2192",
+                        ' ',
+                        tool === 'claude-code'
+                            ? getClaudeConfigPath()
+                            : getOpenCodeConfigPath())))))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(SelectInput, { items: items, onSelect: handleSelect }))));
+}

package/dist/components/SuccessScreen.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { Tool } from '../types.js';
+interface Props {
+    targets: Tool[];
+    assistantName: string | null;
+    onDone: () => void;
+}
+export default function SuccessScreen({ targets, assistantName, onDone }: Props): React.JSX.Element;
+export {};

package/dist/components/SuccessScreen.js

@@ -0,0 +1,24 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+export default function SuccessScreen({ targets, assistantName, onDone }) {
+    const items = [{ key: 'done', label: '✓ Готово', value: 'done' }];
+    const handleSelect = () => {
+        onDone();
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true, color: "green" }, "\u2713 \u041A\u043E\u043D\u0444\u0438\u0433\u0443\u0440\u0430\u0446\u0438\u044F \u043F\u0440\u0438\u043C\u0435\u043D\u0435\u043D\u0430!")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, null, assistantName
+                ? `Ассистент "${assistantName}" настроен`
+                : 'Обычный режим настроен')),
+        React.createElement(Box, { marginBottom: 1, flexDirection: "column" },
+            React.createElement(Text, { bold: true }, "\u0422\u0435\u043F\u0435\u0440\u044C \u0432\u044B \u043C\u043E\u0436\u0435\u0442\u0435 \u0438\u0441\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u044C:"),
+            targets.includes('claude-code') && (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { dimColor: true }, "\u2022 claude"))),
+            targets.includes('opencode') && (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { dimColor: true }, "\u2022 opencode")))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(SelectInput, { items: items, onSelect: handleSelect }))));
+}

package/dist/components/ToolSelect.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { Tool } from '../types.js';
+interface Props {
+    onSelect: (tools: Tool[]) => void;
+    onBack: () => void;
+    initialTools?: Tool[];
+}
+export default function ToolSelect({ onSelect, onBack, initialTools }: Props): React.JSX.Element;
+export {};

package/dist/components/ToolSelect.js

@@ -0,0 +1,48 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import SelectInput from 'ink-select-input';
+const ALL_TOOLS = ['claude-code', 'opencode'];
+export default function ToolSelect({ onSelect, onBack, initialTools = [] }) {
+    const [selectedTools, setSelectedTools] = useState(new Set(initialTools));
+    const toggleTool = (tool) => {
+        const newSet = new Set(selectedTools);
+        if (newSet.has(tool)) {
+            newSet.delete(tool);
+        }
+        else {
+            newSet.add(tool);
+        }
+        setSelectedTools(newSet);
+    };
+    const items = [
+        ...ALL_TOOLS.map((tool) => ({
+            key: tool,
+            label: `${selectedTools.has(tool) ? '✓' : ' '} ${tool === 'claude-code' ? 'Claude Code' : 'OpenCode'}`,
+            value: tool,
+        })),
+        { key: 'continue', label: '→ Продолжить', value: 'continue' },
+        { key: 'back', label: '← Назад', value: 'back' },
+    ];
+    const handleSelect = (item) => {
+        if (item.value === 'back') {
+            onBack();
+        }
+        else if (item.value === 'continue') {
+            if (selectedTools.size === 0) {
+                return;
+            }
+            onSelect(Array.from(selectedTools));
+        }
+        else {
+            toggleTool(item.value);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442\u044B")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { dimColor: true }, "\u041D\u0430\u0436\u043C\u0438\u0442\u0435 Enter \u0434\u043B\u044F \u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0435\u043D\u0438\u044F, \u0437\u0430\u0442\u0435\u043C \"\u041F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442\u044C\"")),
+        React.createElement(SelectInput, { items: items, onSelect: handleSelect }),
+        selectedTools.size === 0 && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "yellow" }, "\u0412\u044B\u0431\u0435\u0440\u0438\u0442\u0435 \u0445\u043E\u0442\u044F \u0431\u044B \u043E\u0434\u0438\u043D \u0438\u043D\u0441\u0442\u0440\u0443\u043C\u0435\u043D\u0442")))));
+}

package/dist/store.d.ts

@@ -0,0 +1,12 @@
+import type { StoreConfig, Tool } from './types.js';
+export declare function getApiKey(): string | undefined;
+export declare function setApiKey(key: string): void;
+export declare function getAssistantId(): string | undefined;
+export declare function setAssistantId(id: string | undefined): void;
+export declare function getAssistantName(): string | undefined;
+export declare function setAssistantName(name: string | undefined): void;
+export declare function getTargets(): Tool[];
+export declare function setTargets(targets: Tool[]): void;
+export declare function clearConfig(): void;
+export declare function getConfigPath(): string;
+export declare function getConfig(): StoreConfig;

package/dist/store.js

@@ -0,0 +1,52 @@
+import Conf from 'conf';
+const config = new Conf({
+    projectName: 'ergpt-helpers',
+});
+export function getApiKey() {
+    return config.get('apiKey');
+}
+export function setApiKey(key) {
+    config.set('apiKey', key);
+}
+export function getAssistantId() {
+    return config.get('assistantId');
+}
+export function setAssistantId(id) {
+    if (id) {
+        config.set('assistantId', id);
+    }
+    else {
+        config.delete('assistantId');
+    }
+}
+export function getAssistantName() {
+    return config.get('assistantName');
+}
+export function setAssistantName(name) {
+    if (name) {
+        config.set('assistantName', name);
+    }
+    else {
+        config.delete('assistantName');
+    }
+}
+export function getTargets() {
+    return config.get('targets') ?? [];
+}
+export function setTargets(targets) {
+    config.set('targets', targets);
+}
+export function clearConfig() {
+    config.clear();
+}
+export function getConfigPath() {
+    return config.path;
+}
+export function getConfig() {
+    return {
+        apiKey: getApiKey(),
+        assistantId: getAssistantId(),
+        assistantName: getAssistantName(),
+        targets: getTargets(),
+    };
+}

package/dist/tools/claude-code.d.ts

@@ -0,0 +1,19 @@
+import type { ClaudeUserConfig } from '../types.js';
+interface ClaudeSettings {
+    env?: {
+        ANTHROPIC_AUTH_TOKEN?: string;
+        ANTHROPIC_BASE_URL?: string;
+        [key: string]: string | undefined;
+    };
+    [key: string]: unknown;
+}
+export declare function readClaudeSettings(): ClaudeSettings | null;
+export declare function writeClaudeSettings(apiKey: string, baseUrl: string): void;
+export declare function clearClaudeSettings(): void;
+export declare function getClaudeConfigPath(): string;
+export declare function readClaudeUserConfig(): ClaudeUserConfig | null;
+export declare function writeClaudeMcpConfig(assistantId: string, apiKey: string): void;
+export declare function clearClaudeMcpConfig(): void;
+export declare function getClaudeUserConfigPath(): string;
+export declare function hasClaudeMcpConfig(): boolean;
+export {};

package/dist/tools/claude-code.js

@@ -0,0 +1,108 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
+const CLAUDE_USER_CONFIG_PATH = path.join(os.homedir(), '.claude.json');
+const MCP_SERVER_NAME = 'ergpt';
+export function readClaudeSettings() {
+    try {
+        if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+            return null;
+        }
+        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeClaudeSettings(apiKey, baseUrl) {
+    const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    let settings = {};
+    try {
+        if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+            const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf-8');
+            settings = JSON.parse(content);
+        }
+    }
+    catch {
+        settings = {};
+    }
+    settings.env = {
+        ...settings.env,
+        ANTHROPIC_AUTH_TOKEN: apiKey,
+        ANTHROPIC_BASE_URL: baseUrl,
+    };
+    fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+}
+export function clearClaudeSettings() {
+    const settings = readClaudeSettings();
+    if (settings?.env) {
+        delete settings.env.ANTHROPIC_AUTH_TOKEN;
+        delete settings.env.ANTHROPIC_BASE_URL;
+        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+    }
+}
+export function getClaudeConfigPath() {
+    return CLAUDE_SETTINGS_PATH;
+}
+export function readClaudeUserConfig() {
+    try {
+        if (!fs.existsSync(CLAUDE_USER_CONFIG_PATH)) {
+            return null;
+        }
+        const content = fs.readFileSync(CLAUDE_USER_CONFIG_PATH, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeClaudeMcpConfig(assistantId, apiKey) {
+    const dir = path.dirname(CLAUDE_USER_CONFIG_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    let config = {};
+    try {
+        if (fs.existsSync(CLAUDE_USER_CONFIG_PATH)) {
+            const content = fs.readFileSync(CLAUDE_USER_CONFIG_PATH, 'utf-8');
+            config = JSON.parse(content);
+        }
+    }
+    catch {
+        config = {};
+    }
+    if (!config.mcpServers) {
+        config.mcpServers = {};
+    }
+    config.mcpServers[MCP_SERVER_NAME] = {
+        type: 'sse',
+        url: 'https://api.er-gpt.ru/mcp/sse',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'X-Assistant-Id': assistantId,
+        },
+    };
+    fs.writeFileSync(CLAUDE_USER_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+export function clearClaudeMcpConfig() {
+    const config = readClaudeUserConfig();
+    if (config?.mcpServers?.[MCP_SERVER_NAME]) {
+        delete config.mcpServers[MCP_SERVER_NAME];
+        if (Object.keys(config.mcpServers).length === 0) {
+            delete config.mcpServers;
+        }
+        fs.writeFileSync(CLAUDE_USER_CONFIG_PATH, JSON.stringify(config, null, 2));
+    }
+}
+export function getClaudeUserConfigPath() {
+    return CLAUDE_USER_CONFIG_PATH;
+}
+export function hasClaudeMcpConfig() {
+    const config = readClaudeUserConfig();
+    return !!config?.mcpServers?.[MCP_SERVER_NAME];
+}

package/dist/tools/opencode.d.ts

@@ -0,0 +1,26 @@
+import type { OpenCodeMcpServerConfig } from '../types.js';
+interface OpenCodeProviderOptions {
+    apiKey?: string;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    [key: string]: unknown;
+}
+interface OpenCodeProvider {
+    ergpt?: {
+        options?: OpenCodeProviderOptions;
+    };
+    [key: string]: unknown;
+}
+interface OpenCodeConfig {
+    provider?: OpenCodeProvider;
+    mcp?: Record<string, OpenCodeMcpServerConfig>;
+    [key: string]: unknown;
+}
+export declare function readOpenCodeConfig(): OpenCodeConfig | null;
+export declare function writeOpenCodeConfig(apiKey: string, baseUrl: string): void;
+export declare function clearOpenCodeConfig(): void;
+export declare function getOpenCodeConfigPath(): string;
+export declare function writeOpenCodeMcpConfig(assistantId: string, apiKey: string): void;
+export declare function clearOpenCodeMcpConfig(): void;
+export declare function hasOpenCodeMcpConfig(): boolean;
+export {};

package/dist/tools/opencode.js

@@ -0,0 +1,99 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const OPENCODE_CONFIG_PATH = path.join(os.homedir(), '.config', 'opencode', 'opencode.json');
+const MCP_SERVER_NAME = 'ergpt';
+export function readOpenCodeConfig() {
+    try {
+        if (!fs.existsSync(OPENCODE_CONFIG_PATH)) {
+            return null;
+        }
+        const content = fs.readFileSync(OPENCODE_CONFIG_PATH, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeOpenCodeConfig(apiKey, baseUrl) {
+    const dir = path.dirname(OPENCODE_CONFIG_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    let config = {};
+    try {
+        if (fs.existsSync(OPENCODE_CONFIG_PATH)) {
+            const content = fs.readFileSync(OPENCODE_CONFIG_PATH, 'utf-8');
+            config = JSON.parse(content);
+        }
+    }
+    catch {
+        config = {};
+    }
+    if (!config.provider) {
+        config.provider = {};
+    }
+    if (!config.provider.ergpt) {
+        config.provider.ergpt = {};
+    }
+    if (!config.provider.ergpt.options) {
+        config.provider.ergpt.options = {};
+    }
+    config.provider.ergpt.options.apiKey = apiKey;
+    config.provider.ergpt.options.baseURL = baseUrl;
+    fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+export function clearOpenCodeConfig() {
+    const config = readOpenCodeConfig();
+    if (config?.provider?.ergpt?.options) {
+        delete config.provider.ergpt.options.apiKey;
+        delete config.provider.ergpt.options.baseURL;
+        fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+    }
+}
+export function getOpenCodeConfigPath() {
+    return OPENCODE_CONFIG_PATH;
+}
+export function writeOpenCodeMcpConfig(assistantId, apiKey) {
+    const dir = path.dirname(OPENCODE_CONFIG_PATH);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    let config = {};
+    try {
+        if (fs.existsSync(OPENCODE_CONFIG_PATH)) {
+            const content = fs.readFileSync(OPENCODE_CONFIG_PATH, 'utf-8');
+            config = JSON.parse(content);
+        }
+    }
+    catch {
+        config = {};
+    }
+    if (!config.mcp) {
+        config.mcp = {};
+    }
+    config.mcp[MCP_SERVER_NAME] = {
+        type: 'remote',
+        url: 'https://api.er-gpt.ru/mcp/sse',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'X-Assistant-Id': assistantId,
+        },
+        enabled: true,
+    };
+    fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+export function clearOpenCodeMcpConfig() {
+    const config = readOpenCodeConfig();
+    if (config?.mcp?.[MCP_SERVER_NAME]) {
+        delete config.mcp[MCP_SERVER_NAME];
+        if (Object.keys(config.mcp).length === 0) {
+            delete config.mcp;
+        }
+        fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+    }
+}
+export function hasOpenCodeMcpConfig() {
+    const config = readOpenCodeConfig();
+    return !!config?.mcp?.[MCP_SERVER_NAME];
+}