@x-all-in-one/coding-helper 0.0.0

package/dist/lib/i18n.js

@@ -0,0 +1,148 @@
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+class I18n {
+    static instance;
+    currentLocale = 'en_US';
+    translations = new Map();
+    fallbackLocale = 'en_US';
+    localesDir;
+    constructor() {
+        // Determine the locales directory path
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // Both in development (src/lib/i18n.ts) and production (dist/lib/i18n.js),
+        // locales is at the same relative path: lib -> parent -> locales
+        this.localesDir = join(__dirname, '..', 'locales');
+        this.loadTranslations();
+        this.loadSavedLocale();
+    }
+    static getInstance() {
+        if (!I18n.instance) {
+            I18n.instance = new I18n();
+        }
+        return I18n.instance;
+    }
+    loadTranslations() {
+        try {
+            // Check if locales directory exists
+            if (!existsSync(this.localesDir)) {
+                console.warn(`Locales directory not found at ${this.localesDir}`);
+                return;
+            }
+            // Get all JSON files in the locales directory
+            const files = readdirSync(this.localesDir);
+            const localeFiles = files.filter(file => file.endsWith('.json'));
+            if (localeFiles.length === 0) {
+                console.warn('No locale files found in locales directory');
+                return;
+            }
+            // Load each locale file
+            for (const file of localeFiles) {
+                const locale = file.replace('.json', '');
+                const filePath = join(this.localesDir, file);
+                try {
+                    const fileContent = readFileSync(filePath, 'utf-8');
+                    const translations = JSON.parse(fileContent);
+                    this.translations.set(locale, translations);
+                }
+                catch (error) {
+                    console.warn(`Failed to load locale file ${file}:`, error);
+                }
+            }
+            // Try to detect locale from environment
+            const envLocale = process.env.LANG || process.env.LC_ALL || process.env.LC_MESSAGES;
+            if (envLocale) {
+                const localeCode = envLocale.split('.')[0].replace('_', '-');
+                // First try exact match
+                if (this.translations.has(localeCode)) {
+                    this.currentLocale = localeCode;
+                }
+                else {
+                    // Try language-only match (e.g., 'en' from 'en-US')
+                    const langOnly = localeCode.split('-')[0];
+                    const matchingLocale = Array.from(this.translations.keys()).find(key => key.startsWith(langOnly + '_'));
+                    if (matchingLocale) {
+                        this.currentLocale = matchingLocale;
+                    }
+                    else if (langOnly === 'zh') {
+                        // Fallback to zh_CN for Chinese
+                        this.currentLocale = 'zh_CN';
+                    }
+                    else if (langOnly === 'en') {
+                        // Fallback to en_US for English
+                        this.currentLocale = 'en_US';
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load translations:', error);
+        }
+    }
+    setLocale(locale) {
+        if (this.translations.has(locale)) {
+            this.currentLocale = locale;
+            this.saveLocale();
+        }
+        else {
+            console.warn(`Locale '${locale}' not supported, falling back to '${this.currentLocale}'`);
+        }
+    }
+    getLocale() {
+        return this.currentLocale;
+    }
+    getAvailableLocales() {
+        return Array.from(this.translations.keys());
+    }
+    translate(key, params) {
+        const keys = key.split('.');
+        let translation = this.translations.get(this.currentLocale);
+        for (const k of keys) {
+            if (translation && typeof translation === 'object' && k in translation) {
+                translation = translation[k];
+            }
+            else {
+                // Fallback to fallback locale
+                translation = this.translations.get(this.fallbackLocale);
+                for (const fallbackKey of keys) {
+                    if (translation && typeof translation === 'object' && fallbackKey in translation) {
+                        translation = translation[fallbackKey];
+                    }
+                    else {
+                        return key; // Return key if translation not found
+                    }
+                }
+                break;
+            }
+        }
+        if (typeof translation !== 'string') {
+            return key;
+        }
+        // Replace parameters in the translation string
+        if (params) {
+            return translation.replace(/\{\{(\w+)\}\}/g, (match, param) => {
+                return params[param] || match;
+            });
+        }
+        return translation;
+    }
+    t(key, params) {
+        return this.translate(key, params);
+    }
+    saveLocale() {
+        // Language is now saved via ConfigManager
+        // This method is kept for compatibility
+    }
+    loadSavedLocale() {
+        // Language is now loaded via ConfigManager
+        // This method is kept for compatibility
+    }
+    loadFromConfig(locale) {
+        if (this.translations.has(locale)) {
+            this.currentLocale = locale;
+        }
+    }
+}
+export const i18n = I18n.getInstance();
+export { i18n as I18n };

package/dist/lib/tool-manager.d.ts

@@ -0,0 +1,24 @@
+import { ModelConfig } from './claude-code-manager.js';
+export interface ToolInfo {
+    name: string;
+    command: string;
+    installCommand: string;
+    configPath: string;
+    displayName: string;
+    hidden?: boolean;
+}
+export declare const SUPPORTED_TOOLS: Record<string, ToolInfo>;
+export declare class ToolManager {
+    private static instance;
+    private constructor();
+    static getInstance(): ToolManager;
+    isToolInstalled(toolName: string): boolean;
+    installTool(toolName: string): Promise<void>;
+    getToolConfig(toolName: string): any;
+    updateToolConfig(toolName: string, config: any): void;
+    loadModelConfig(toolName: string, config: ModelConfig): void;
+    getInstalledTools(): string[];
+    getSupportedTools(): ToolInfo[];
+    isGitInstalled(): boolean;
+}
+export declare const toolManager: ToolManager;

package/dist/lib/tool-manager.js

@@ -0,0 +1,256 @@
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { claudeCodeManager } from './claude-code-manager.js';
+import { i18n } from './i18n.js';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import terminalLink from 'terminal-link';
+import ora from "ora";
+export const SUPPORTED_TOOLS = {
+    'claude-code': {
+        name: 'claude-code',
+        command: 'claude',
+        installCommand: 'npm install -g @anthropic-ai/claude-code',
+        configPath: join(homedir(), '.claude', 'settings.json'),
+        displayName: 'Claude Code'
+    },
+    'opencode': {
+        name: 'opencode',
+        command: 'opencode',
+        installCommand: 'npm install -g opencode',
+        configPath: join(homedir(), '.config', 'opencode', 'config.json'),
+        displayName: 'OpenCode',
+        hidden: true // 暂不适配，隐藏不展示
+    }
+};
+export class ToolManager {
+    static instance;
+    constructor() { }
+    static getInstance() {
+        if (!ToolManager.instance) {
+            ToolManager.instance = new ToolManager();
+        }
+        return ToolManager.instance;
+    }
+    isToolInstalled(toolName) {
+        const tool = SUPPORTED_TOOLS[toolName];
+        if (!tool)
+            return false;
+        try {
+            // Windows 使用 where 命令，Unix 系统使用 which 命令
+            const checkCommand = process.platform === 'win32'
+                ? `where ${tool.command}`
+                : `which ${tool.command}`;
+            execSync(checkCommand, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async installTool(toolName) {
+        const tool = SUPPORTED_TOOLS[toolName];
+        if (!tool) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        const spinner = ora(i18n.t('wizard.installing_tool')).start();
+        try {
+            // 首次尝试正常安装
+            execSync(tool.installCommand, { stdio: 'inherit' });
+            spinner.succeed(i18n.t('wizard.tool_installed'));
+        }
+        catch (error) {
+            spinner.fail(i18n.t('wizard.install_failed'));
+            // 检查是否是权限错误 (EACCES)
+            // execSync 的错误信息可能在 stderr 中，需要检查多个来源
+            const errorMessage = (error.message || '') + (error.stderr?.toString() || '') + (error.stdout?.toString() || '');
+            const isPermissionError = errorMessage.includes('EACCES') ||
+                errorMessage.includes('permission denied') ||
+                errorMessage.includes('EPERM') ||
+                error.status === 243; // npm 权限错误的退出码
+            if (!isPermissionError) {
+                // 如果不是权限错误，直接抛出
+                throw new Error(`Failed to install ${tool.displayName}: ${error}`);
+            }
+            console.log('\n⚠️  ' + i18n.t('install.permission_detected') + '\n');
+            // Windows 平台处理
+            if (process.platform === 'win32') {
+                try {
+                    // Windows: 尝试使用用户级安装（不需要管理员权限）
+                    const userInstallCommand = tool.installCommand.replace('npm install -g', 'npm install -g --force');
+                    console.log('🔧 ' + i18n.t('install.trying_solution', { num: '1', desc: i18n.t('install.using_force') }));
+                    execSync(userInstallCommand, { stdio: 'inherit' });
+                    console.log('\n✅ ' + i18n.t('install.permission_fixed'));
+                    return;
+                }
+                catch (retryError) {
+                    // 如果还是失败，显示解决方案并询问用户
+                    console.log(`Retry install error ${retryError}`);
+                    console.log('\n❌ ' + i18n.t('install.auto_fix_failed'));
+                    console.log(chalk.yellow('\n📌 ' + i18n.t('install.windows_solutions')));
+                    console.log('');
+                    // 方案 1: 以管理员身份运行
+                    console.log(chalk.cyan.bold(i18n.t('install.windows_solution_1_title')));
+                    console.log(chalk.gray('  ' + i18n.t('install.windows_solution_1_step1')));
+                    console.log(chalk.gray('  ' + i18n.t('install.windows_solution_1_step2')));
+                    console.log(chalk.gray('  ' + i18n.t('install.windows_solution_1_step3')));
+                    console.log(chalk.white(`  ${tool.installCommand}`));
+                    console.log('');
+                    // 方案 2: 用户级安装
+                    console.log(chalk.cyan.bold(i18n.t('install.windows_solution_2_title')));
+                    console.log(chalk.gray('  ' + i18n.t('install.windows_solution_2_command')));
+                    console.log(chalk.white(`  ${tool.installCommand.replace('npm install -g', 'npm install -g --prefix=%APPDATA%\\npm')}`));
+                    console.log('');
+                    // 询问用户是否已完成安装
+                    const { action } = await inquirer.prompt([
+                        {
+                            type: 'list',
+                            name: 'action',
+                            message: i18n.t('install.what_next'),
+                            choices: [
+                                { name: i18n.t('install.installed_continue'), value: 'continue' },
+                                { name: i18n.t('install.cancel_install'), value: 'cancel' }
+                            ]
+                        }
+                    ]);
+                    if (action === 'cancel') {
+                        throw new Error(i18n.t('install.user_cancelled'));
+                    }
+                    // 验证是否真的安装成功
+                    if (!this.isToolInstalled(toolName)) {
+                        console.log(chalk.red('\n❌ ' + i18n.t('install.still_not_installed', { tool: tool.displayName })));
+                        throw new Error(`${tool.displayName} is not installed`);
+                    }
+                    console.log(chalk.green('\n✅ ' + i18n.t('install.verified_success', { tool: tool.displayName })));
+                    return;
+                }
+            }
+            // macOS 和 Linux 平台处理 - 显示建议而不是自动执行
+            console.log(chalk.yellow('\n📌 ' + i18n.t('install.unix_solutions')));
+            console.log('');
+            // 方案 1: 使用 sudo
+            console.log(chalk.cyan.bold(i18n.t('install.unix_solution_1_title')));
+            console.log(chalk.gray('  ' + i18n.t('install.unix_solution_1_desc')));
+            console.log(chalk.white(`  sudo ${tool.installCommand}`));
+            console.log('');
+            // 方案 2: 使用 nvm (推荐)
+            const npmDocsUrl = 'https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally';
+            const clickableLink = terminalLink(npmDocsUrl, npmDocsUrl, { fallback: () => npmDocsUrl });
+            console.log(chalk.cyan.bold(i18n.t('install.unix_solution_2_title')));
+            console.log(chalk.gray('  ' + i18n.t('install.unix_solution_2_desc')));
+            console.log(chalk.blue('  📖 ' + i18n.t('install.npm_docs_link') + ': ') + clickableLink);
+            console.log('');
+            // 询问用户是否已完成安装
+            const { action } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: i18n.t('install.what_next'),
+                    choices: [
+                        { name: i18n.t('install.installed_continue'), value: 'continue' },
+                        { name: i18n.t('install.cancel_install'), value: 'cancel' }
+                    ]
+                }
+            ]);
+            if (action === 'cancel') {
+                throw new Error(i18n.t('install.user_cancelled'));
+            }
+            // 验证是否真的安装成功
+            if (!this.isToolInstalled(toolName)) {
+                console.log(chalk.red('\n❌ ' + i18n.t('install.still_not_installed', { tool: tool.displayName })));
+                throw new Error(`${tool.displayName} is not installed`);
+            }
+            console.log(chalk.green('\n✅ ' + i18n.t('install.verified_success', { tool: tool.displayName })));
+            return;
+        }
+    }
+    getToolConfig(toolName) {
+        const tool = SUPPORTED_TOOLS[toolName];
+        if (!tool) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        // Claude Code 使用专门的管理器
+        if (toolName === 'claude-code') {
+            return {
+                settings: claudeCodeManager.getSettings()
+            };
+        }
+        try {
+            if (existsSync(tool.configPath)) {
+                const content = readFileSync(tool.configPath, 'utf-8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to read config for ${toolName}:`, error);
+        }
+        return null;
+    }
+    updateToolConfig(toolName, config) {
+        const tool = SUPPORTED_TOOLS[toolName];
+        if (!tool) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        // Claude Code 使用专门的管理器
+        if (toolName === 'claude-code') {
+            if (config.settings) {
+                claudeCodeManager.saveSettings(config.settings);
+            }
+            return;
+        }
+        try {
+            // 使用 dirname 获取目录路径，确保跨平台兼容（Windows/macOS/Linux）
+            const configDir = dirname(tool.configPath);
+            if (!existsSync(configDir)) {
+                mkdirSync(configDir, { recursive: true });
+            }
+            writeFileSync(tool.configPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to update config for ${toolName}: ${error}`);
+        }
+    }
+    loadModelConfig(toolName, config) {
+        const tool = SUPPORTED_TOOLS[toolName];
+        if (!tool) {
+            throw new Error(`Unknown tool: ${toolName}`);
+        }
+        // Claude Code 使用专门的管理器
+        if (toolName === 'claude-code') {
+            claudeCodeManager.saveModelConfig(config);
+            return;
+        }
+        // 其他工具的配置
+        let existingConfig = this.getToolConfig(toolName) || {};
+        existingConfig = {
+            ...existingConfig,
+            apiKey: config.apiKey,
+            haikuModel: config.haikuModel,
+            sonnetModel: config.sonnetModel,
+            opusModel: config.opusModel
+        };
+        this.updateToolConfig(toolName, existingConfig);
+    }
+    getInstalledTools() {
+        return Object.keys(SUPPORTED_TOOLS).filter(toolName => this.isToolInstalled(toolName));
+    }
+    getSupportedTools() {
+        return Object.values(SUPPORTED_TOOLS).filter(tool => !tool.hidden);
+    }
+    isGitInstalled() {
+        try {
+            // Windows 使用 where 命令，Unix 系统使用 which 命令
+            const checkCommand = process.platform === 'win32'
+                ? `where git`
+                : `which git`;
+            execSync(checkCommand, { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export const toolManager = ToolManager.getInstance();

package/dist/lib/wizard.d.ts

@@ -0,0 +1,44 @@
+export declare class Wizard {
+    static instance: any;
+    BOX_WIDTH: number;
+    private cachedModels;
+    constructor();
+    static getInstance(): any;
+    /**
+     * Create a simple box with title using double-line border style
+     */
+    createBox(title: any): void;
+    /**
+     * Display operation hints
+     */
+    showOperationHints(): void;
+    /**
+     * Prompt wrapper that shows operation hints
+     */
+    promptWithHints(questions: any): Promise<import("inquirer").Answers>;
+    printBanner(): void;
+    resetScreen(): void;
+    runFirstTimeSetup(): Promise<void>;
+    configLanguage(): Promise<void>;
+    configApiKey(): Promise<void>;
+    /**
+     * Fetch and cache available models
+     */
+    fetchModels(): Promise<string[]>;
+    /**
+     * Configure models menu
+     */
+    configModels(): Promise<void>;
+    /**
+     * Step-by-step model selection
+     */
+    selectModels(): Promise<void>;
+    selectAndConfigureTool(): Promise<void>;
+    configureTool(toolName: any): Promise<void>;
+    showMainMenu(): Promise<void>;
+    showToolMenu(toolName: any): Promise<void>;
+    startTool(toolName: any): Promise<void>;
+    loadModelConfig(toolName: any): Promise<void>;
+    unloadModelConfig(toolName: any): Promise<void>;
+}
+export declare const wizard: any;