Function bodies 33 total

export function readClaudeSettings(): Record<string, unknown> {
  if (!existsSync(SETTINGS_PATH)) return {};
  return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
}

export function applyProfile(settingsConfig: Record<string, unknown>): void {
  const current = readClaudeSettings();

  // 保留用户级字段，用 profile 的配置覆盖
  const preserved: Record<string, unknown> = {};
  const USER_FIELDS = ["language", "permissions"];
  for (const key of USER_FIELDS) {
    if (key in current) {
      preserved[key] = current[key];
    }
  }

  const merged = { ...preserved, ...settingsConfig };
  writeFileSync(SETTINGS_PATH, JSON.stringify(merged, null, 2));
}

export function getSettingsPath(): string {
  return SETTINGS_PATH;
}

function ask(question: string): Promise<string> {
  const rl = createInterface({ input: process.stdin, output: process.stdout });
  return new Promise((resolve) => {
    rl.question(question, (answer) => {
      rl.close();
      resolve(answer.trim());
    });
  });
}

function ensureStore() {
  const store = getStore();
  if (!store) {
    console.log(chalk.yellow("尚未初始化，请先运行: ccm init"));
    process.exit(1);
  }
  return store;
}

function formatEnv(env: Record<string, string>): string {
  const lines: string[] = [];
  const order = [
    "ANTHROPIC_BASE_URL",
    "ANTHROPIC_MODEL",
    "ANTHROPIC_DEFAULT_OPUS_MODEL",
    "ANTHROPIC_DEFAULT_SONNET_MODEL",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
  ];
  for (const key of order) {
    if (key in env) {
      lines.push(`  ${chalk.gray(key)}: ${env[key]}`);
    }
  }
  // Show remaining keys (skip token for security)
  for (const [key, val] of Object.entries(env)) {
    if (!order.includes(key) && key !== "ANTHROPIC_AUTH_TOKEN") {
      lines.push(`  ${chalk.gray(key)}: ${val}`);
    }
  }
  if ("ANTHROPIC_AUTH_TOKEN" in env) {
    const token = env["ANTHROPIC_AUTH_TOKEN"];
    const masked = token.slice(0, 8) + "..." + token.slice(-4);
    lines.push(`  ${chalk.gray("ANTHROPIC_AUTH_TOKEN")}: ${masked}`);
  }
  return lines.join("\n");
}

function levenshtein(a: string, b: string): number {
  const la = a.length, lb = b.length;
  const dp: number[][] = Array.from({ length: la + 1 }, (_, i) =>
    Array.from({ length: lb + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0))
  );
  for (let i = 1; i <= la; i++) {
    for (let j = 1; j <= lb; j++) {
      dp[i][j] = a[i - 1] === b[j - 1]
        ? dp[i - 1][j - 1]
        : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
    }
  }
  return dp[la][lb];
}

function findSuggestions(input: string, names: string[]): string[] {
  const lower = input.toLowerCase();

  // 1. exact case-insensitive match
  const exact = names.find((n) => n.toLowerCase() === lower);
  if (exact) return [exact];

  // 2. substring match (input is part of name, or name is part of input)
  const substring = names.filter(
    (n) => n.toLowerCase().includes(lower) || lower.includes(n.toLowerCase())
  );
  if (substring.length > 0) return substring;

  // 3. Levenshtein distance <= 3
  const fuzzy = names
    .map((n) => ({ name: n, dist: levenshtein(lower, n.toLowerCase()) }))
    .filter((x) => x.dist <= 3)
    .sort((a, b) => a.dist - b.dist)
    .map((x) => x.name);

  return fuzzy;
}

function resolveAlias(input: string): string {
  const rc = readRc();
  return rc?.aliases?.[input] ?? input;
}

