ccman 0.0.1

package/src/shell/ShellManager.ts

@@ -0,0 +1,416 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { ShellEnvVars, ShellWriteResult, ShellType } from '../types';
+import { CONFIG, getConfigDir, getShellRCFile } from '../config/constants';
+
+export class ShellManager {
+  private readonly homeDir: string;
+  private readonly ccmanDir: string;
+  private readonly ccmanrcPath: string;
+  
+  constructor() {
+    this.homeDir = os.homedir();
+    this.ccmanDir = getConfigDir();
+    this.ccmanrcPath = getShellRCFile();
+  }
+
+  /**
+   * 写入环境变量到 CCMan 配置文件并更新 shell 引用
+   */
+  async writeToShell(envVars: ShellEnvVars, envName?: string): Promise<ShellWriteResult> {
+    try {
+      // 1. 写入环境变量到独立的 ccmanrc 文件
+      await this.writeCCMANRC(envVars, envName);
+      
+      // 2. 确保 shell 配置文件中有对 ccmanrc 的引用
+      const shellUpdateResult = await this.ensureShellReference();
+      
+      return {
+        success: true,
+        filePath: this.ccmanrcPath,
+        message: `Environment variables written to ${this.ccmanrcPath}${shellUpdateResult.updated ? ` and shell reference ${shellUpdateResult.action}` : ''}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        filePath: this.ccmanrcPath,
+        message: 'Failed to write environment variables',
+        error: String(error)
+      };
+    }
+  }
+
+  /**
+   * 写入 ccmanrc 文件
+   */
+  private async writeCCMANRC(envVars: ShellEnvVars, envName?: string): Promise<void> {
+    // 确保 .ccman 目录存在
+    if (!fs.existsSync(this.ccmanDir)) {
+      fs.mkdirSync(this.ccmanDir, { recursive: true });
+    }
+
+    const content = this.generateExportStatements(envVars, envName);
+    fs.writeFileSync(this.ccmanrcPath, content);
+  }
+
+  /**
+   * 确保 shell 配置文件中有对 ccmanrc 的引用
+   */
+  private async ensureShellReference(): Promise<{ updated: boolean; action: string; filePath?: string }> {
+    const shellType = this.detectShell();
+    const configFiles = this.getShellConfigFiles(shellType);
+    
+    // 检查是否已经有引用
+    for (const configFile of configFiles) {
+      if (fs.existsSync(configFile)) {
+        const content = fs.readFileSync(configFile, 'utf8');
+        if (this.hasShellReference(content)) {
+          return { updated: false, action: 'already exists' };
+        }
+      }
+    }
+
+    // 添加引用到主配置文件
+    const primaryConfigFile = configFiles[0];
+    try {
+      await this.addShellReference(primaryConfigFile);
+      return { 
+        updated: true, 
+        action: 'added', 
+        filePath: primaryConfigFile 
+      };
+    } catch (error) {
+      // 尝试其他配置文件
+      for (let i = 1; i < configFiles.length; i++) {
+        try {
+          await this.addShellReference(configFiles[i]);
+          return { 
+            updated: true, 
+            action: 'added (fallback)', 
+            filePath: configFiles[i] 
+          };
+        } catch (fallbackError) {
+          continue;
+        }
+      }
+      throw new Error('Failed to add shell reference to any configuration file');
+    }
+  }
+
+  /**
+   * 添加 shell 引用到配置文件
+   */
+  private async addShellReference(configFilePath: string): Promise<void> {
+    // 确保目录存在
+    const dir = path.dirname(configFilePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    let content = '';
+    if (fs.existsSync(configFilePath)) {
+      content = fs.readFileSync(configFilePath, 'utf8');
+    }
+
+    // 添加对 ccmanrc 的引用
+    const reference = this.generateShellReference();
+    content += reference;
+
+    fs.writeFileSync(configFilePath, content);
+  }
+
+  /**
+   * 生成 shell 引用代码
+   */
+  private generateShellReference(): string {
+    return `
+# ${CONFIG.APP_FULL_NAME} - Auto Generated Reference
+# This line sources ${CONFIG.APP_NAME} environment variables from ${this.ccmanrcPath}
+[ -f "${this.ccmanrcPath}" ] && source "${this.ccmanrcPath}"
+# End ${CONFIG.APP_NAME} Reference
+`;
+  }
+
+  /**
+   * 检查是否已经有 shell 引用
+   */
+  private hasShellReference(content: string): boolean {
+    return content.includes(`# ${CONFIG.APP_FULL_NAME} - Auto Generated Reference`) || 
+           content.includes(this.ccmanrcPath);
+  }
+
+  /**
+   * 从 shell 配置文件中清除 ccmanrc 引用和 ccmanrc 文件
+   */
+  async clearFromShell(): Promise<ShellWriteResult> {
+    let clearedAny = false;
+    let lastError: string | undefined;
+    
+    // 1. 删除 ccmanrc 文件
+    if (fs.existsSync(this.ccmanrcPath)) {
+      try {
+        fs.unlinkSync(this.ccmanrcPath);
+        clearedAny = true;
+      } catch (error) {
+        lastError = String(error);
+      }
+    }
+
+    // 2. 从 shell 配置文件中移除引用
+    const shellType = this.detectShell();
+    const configFiles = this.getShellConfigFiles(shellType);
+    
+    for (const configFile of configFiles) {
+      try {
+        if (fs.existsSync(configFile)) {
+          await this.removeShellReference(configFile);
+          clearedAny = true;
+        }
+      } catch (error) {
+        lastError = String(error);
+      }
+    }
+    
+    if (clearedAny) {
+      return {
+        success: true,
+        filePath: this.ccmanrcPath,
+        message: 'Environment variables and shell references cleared'
+      };
+    } else {
+      return {
+        success: false,
+        filePath: this.ccmanrcPath,
+        message: 'Failed to clear environment variables',
+        error: lastError
+      };
+    }
+  }
+
+  /**
+   * 从配置文件中移除 shell 引用
+   */
+  private async removeShellReference(filePath: string): Promise<void> {
+    if (!fs.existsSync(filePath)) {
+      return;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const cleanedContent = this.removeShellReferenceFromContent(content);
+    
+    fs.writeFileSync(filePath, cleanedContent);
+  }
+
+  /**
+   * 从内容中移除 shell 引用部分
+   */
+  private removeShellReferenceFromContent(content: string): string {
+    const startMarker = `# ${CONFIG.APP_FULL_NAME} - Auto Generated Reference`;
+    const endMarker = `# End ${CONFIG.APP_NAME} Reference`;
+    
+    const lines = content.split('\n');
+    const filteredLines: string[] = [];
+    let inCCMSection = false;
+    
+    for (const line of lines) {
+      if (line.includes(startMarker)) {
+        inCCMSection = true;
+        continue;
+      }
+      
+      if (line.includes(endMarker)) {
+        inCCMSection = false;
+        continue;
+      }
+      
+      if (!inCCMSection) {
+        filteredLines.push(line);
+      }
+    }
+    
+    return filteredLines.join('\n').replace(/\n{3,}/g, '\n\n');
+  }
+
+  /**
+   * 检测当前使用的 shell 类型
+   */
+  detectShell(): ShellType {
+    const shell = process.env.SHELL || '';
+    
+    if (shell.includes('zsh')) {
+      return 'zsh';
+    } else if (shell.includes('bash')) {
+      return 'bash';
+    } else if (shell.includes('fish')) {
+      return 'fish';
+    } else {
+      return 'unknown';
+    }
+  }
+
+  /**
+   * 获取 shell 配置文件路径列表
+   */
+  getShellConfigFiles(shellType: ShellType): string[] {
+    const configFiles: string[] = [];
+    
+    switch (shellType) {
+      case 'zsh':
+        configFiles.push(
+          path.join(this.homeDir, '.zshrc'),
+          path.join(this.homeDir, '.zprofile')
+        );
+        break;
+      case 'bash':
+        configFiles.push(
+          path.join(this.homeDir, '.bashrc'),
+          path.join(this.homeDir, '.bash_profile'),
+          path.join(this.homeDir, '.profile')
+        );
+        break;
+      case 'fish':
+        configFiles.push(
+          path.join(this.homeDir, '.config/fish/config.fish')
+        );
+        break;
+      default:
+        // 默认尝试常见的配置文件
+        configFiles.push(
+          path.join(this.homeDir, '.zshrc'),
+          path.join(this.homeDir, '.bashrc'),
+          path.join(this.homeDir, '.profile')
+        );
+    }
+    
+    return configFiles;
+  }
+
+  /**
+   * 生成环境变量导出语句
+   */
+  generateExportStatements(envVars: ShellEnvVars, envName?: string): string {
+    const now = new Date();
+    const timestamp = now.getFullYear() + '-' + 
+      String(now.getMonth() + 1).padStart(2, '0') + '-' + 
+      String(now.getDate()).padStart(2, '0') + ' ' +
+      String(now.getHours()).padStart(2, '0') + ':' + 
+      String(now.getMinutes()).padStart(2, '0') + ':' + 
+      String(now.getSeconds()).padStart(2, '0');
+    const nameComment = envName ? `# Environment: ${envName}` : '';
+    
+    return `
+# ${CONFIG.APP_FULL_NAME} Environment Variables - Auto Generated
+# Generated at: ${timestamp}${nameComment ? '\n' + nameComment : ''}
+export ${CONFIG.ENV_VARS.BASE_URL}="${envVars.ANTHROPIC_BASE_URL}"
+export ${CONFIG.ENV_VARS.AUTH_TOKEN}="${envVars.ANTHROPIC_AUTH_TOKEN}"
+# End ${CONFIG.APP_NAME} Environment Variables
+`;
+  }
+
+  /**
+   * 检查是否已经写入了环境变量
+   */
+  hasEnvVarsInShell(): boolean {
+    // 检查 ccmanrc 文件是否存在
+    if (fs.existsSync(this.ccmanrcPath)) {
+      return true;
+    }
+    
+    // 检查 shell 配置文件中是否有引用
+    const shellType = this.detectShell();
+    const configFiles = this.getShellConfigFiles(shellType);
+    
+    for (const configFile of configFiles) {
+      if (fs.existsSync(configFile)) {
+        const content = fs.readFileSync(configFile, 'utf8');
+        if (this.hasShellReference(content)) {
+          return true;
+        }
+      }
+    }
+    
+    return false;
+  }
+
+  /**
+   * 自动 source shell 配置文件
+   */
+  async autoSourceShell(): Promise<ShellWriteResult> {
+    const shellType = this.detectShell();
+    const configFiles = this.getShellConfigFiles(shellType);
+    
+    // 找到第一个存在的配置文件
+    const activeConfigFile = configFiles.find(file => fs.existsSync(file));
+    
+    if (!activeConfigFile) {
+      return {
+        success: false,
+        filePath: configFiles.join(', '),
+        message: 'No shell configuration file found to source',
+        error: 'Configuration file not found'
+      };
+    }
+
+    try {
+      // 使用子进程执行 source 命令
+      const { exec } = await import('child_process');
+      const { promisify } = await import('util');
+      const execAsync = promisify(exec);
+
+      // 根据不同 shell 类型使用不同的 source 命令
+      let sourceCommand: string;
+      switch (shellType) {
+        case 'zsh':
+          sourceCommand = `zsh -c "source ${activeConfigFile}"`;
+          break;
+        case 'bash':
+          sourceCommand = `bash -c "source ${activeConfigFile}"`;
+          break;
+        case 'fish':
+          sourceCommand = `fish -c "source ${activeConfigFile}"`;
+          break;
+        default:
+          sourceCommand = `bash -c "source ${activeConfigFile}"`;
+      }
+
+      await execAsync(sourceCommand);
+      
+      return {
+        success: true,
+        filePath: activeConfigFile,
+        message: `Successfully sourced ${activeConfigFile}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        filePath: activeConfigFile,
+        message: 'Failed to source shell configuration file',
+        error: String(error)
+      };
+    }
+  }
+
+  /**
+   * 获取当前 shell 信息
+   */
+  getShellInfo(): {
+    shellType: ShellType;
+    shellPath: string;
+    configFiles: string[];
+    activeConfigFile?: string;
+  } {
+    const shellType = this.detectShell();
+    const configFiles = this.getShellConfigFiles(shellType);
+    
+    // 找到第一个存在的配置文件作为活动配置文件
+    const activeConfigFile = configFiles.find(file => fs.existsSync(file));
+    
+    return {
+      shellType,
+      shellPath: process.env.SHELL || 'unknown',
+      configFiles,
+      activeConfigFile
+    };
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,60 @@
+/**
+ * Claude Code Manager 类型定义
+ */
+
+export interface ClaudeEnv {
+  /** 环境名称 */
+  name: string;
+  /** API 基础 URL */
+  baseUrl: string;
+  /** API 密钥 */
+  apiKey: string;
+  /** 创建时间 */
+  createdAt: string;
+  /** 最后使用时间 */
+  lastUsed?: string;
+}
+
+export interface Config {
+  /** 当前使用的环境名称 */
+  current: string | null;
+  /** 环境配置列表 */
+  environments: { [name: string]: ClaudeEnv };
+  /** 全局设置 */
+  settings: GlobalSettings;
+}
+
+export interface GlobalSettings {
+  /** 是否自动写入 shell 配置文件 */
+  autoWriteShell: boolean;
+  /** 首选的 shell 类型 */
+  preferredShell: 'bash' | 'zsh' | 'auto';
+  /** shell 配置文件路径（可自定义） */
+  shellConfigPath?: string;
+}
+
+export interface ShellEnvVars {
+  ANTHROPIC_BASE_URL: string;
+  ANTHROPIC_AUTH_TOKEN: string;
+}
+
+export interface AddEnvOptions {
+  name: string;
+  baseUrl: string;
+  apiKey: string;
+  autoWriteShell?: boolean;
+}
+
+export interface ShellWriteResult {
+  success: boolean;
+  filePath: string;
+  message: string;
+  error?: string;
+}
+
+export interface EnvironmentListItem extends ClaudeEnv {
+  /** 是否为当前使用的环境 */
+  isCurrent: boolean;
+}
+
+export type ShellType = 'bash' | 'zsh' | 'fish' | 'unknown';

package/src/utils/version.ts

@@ -0,0 +1,189 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * 版本信息接口
+ */
+export interface VersionInfo {
+  version: string;
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease?: string;
+}
+
+/**
+ * 版本工具类
+ */
+export class VersionManager {
+  private static instance: VersionManager;
+  private cachedVersion?: VersionInfo;
+
+  private constructor() {}
+
+  /**
+   * 获取单例实例
+   */
+  static getInstance(): VersionManager {
+    if (!VersionManager.instance) {
+      VersionManager.instance = new VersionManager();
+    }
+    return VersionManager.instance;
+  }
+
+  /**
+   * 获取当前版本信息
+   */
+  getCurrentVersion(): VersionInfo {
+    if (this.cachedVersion) {
+      return this.cachedVersion;
+    }
+
+    try {
+      const packageJsonPath = this.getPackageJsonPath();
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+      const version = packageJson.version;
+      
+      this.cachedVersion = this.parseVersion(version);
+      return this.cachedVersion;
+    } catch (error) {
+      console.warn('⚠️  无法读取版本信息，使用默认版本');
+      this.cachedVersion = this.parseVersion('0.0.1');
+      return this.cachedVersion;
+    }
+  }
+
+  /**
+   * 获取版本字符串
+   */
+  getVersionString(): string {
+    return this.getCurrentVersion().version;
+  }
+
+  /**
+   * 解析版本字符串
+   */
+  private parseVersion(versionString: string): VersionInfo {
+    const match = versionString.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+    
+    if (!match) {
+      throw new Error(`无效的版本格式: ${versionString}`);
+    }
+
+    const [, major, minor, patch, prerelease] = match;
+    
+    return {
+      version: versionString,
+      major: parseInt(major, 10),
+      minor: parseInt(minor, 10),
+      patch: parseInt(patch, 10),
+      prerelease
+    };
+  }
+
+  /**
+   * 获取 package.json 路径
+   */
+  private getPackageJsonPath(): string {
+    // 在构建后的环境中，package.json 在 ../package.json
+    // 在开发环境中，可能在不同的位置
+    const paths = [
+      join(__dirname, '../package.json'),      // 构建后
+      join(__dirname, '../../package.json'),   // 开发环境
+      join(process.cwd(), 'package.json')      // 当前工作目录
+    ];
+
+    for (const path of paths) {
+      try {
+        readFileSync(path, 'utf8');
+        return path;
+      } catch {
+        continue;
+      }
+    }
+
+    throw new Error('找不到 package.json 文件');
+  }
+
+  /**
+   * 预测下一个版本
+   */
+  getNextVersion(type: 'patch' | 'minor' | 'major'): string {
+    const current = this.getCurrentVersion();
+    
+    switch (type) {
+      case 'patch':
+        return `${current.major}.${current.minor}.${current.patch + 1}`;
+      case 'minor':
+        return `${current.major}.${current.minor + 1}.0`;
+      case 'major':
+        return `${current.major + 1}.0.0`;
+      default:
+        throw new Error(`不支持的版本类型: ${type}`);
+    }
+  }
+
+  /**
+   * 获取版本变更建议（基于 git 历史分析）
+   */
+  async getVersionSuggestion(): Promise<'patch' | 'minor' | 'major'> {
+    try {
+      // 这里可以添加 git 历史分析逻辑
+      // 比如分析提交信息中的关键词来推荐版本类型
+      const { exec } = await import('child_process');
+      const { promisify } = await import('util');
+      const execAsync = promisify(exec);
+
+      // 获取最近的提交信息
+      const { stdout } = await execAsync('git log --oneline -10');
+      const commits = stdout.toLowerCase();
+
+      // 简单的启发式规则
+      if (commits.includes('breaking') || commits.includes('major')) {
+        return 'major';
+      } else if (commits.includes('feat') || commits.includes('feature') || commits.includes('add')) {
+        return 'minor';
+      } else {
+        return 'patch';
+      }
+    } catch {
+      // 默认推荐 patch
+      return 'patch';
+    }
+  }
+
+  /**
+   * 清除缓存（测试用）
+   */
+  clearCache(): void {
+    this.cachedVersion = undefined;
+  }
+}
+
+/**
+ * 便捷函数：获取当前版本字符串
+ */
+export function getCurrentVersion(): string {
+  return VersionManager.getInstance().getVersionString();
+}
+
+/**
+ * 便捷函数：获取版本信息
+ */
+export function getVersionInfo(): VersionInfo {
+  return VersionManager.getInstance().getCurrentVersion();
+}
+
+/**
+ * 便捷函数：获取下一个版本
+ */
+export function getNextVersion(type: 'patch' | 'minor' | 'major'): string {
+  return VersionManager.getInstance().getNextVersion(type);
+}
+
+/**
+ * 便捷函数：获取版本建议
+ */
+export async function getVersionSuggestion(): Promise<'patch' | 'minor' | 'major'> {
+  return VersionManager.getInstance().getVersionSuggestion();
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
+}