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

package/dist/lib/api-validator.js

@@ -0,0 +1,75 @@
+/**
+ * API Key 和网络验证模块
+ * 通过调用模型列表 API 来验证 API Key 的有效性和网络连通性
+ */
+const VALIDATION_URL = 'https://code-api.x-aio.com/v1/models';
+/**
+ * 验证 API Key 的有效性和网络连通性
+ *
+ * @param apiKey - API Key
+ * @returns 验证结果，包含 valid 状态和可选的错误信息
+ */
+export async function validateApiKey(apiKey) {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 秒超时
+        const response = await fetch(VALIDATION_URL, {
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'Content-Type': 'application/json'
+            },
+            signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 401) {
+            return {
+                valid: false,
+                error: 'invalid_api_key',
+                message: 'API Key is invalid or expired'
+            };
+        }
+        if (response.ok) {
+            // 尝试解析响应以确保是有效的 JSON
+            try {
+                const data = await response.json();
+                if (data && data.object === 'list') {
+                    return { valid: true };
+                }
+            }
+            catch {
+                // JSON 解析失败但响应成功，仍然视为有效
+                return { valid: true };
+            }
+            return { valid: true };
+        }
+        // 其他 HTTP 错误
+        return {
+            valid: false,
+            error: 'unknown_error',
+            message: `HTTP ${response.status}: ${response.statusText}`
+        };
+    }
+    catch (error) {
+        // 网络错误或超时
+        if (error instanceof Error) {
+            if (error.name === 'AbortError') {
+                return {
+                    valid: false,
+                    error: 'network_error',
+                    message: 'Request timeout'
+                };
+            }
+            return {
+                valid: false,
+                error: 'network_error',
+                message: error.message
+            };
+        }
+        return {
+            valid: false,
+            error: 'network_error',
+            message: 'Network connection failed'
+        };
+    }
+}

package/dist/lib/claude-code-manager.d.ts