function resolveProfile(store: ReturnType<typeof ensureStore>, input: string) {
  // 1. check alias first
  const resolved = resolveAlias(input);
  const profile = store.get(resolved);
  if (profile) return profile;

  // If alias resolved to something different but not found, mention it
  if (resolved !== input) {
    console.log(chalk.red(`别名 "${input}" 指向 "${resolved}"，但该配置不存在`));
    return null;
  }

  const allNames = store.list().map((p) => p.name);
  const suggestions = findSuggestions(input, allNames);

  console.log(chalk.red(`配置 "${input}" 不存在`));
  if (suggestions.length === 1) {
    console.log(chalk.yellow(`你是不是想说: ${chalk.bold(suggestions[0])}?`));
  } else if (suggestions.length > 1) {
    console.log(chalk.yellow(`你是不是想说:`));
    for (const s of suggestions) {
      console.log(`  - ${chalk.bold(s)}`);
    }
  } else {
    console.log(chalk.gray("使用 ccm list 查看所有可用配置"));
  }
  return null;
}

export function ccSwitchExists(): boolean {
  return existsSync(DB_PATH);
}

export class CcSwitchStore implements DataStore {
  private db: Database.Database;

  constructor() {
    if (!existsSync(DB_PATH)) {
      throw new Error(`cc-switch 数据库不存在: ${DB_PATH}`);
    }
    this.db = new Database(DB_PATH);
  }

  list(): Profile[] {
    const rows = this.db
      .prepare(
        `SELECT id, name, settings_config FROM providers WHERE app_type = 'claude' ORDER BY sort_index`
      )
      .all() as Array<{ id: string; name: string; settings_config: string }>;

    return rows.map((row) => ({
      id: row.id,
      name: row.name,
      settingsConfig: JSON.parse(row.settings_config),
    }));
  }

  get(name: string): Profile | undefined {
    const row = this.db
      .prepare(
        `SELECT id, name, settings_config FROM providers WHERE app_type = 'claude' AND name = ?`
      )
      .get(name) as
      | { id: string; name: string; settings_config: string }
      | undefined;

    if (!row) return undefined;
    return {
      id: row.id,
      name: row

  constructor() {
    if (!existsSync(DB_PATH)) {
      throw new Error(`cc-switch 数据库不存在: ${DB_PATH}`);
    }
    this.db = new Database(DB_PATH);
  }

  list(): Profile[] {
    const rows = this.db
      .prepare(
        `SELECT id, name, settings_config FROM providers WHERE app_type = 'claude' ORDER BY sort_index`
      )
      .all() as Array<{ id: string; name: string; settings_config: string }>;

    return rows.map((row) => ({
      id: row.id,
      name: row.name,
      settingsConfig: JSON.parse(row.settings_config),
    }));
  }

  get(name: string): Profile | undefined {
    const row = this.db
      .prepare(
        `SELECT id, name, settings_config FROM providers WHERE app_type = 'claude' AND name = ?`
      )
      .get(name) as
      | { id: string; name: string; settings_config: string }
      | undefined;

    if (!row) return undefined;
    return {
      id: row.id,
      name: row.name,
      settingsConfig: JSON.parse(row.settings_config),
    };
  }

  save(name: string, settingsConfig: Record<string, unknown>): void {
    const existing = this.get(name);
    if (existing) {
      this.db
        .prepare(
          `UPDATE providers SET settings_config = ? WHERE app_type = 'claude' AND name = ?`
        )
        .run(JSON.stringify(settingsConfig), name);
    } else {
      const id = crypto.randomUUID();
      this.db
        .prepare(
          `INSERT INTO providers (id, app_type, name, settings_config, meta, created_at) VALUES (?, 'claude', ?, ?, '{}', ?)`
        )
        .run(id, name, JSON.stringify(settingsConfig), Date.now());
    }
  }

  remove(name: string): boolean {
    const result = this.db
      .prepare(
        `DELETE FROM providers WHERE app_type = 'claude' AND name = ?`
      )
      .run(name);
    return result.changes > 0;
  }

  getCurrent(): string | undefined {
    if (!existsSync(SETTINGS_PATH)) return undefined;
    try {
      const settings = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
      const currentId = settings.currentProviderClaude;
      if (!currentId) return undefined;
      const row = this.db
        .prepare(
          `SELECT name FROM providers WHERE app_type = 'claude' AND id = ?`
        )
        .get(currentId) as { name: string } | undefined;
      return row?.name;
    } catch {
      return undefined;
    }
  }

  setCurrent(name: string): void {
    const profile = this.get(name);
    if (!profile) throw new Error(`配置 "${name}" 不存在`);

    if (existsSync(SETTINGS_PATH)) {
      const settings = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
      settings.currentProviderClaude = profile.id;
      writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
    }
  }

  close(): void {
    this.db.close();
  }

function ensureDir(): void {
  if (!existsSync(CCM_DIR)) {
    mkdirSync(CCM_DIR, { recursive: true });
  }
}

function readConfig(): StandaloneConfig {
  if (!existsSync(CONFIG_PATH)) {
    return { profiles: {} };
  }
  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
}

function writeConfig(config: StandaloneConfig): void {
  ensureDir();
  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
}

export class StandaloneStore implements DataStore {
  list(): Profile[] {
    const config = readConfig();
    return Object.entries(config.profiles).map(([name, settingsConfig]) => ({
      id: name,
      name,
      settingsConfig,
    }));
  }

  get(name: string): Profile | undefined {
    const config = readConfig();
    const settingsConfig = config.profiles[name];
    if (!settingsConfig) return undefined;
    return { id: name, name, settingsConfig };
  }

  save(name: string, settingsConfig: Record<string, unknown>): void {
    const config = readConfig();
    config.profiles[name] = settingsConfig;
    writeConfig(config);
  }

  remove(name: string): boolean {
    const config = readConfig();
    if (!(name in config.profiles)) return false;
    delete config.profiles[name];
    if (config.current === name) {
      config.current = undefined;
    }
    writeConfig(config);
    return true;
  }

  getCurrent(): string | undefined {
    return readConfig().current;
  }

  set

  list(): Profile[] {
    const config = readConfig();
    return Object.entries(config.profiles).map(([name, settingsConfig]) => ({
      id: name,
      name,
      settingsConfig,
    }));
  }

  get(name: string): Profile | undefined {
    const config = readConfig();
    const settingsConfig = config.profiles[name];
    if (!settingsConfig) return undefined;
    return { id: name, name, settingsConfig };
  }

  save(name: string, settingsConfig: Record<string, unknown>): void {
    const config = readConfig();
    config.profiles[name] = settingsConfig;
    writeConfig(config);
  }

  remove(name: string): boolean {
    const config = readConfig();
    if (!(name in config.profiles)) return false;
    delete config.profiles[name];
    if (config.current === name) {
      config.current = undefined;
    }
    writeConfig(config);
    return true;
  }

  getCurrent(): string | undefined {
    return readConfig().current;
  }

  setCurrent(name: string): void {
    const config = readConfig();
    if (!(name in config.profiles)) {
      throw new Error(`配置 "${name}" 不存在`);
    }
    config.current = name;
    writeConfig(config);
  }

export function readRc(): RcConfig | undefined {
  if (!existsSync(RC_PATH)) return undefined;
  try {
    return JSON.parse(readFileSync(RC_PATH, "utf-8"));
  } catch {
    return undefined;
  }
}

export function writeRc(rc: RcConfig): void {
  if (!existsSync(CCM_DIR)) {
    mkdirSync(CCM_DIR, { recursive: true });
  }
  writeFileSync(RC_PATH, JSON.stringify(rc, null, 2));
}

export function getStore(): DataStore | null {
  const rc = readRc();
  if (!rc) return null;

  if (rc.mode === "cc-switch") {
    return new CcSwitchStore();
  } else {
    return new StandaloneStore();
  }
}