@@ -0,0 +1,79 @@
+export declare const DEFAULT_CONFIG: {
+    ANTHROPIC_BASE_URL: string;
+    ANTHROPIC_API_KEY: string;
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: string;
+    ANTHROPIC_DEFAULT_SONNET_MODEL: string;
+    ANTHROPIC_DEFAULT_OPUS_MODEL: string;
+};
+export interface ModelConfig {
+    apiKey: string;
+    haikuModel: string;
+    sonnetModel: string;
+    opusModel: string;
+    baseUrl?: string;
+}
+export interface ClaudeCodeSettingsConfig {
+    env?: {
+        ANTHROPIC_API_KEY?: string;
+        ANTHROPIC_BASE_URL?: string;
+        ANTHROPIC_DEFAULT_HAIKU_MODEL?: string;
+        ANTHROPIC_DEFAULT_SONNET_MODEL?: string;
+        ANTHROPIC_DEFAULT_OPUS_MODEL?: string;
+        API_TIMEOUT_MS?: string;
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC?: number;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+export interface ClaudeCodeOnboardingConfig {
+    hasCompletedOnboarding?: boolean;
+    [key: string]: any;
+}
+export declare class ClaudeCodeManager {
+    private static instance;
+    private settingsPath;
+    private onboardingConfigPath;
+    private constructor();
+    static getInstance(): ClaudeCodeManager;
+    /**
+     * 确保配置目录存在
+     */
+    private ensureConfigDir;
+    /**
+     * 读取 settings.json 配置
+     */
+    getSettings(): ClaudeCodeSettingsConfig;
+    /**
+     * 保存 settings.json 配置
+     */
+    saveSettings(config: ClaudeCodeSettingsConfig): void;
+    /**
+     * 读取 onboarding 配置 (~/.claude.json)
+     */
+    private getOnboardingConfig;
+    /**
+     * 保存 onboarding 配置 (~/.claude.json)
+     */
+    private saveOnboardingConfig;
+    /**
+     * 确保 .claude.json 中有 hasCompletedOnboarding: true
+     */
+    private ensureOnboardingCompleted;
+    /**
+     * 从 API 获取可用的模型列表
+     */
+    fetchAvailableModels(apiKey: string): Promise<string[]>;
+    /**
+     * 保存模型配置到 Claude Code
+     */
+    saveModelConfig(config: ModelConfig): void;
+    /**
+     * 获取当前模型配置
+     */
+    getModelConfig(): ModelConfig | null;
+    /**
+     * 清除模型配置
+     */
+    clearModelConfig(): void;
+}
+export declare const claudeCodeManager: ClaudeCodeManager;

package/dist/lib/claude-code-manager.js

@@ -0,0 +1,201 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+// 默认配置
+export const DEFAULT_CONFIG = {
+    ANTHROPIC_BASE_URL: 'https://code-api.x-aio.com/anthropic',
+    ANTHROPIC_API_KEY: 'sk-xxx',
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: 'Qwen3-Coder-30B-A3B-Instruct',
+    ANTHROPIC_DEFAULT_SONNET_MODEL: 'MiniMax-M2',
+    ANTHROPIC_DEFAULT_OPUS_MODEL: 'Qwen3-Coder-480B-A35B-Instruct'
+};
+export class ClaudeCodeManager {
+    static instance;
+    settingsPath;
+    onboardingConfigPath;
+    constructor() {
+        // Claude Code 配置文件路径（跨平台支持）
+        // - macOS/Linux: ~/.claude/settings.json 和 ~/.claude.json
+        // - Windows: %USERPROFILE%\.claude\settings.json 和 %USERPROFILE%\.claude.json
+        //   (例如: C:\Users\username\.claude\settings.json)
+        this.settingsPath = join(homedir(), '.claude', 'settings.json');
+        this.onboardingConfigPath = join(homedir(), '.claude.json');
+    }
+    static getInstance() {
+        if (!ClaudeCodeManager.instance) {
+            ClaudeCodeManager.instance = new ClaudeCodeManager();
+        }
+        return ClaudeCodeManager.instance;
+    }
+    /**
+     * 确保配置目录存在
+     */
+    ensureConfigDir(filePath) {
+        const dir = dirname(filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    /**
+     * 读取 settings.json 配置
+     */
+    getSettings() {
+        try {
+            if (existsSync(this.settingsPath)) {
+                const content = readFileSync(this.settingsPath, 'utf-8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to read Claude Code settings:', error);
+        }
+        return {};
+    }
+    /**
+     * 保存 settings.json 配置
+     */
+    saveSettings(config) {
+        try {
+            this.ensureConfigDir(this.settingsPath);
+            writeFileSync(this.settingsPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to save Claude Code settings: ${error}`);
+        }
+    }
+    /**
+     * 读取 onboarding 配置 (~/.claude.json)
+     */
+    getOnboardingConfig() {
+        try {
+            if (existsSync(this.onboardingConfigPath)) {
+                const content = readFileSync(this.onboardingConfigPath, 'utf-8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn('Failed to read Claude Code onboarding config:', error);
+        }
+        return {};
+    }
+    /**
+     * 保存 onboarding 配置 (~/.claude.json)
+     */
+    saveOnboardingConfig(config) {
+        try {
+            this.ensureConfigDir(this.onboardingConfigPath);
+            writeFileSync(this.onboardingConfigPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        catch (error) {
+            throw new Error(`Failed to save Claude Code onboarding config: ${error}`);
+        }
+    }
+    /**
+     * 确保 .claude.json 中有 hasCompletedOnboarding: true
+     */
+    ensureOnboardingCompleted() {
+        try {
+            const config = this.getOnboardingConfig();
+            if (!config.hasCompletedOnboarding) {
+                this.saveOnboardingConfig({ ...config, hasCompletedOnboarding: true });
+            }
+        }
+        catch (error) {
+            console.warn('Failed to ensure onboarding completed:', error);
+        }
+    }
+    /**
+     * 从 API 获取可用的模型列表
+     */
+    async fetchAvailableModels(apiKey) {
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 30000);
+            const response = await fetch('https://code-api.x-aio.com/v1/models', {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json'
+                },
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (data && data.data && Array.isArray(data.data)) {
+                return data.data.map((model) => model.id);
+            }
+            return [];
+        }
+        catch (error) {
+            console.warn('Failed to fetch available models:', error);
+            return [];
+        }
+    }
+    /**
+     * 保存模型配置到 Claude Code
+     */
+    saveModelConfig(config) {
+        // 确保 onboarding 已完成
+        this.ensureOnboardingCompleted();
+        const currentSettings = this.getSettings();
+        // 移除旧的 ANTHROPIC_AUTH_TOKEN（如果存在）
+        const currentEnv = currentSettings.env || {};
+        const { ANTHROPIC_AUTH_TOKEN: _, ...cleanedEnv } = currentEnv;
+        const newSettings = {
+            ...currentSettings,
+            env: {
+                ...cleanedEnv,
+                ANTHROPIC_BASE_URL: config.baseUrl || DEFAULT_CONFIG.ANTHROPIC_BASE_URL,
+                ANTHROPIC_API_KEY: config.apiKey,
+                ANTHROPIC_DEFAULT_HAIKU_MODEL: config.haikuModel,
+                ANTHROPIC_DEFAULT_SONNET_MODEL: config.sonnetModel,
+                ANTHROPIC_DEFAULT_OPUS_MODEL: config.opusModel,
+                API_TIMEOUT_MS: '3000000',
+                CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: 1
+            }
+        };
+        this.saveSettings(newSettings);
+    }
+    /**
+     * 获取当前模型配置
+     */
+    getModelConfig() {
+        const settings = this.getSettings();
+        if (!settings.env) {
+            return null;
+        }
+        const apiKey = settings.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            return null;
+        }
+        return {
+            apiKey,
+            haikuModel: settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL || "",
+            sonnetModel: settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL || "",
+            opusModel: settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL || "",
+            baseUrl: settings.env.ANTHROPIC_BASE_URL || ""
+        };
+    }
+    /**
+     * 清除模型配置
+     */
+    clearModelConfig() {
+        const currentSettings = this.getSettings();
+        if (!currentSettings.env) {
+            return;
+        }
+        const { ANTHROPIC_BASE_URL: _1, ANTHROPIC_API_KEY: _2, ANTHROPIC_DEFAULT_HAIKU_MODEL: _3, ANTHROPIC_DEFAULT_SONNET_MODEL: _4, ANTHROPIC_DEFAULT_OPUS_MODEL: _5, API_TIMEOUT_MS: _6, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: _7, ...otherEnv } = currentSettings.env;
+        const newSettings = {
+            ...currentSettings,
+            env: otherEnv
+        };
+        if (newSettings.env && Object.keys(newSettings.env).length === 0) {
+            delete newSettings.env;
+        }
+        this.saveSettings(newSettings);
+    }
+}
+export const claudeCodeManager = ClaudeCodeManager.getInstance();

package/dist/lib/command.d.ts

@@ -0,0 +1,10 @@
+import { Command as Commander } from 'commander';
+export declare class Command {
+    private program;
+    constructor();
+    private getVersion;
+    private setupProgram;
+    private handleInitCommand;
+    execute(args: string[]): Promise<void>;
+    getProgram(): Commander;
+}

package/dist/lib/command.js

@@ -0,0 +1,174 @@
+import { Command as Commander } from 'commander';
+import { i18n } from './i18n.js';
+import { configManager } from './config.js';
+import { wizard } from './wizard.js';
+import { langCommand, authCommand, doctorCommand, configCommand } from '../commands/index.js';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+export class Command {
+    program;
+    constructor() {
+        // Load language from config
+        const lang = configManager.getLang();
+        i18n.loadFromConfig(lang);
+        this.program = new Commander();
+        this.setupProgram();
+    }
+    getVersion() {
+        try {
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            const packagePath = join(__dirname, '../../package.json');
+            const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            return packageJson.version;
+        }
+        catch {
+            return '1.0.0';
+        }
+    }
+    setupProgram() {
+        this.program
+            .name('chelper')
+            .description(i18n.t('cli.title'))
+            .version(this.getVersion(), '-v, --version', i18n.t('commands.version'))
+            .helpOption('-h, --help', i18n.t('commands.help'));
+        // Init command - interactive wizard
+        this.program
+            .command('init')
+            .description(i18n.t('commands.init'))
+            .action(async () => {
+            await this.handleInitCommand();
+        });
+        // Lang command - language management
+        const langCmd = this.program
+            .command('lang')
+            .description(i18n.t('commands.lang'));
+        langCmd
+            .command('show')
+            .description(i18n.t('lang.show_usage'))
+            .action(async () => {
+            await langCommand(['show']);
+        });
+        langCmd
+            .command('set <locale>')
+            .description(i18n.t('lang.set_usage'))
+            .action(async (locale) => {
+            await langCommand(['set', locale]);
+        });
+        // Auth command - API key management
+        const authCmd = this.program
+            .command('auth')
+            .description(i18n.t('commands.auth'));
+        authCmd
+            .argument('[token]', 'API token')
+            .action(async (token) => {
+            const args = [];
+            if (token)
+                args.push(token);
+            await authCommand(args);
+        });
+        authCmd
+            .command('revoke')
+            .description('Revoke saved API key')
+            .action(async () => {
+            await authCommand(['revoke']);
+        });
+        authCmd
+            .command('reload <tool>')
+            .description('Reload plan configuration to the specified tool (e.g., claude)')
+            .action(async (tool) => {
+            await authCommand(['reload', tool]);
+        });
+        // Doctor command - health check
+        this.program
+            .command('doctor')
+            .description(i18n.t('commands.doctor'))
+            .action(async () => {
+            await doctorCommand();
+        });
+        // Config command - tool configuration
+        const enterCmd = this.program
+            .command('enter [option]')
+            .description(i18n.t('commands.enter'));
+        // config 子命令
+        enterCmd
+            .action(async (option) => {
+            // 如果没有参数，显示主菜单
+            if (!option) {
+                await wizard.showMainMenu();
+                return;
+            }
+            // 根据参数执行对应操作
+            switch (option) {
+                case 'lang':
+                case 'language':
+                    await wizard.configLanguage();
+                    break;
+                case 'models':
+                    await wizard.configModels();
+                    break;
+                case 'apikey':
+                case 'api-key':
+                    await wizard.configApiKey();
+                    break;
+                default: {
+                    // 尝试作为工具名处理
+                    const args = [option];
+                    await configCommand(args);
+                    break;
+                }
+            }
+        });
+        this.program.action(async () => {
+            if (configManager.isFirstRun()) {
+                console.log(chalk.cyan(i18n.t('messages.first_run')));
+                await wizard.runFirstTimeSetup();
+            }
+            else {
+                await wizard.showMainMenu();
+            }
+        });
+        // Custom help
+        this.program.configureHelp({
+            sortSubcommands: true,
+            subcommandTerm: (cmd) => cmd.name() + ' ' + cmd.usage()
+        });
+        // Add examples to help
+        this.program.addHelpText('after', `
+${chalk.bold(i18n.t('cli.examples'))}:
+  ${chalk.gray('$ chelper                    # Interactive main menu')}
+  ${chalk.gray('$ chelper init               # Run first-time setup wizard')}
+  ${chalk.gray('$ chelper enter              # Interactive main menu')}
+  ${chalk.gray('$ chelper enter lang         # Interactive language configuration')}
+  ${chalk.gray('$ chelper enter models       # Interactive models configuration')}
+  ${chalk.gray('$ chelper enter apikey       # Interactive API key configuration')}
+  ${chalk.gray('$ chelper enter claude-code  # Interactive Configure Claude Code tool')}
+  ${chalk.gray('$ chelper lang show          # Show current language')}
+  ${chalk.gray('$ chelper lang set zh_CN')}
+  ${chalk.gray('$ chelper auth               # Interactive auth setup')}
+  ${chalk.gray('$ chelper auth <token>       # Set API key directly')}
+  ${chalk.gray('$ chelper auth revoke')}
+  ${chalk.gray('$ chelper auth reload claude # Reload config to Claude Code')}
+  ${chalk.gray('$ chelper doctor             # Health check')}
+`);
+    }
+    async handleInitCommand() {
+        await wizard.runFirstTimeSetup();
+    }
+    async execute(args) {
+        try {
+            await this.program.parseAsync(args, { from: 'user' });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(chalk.red(i18n.t('cli.error_general')), error.message);
+            }
+            process.exit(1);
+        }
+    }
+    getProgram() {
+        return this.program;
+    }
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,37 @@
+export interface ChelperConfig {
+    lang: string;
+    api_key?: string;
+    haikuModel?: string;
+    sonnetModel?: string;
+    opusModel?: string;
+}
+export declare class ConfigManager {
+    private static instance;
+    private configDir;
+    private configPath;
+    private config;
+    private constructor();
+    static getInstance(): ConfigManager;
+    private ensureConfigDir;
+    private loadConfig;
+    saveConfig(config?: ChelperConfig): void;
+    getConfig(): ChelperConfig;
+    updateConfig(updates: Partial<ChelperConfig>): void;
+    isFirstRun(): boolean;
+    getLang(): string;
+    setLang(lang: string): void;
+    getApiKey(): string | undefined;
+    setApiKey(apiKey: string): void;
+    revokeApiKey(): void;
+    getModels(): {
+        haikuModel?: string;
+        sonnetModel?: string;
+        opusModel?: string;
+    };
+    setModels(models: {
+        haikuModel?: string;
+        sonnetModel?: string;
+        opusModel?: string;
+    }): void;
+}
+export declare const configManager: ConfigManager;

package/dist/lib/config.js

@@ -0,0 +1,92 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import * as yaml from 'js-yaml';
+export class ConfigManager {
+    static instance;
+    configDir;
+    configPath;
+    config;
+    constructor() {
+        // chelper 配置文件路径（跨平台支持）
+        // - macOS/Linux: ~/.chelper/config.yaml
+        // - Windows: %USERPROFILE%\.chelper\config.yaml
+        //   (例如: C:\Users\username\.chelper\config.yaml)
+        this.configDir = join(homedir(), '.chelper');
+        this.configPath = join(this.configDir, 'config.yaml');
+        this.config = this.loadConfig();
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    ensureConfigDir() {
+        if (!existsSync(this.configDir)) {
+            mkdirSync(this.configDir, { recursive: true });
+        }
+    }
+    loadConfig() {
+        try {
+            if (existsSync(this.configPath)) {
+                const fileContent = readFileSync(this.configPath, 'utf-8');
+                const config = yaml.load(fileContent);
+                return config || { lang: 'en_US' };
+            }
+        }
+        catch (error) {
+            console.warn('Failed to load config, using defaults:', error);
+        }
+        return { lang: 'en_US' };
+    }
+    saveConfig(config) {
+        try {
+            this.ensureConfigDir();
+            const configToSave = config || this.config;
+            const yamlContent = yaml.dump(configToSave);
+            writeFileSync(this.configPath, yamlContent, 'utf-8');
+            this.config = configToSave;
+        }
+        catch (error) {
+            console.error('Failed to save config:', error);
+            throw error;
+        }
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+        this.saveConfig();
+    }
+    isFirstRun() {
+        return !existsSync(this.configPath);
+    }
+    getLang() {
+        return this.config.lang || 'en_US';
+    }
+    setLang(lang) {
+        this.updateConfig({ lang });
+    }
+    getApiKey() {
+        return this.config.api_key;
+    }
+    setApiKey(apiKey) {
+        this.updateConfig({ api_key: apiKey });
+    }
+    revokeApiKey() {
+        this.updateConfig({ api_key: undefined });
+    }
+    getModels() {
+        return {
+            haikuModel: this.config.haikuModel,
+            sonnetModel: this.config.sonnetModel,
+            opusModel: this.config.opusModel
+        };
+    }
+    setModels(models) {
+        this.updateConfig(models);
+    }
+}
+export const configManager = ConfigManager.getInstance();

package/dist/lib/i18n.d.ts

@@ -0,0 +1,20 @@
+declare class I18n {
+    private static instance;
+    private currentLocale;
+    private translations;
+    private fallbackLocale;
+    private localesDir;
+    private constructor();
+    static getInstance(): I18n;
+    private loadTranslations;
+    setLocale(locale: string): void;
+    getLocale(): string;
+    getAvailableLocales(): string[];
+    translate(key: string, params?: Record<string, string>): string;
+    t(key: string, params?: Record<string, string>): string;
+    private saveLocale;
+    private loadSavedLocale;
+    loadFromConfig(locale: string): void;
+}
+export declare const i18n: I18n;
+export { i18n as I18n };