claude-ai-switcher 1.1.4

package/src/display.ts

@@ -0,0 +1,151 @@
+/**
+ * Display utilities for formatted output
+ */
+
+import chalk from "chalk";
+
+/**
+ * Format a table row with proper padding
+ */
+export function formatTableRow(
+  columns: string[],
+  widths: number[]
+): string {
+  return columns
+    .map((col, i) => col.padEnd(widths[i]))
+    .join("  ");
+}
+
+/**
+ * Display model list with descriptions and context sizes
+ */
+export function displayModels(
+  providerName: string,
+  models: Array<{
+    id: string;
+    name: string;
+    contextWindow: number;
+    capabilities: string[];
+    description: string;
+  }>,
+  currentModel?: string
+): void {
+  console.log(chalk.green(`\n✓ Provider: ${providerName}`));
+  console.log(chalk.dim("─".repeat(80)) + "\n");
+
+  // Calculate column widths
+  const modelWidth = Math.max(20, ...models.map(m => m.id.length)) + 2;
+  const contextWidth = 15;
+
+  // Header
+  console.log(
+    chalk.cyan.bold(
+      formatTableRow(["Model", "Context", "Capabilities"], [modelWidth, contextWidth, 40])
+    )
+  );
+  console.log(chalk.dim("─".repeat(80)));
+
+  // Models
+  for (const model of models) {
+    const isCurrent = model.id === currentModel;
+    const modelDisplay = isCurrent
+      ? chalk.green.bold(`● ${model.id}`)
+      : chalk.white(`  ${model.id}`);
+
+    const contextDisplay = chalk.yellow(formatContext(model.contextWindow));
+    const capabilitiesDisplay = chalk.gray(model.capabilities.join(", "));
+
+    console.log(
+      formatTableRow(
+        [modelDisplay, contextDisplay, capabilitiesDisplay],
+        [modelWidth, contextWidth, 40]
+      )
+    );
+
+    // Description on next line
+    console.log(chalk.dim(`  ${model.description}`));
+    console.log();
+  }
+
+  console.log(chalk.dim("─".repeat(80)));
+}
+
+/**
+ * Display current provider status
+ */
+export function displayCurrentStatus(
+  provider: string,
+  model?: string,
+  endpoint?: string
+): void {
+  console.log(chalk.green("\n✓ Current Configuration:\n"));
+  console.log(`  ${chalk.cyan.bold("Provider:")} ${chalk.white(provider)}`);
+  if (model) {
+    console.log(`  ${chalk.cyan.bold("Model:")} ${chalk.white(model)}`);
+  }
+  if (endpoint) {
+    console.log(`  ${chalk.cyan.bold("Endpoint:")} ${chalk.dim(endpoint)}`);
+  }
+  console.log();
+}
+
+/**
+ * Display success message
+ */
+export function displaySuccess(message: string): void {
+  console.log(chalk.green(`\n✓ ${message}\n`));
+}
+
+/**
+ * Display error message
+ */
+export function displayError(message: string): void {
+  console.log(chalk.red(`\n✗ Error: ${message}\n`));
+}
+
+/**
+ * Display warning message
+ */
+export function displayWarning(message: string): void {
+  console.log(chalk.yellow(`\n⚠ Warning: ${message}\n`));
+}
+
+/**
+ * Display info message
+ */
+export function displayInfo(message: string): void {
+  console.log(chalk.blue(`\nℹ ${message}\n`));
+}
+
+/**
+ * Format context window for display
+ */
+export function formatContext(tokens: number): string {
+  if (tokens >= 1000000) {
+    return `${(tokens / 1000000).toFixed(0)}M tokens`;
+  } else if (tokens >= 1000) {
+    return `${(tokens / 1000).toFixed(0)}K tokens`;
+  }
+  return `${tokens} tokens`;
+}
+
+/**
+ * Display provider list
+ */
+export function displayProviders(providers: Array<{
+  id: string;
+  name: string;
+  endpoint?: string;
+  modelCount: number;
+}>): void {
+  console.log(chalk.green("\n✓ Available Providers:\n"));
+
+  for (const provider of providers) {
+    console.log(chalk.cyan.bold(`  ${provider.name} (${provider.id})`));
+    console.log(chalk.dim(`    Models: ${provider.modelCount}`));
+    if (provider.endpoint) {
+      console.log(chalk.dim(`    Endpoint: ${provider.endpoint}`));
+    }
+    console.log();
+  }
+}

package/src/hooks/index.ts

@@ -0,0 +1,208 @@
+/**
+ * Hook Manager
+ *
+ * Installs and manages Claude Code hooks for:
+ * - Token tracking
+ * - Visual enhancements (context bar, model display)
+ * - Custom system prompts
+ *
+ * Hooks are installed to ~/.claude/ directory
+ */
+
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+import { execFileSync } from "child_process";
+
+const CLAUDE_DIR = path.join(os.homedir(), ".claude");
+const TOKEN_TRACKER_SRC = path.join(__dirname, "..", "hooks", "token-tracker.js");
+const VISUAL_ENHANCEMENTS_SRC = path.join(__dirname, "..", "hooks", "visual-enhancements.js");
+const TOKEN_TRACKER_DEST = path.join(CLAUDE_DIR, "token-tracker.js");
+const VISUAL_ENHANCEMENTS_DEST = path.join(CLAUDE_DIR, "visual-enhancements.js");
+const HOOKS_CONFIG = path.join(CLAUDE_DIR, "hooks-config.json");
+
+export interface HooksConfig {
+  tokenTracking: boolean;
+  visualEnhancements: boolean;
+  customPrompts: boolean;
+  lastInstalled?: string;
+}
+
+/**
+ * Check if hooks are installed
+ */
+export async function areHooksInstalled(): Promise<{
+  tokenTracking: boolean;
+  visualEnhancements: boolean;
+}> {
+  return {
+    tokenTracking: await fs.pathExists(TOKEN_TRACKER_DEST),
+    visualEnhancements: await fs.pathExists(VISUAL_ENHANCEMENTS_DEST)
+  };
+}
+
+/**
+ * Install token tracker hook
+ */
+export async function installTokenTracker(): Promise<void> {
+  if (!await fs.pathExists(TOKEN_TRACKER_SRC)) {
+    throw new Error("Token tracker source not found. Please rebuild the project.");
+  }
+
+  await fs.ensureDir(CLAUDE_DIR);
+  await fs.copy(TOKEN_TRACKER_SRC, TOKEN_TRACKER_DEST, { overwrite: true });
+
+  const config = await readHooksConfig();
+  config.tokenTracking = true;
+  config.lastInstalled = new Date().toISOString();
+  await writeHooksConfig(config);
+}
+
+/**
+ * Install visual enhancements hook
+ */
+export async function installVisualEnhancements(): Promise<void> {
+  if (!await fs.pathExists(VISUAL_ENHANCEMENTS_SRC)) {
+    throw new Error("Visual enhancements source not found. Please rebuild the project.");
+  }
+
+  await fs.ensureDir(CLAUDE_DIR);
+  await fs.copy(VISUAL_ENHANCEMENTS_SRC, VISUAL_ENHANCEMENTS_DEST, { overwrite: true });
+
+  const config = await readHooksConfig();
+  config.visualEnhancements = true;
+  config.lastInstalled = new Date().toISOString();
+  await writeHooksConfig(config);
+}
+
+/**
+ * Install all hooks
+ */
+export async function installAllHooks(): Promise<void> {
+  await installTokenTracker();
+  await installVisualEnhancements();
+}
+
+/**
+ * Remove token tracker hook
+ */
+export async function removeTokenTracker(): Promise<void> {
+  if (await fs.pathExists(TOKEN_TRACKER_DEST)) {
+    await fs.remove(TOKEN_TRACKER_DEST);
+  }
+
+  const config = await readHooksConfig();
+  config.tokenTracking = false;
+  await writeHooksConfig(config);
+}
+
+/**
+ * Remove visual enhancements hook
+ */
+export async function removeVisualEnhancements(): Promise<void> {
+  if (await fs.pathExists(VISUAL_ENHANCEMENTS_DEST)) {
+    await fs.remove(VISUAL_ENHANCEMENTS_DEST);
+  }
+
+  const config = await readHooksConfig();
+  config.visualEnhancements = false;
+  await writeHooksConfig(config);
+}
+
+/**
+ * Remove all hooks
+ */
+export async function removeAllHooks(): Promise<void> {
+  await removeTokenTracker();
+  await removeVisualEnhancements();
+}
+
+/**
+ * Read hooks configuration
+ */
+async function readHooksConfig(): Promise<HooksConfig> {
+  if (!await fs.pathExists(HOOKS_CONFIG)) {
+    return {
+      tokenTracking: false,
+      visualEnhancements: false,
+      customPrompts: false
+    };
+  }
+
+  try {
+    const content = await fs.readFile(HOOKS_CONFIG, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      tokenTracking: false,
+      visualEnhancements: false,
+      customPrompts: false
+    };
+  }
+}
+
+/**
+ * Write hooks configuration
+ */
+async function writeHooksConfig(config: HooksConfig): Promise<void> {
+  await fs.writeFile(HOOKS_CONFIG, JSON.stringify(config, null, 2), "utf-8");
+}
+
+/**
+ * Run a hook script in a subprocess for isolation
+ */
+function runHookScript(scriptPath: string, args: string[] = []): void {
+  execFileSync("node", [scriptPath, ...args], {
+    stdio: "inherit",
+    timeout: 10000
+  });
+}
+
+/**
+ * Run token tracker display
+ */
+export async function showTokenStatus(): Promise<void> {
+  if (!await fs.pathExists(TOKEN_TRACKER_DEST)) {
+    console.log("Token tracker not installed. Run: claude-switch hooks install");
+    return;
+  }
+
+  try {
+    runHookScript(TOKEN_TRACKER_DEST);
+  } catch (error) {
+    console.error("Failed to run token tracker:", error instanceof Error ? error.message : error);
+  }
+}
+
+/**
+ * Run visual enhancements display
+ */
+export async function showVisualStatus(): Promise<void> {
+  if (!await fs.pathExists(VISUAL_ENHANCEMENTS_DEST)) {
+    console.log("Visual enhancements not installed. Run: claude-switch hooks install");
+    return;
+  }
+
+  try {
+    runHookScript(VISUAL_ENHANCEMENTS_DEST);
+  } catch (error) {
+    console.error("Failed to run visual enhancements:", error instanceof Error ? error.message : error);
+  }
+}
+
+/**
+ * Reset token usage
+ */
+export async function resetTokenUsage(): Promise<void> {
+  if (!await fs.pathExists(TOKEN_TRACKER_DEST)) {
+    console.log("Token tracker not installed. Run: claude-switch hooks install");
+    return;
+  }
+
+  try {
+    runHookScript(TOKEN_TRACKER_DEST, ["--reset"]);
+    console.log("Token usage reset complete.");
+  } catch (error) {
+    console.error("Failed to reset token usage:", error instanceof Error ? error.message : error);
+  }
+}

package/src/hooks/token-tracker.js

@@ -0,0 +1,280 @@
+/**
+ * Claude Code Token Tracker
+ * 
+ * Tracks token usage across Claude Code sessions and displays
+ * context usage percentage with visual bar.
+ * 
+ * Installed to: ~/.claude/token-tracker.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const TRACKER_FILE = path.join(os.homedir(), '.claude', 'token-usage.json');
+const SETTINGS_FILE = path.join(os.homedir(), '.claude', 'settings.json');
+
+// Model context windows (matches src/models.ts)
+const MODEL_CONTEXT_WINDOWS = {
+  // Alibaba Models
+  'qwen3.7-plus': 1000000,
+  'qwen3.6-plus': 1000000,
+  'qwen3-max-2026-01-23': 262144,
+  'qwen3-coder-next': 262144,
+  'qwen3-coder-plus': 1000000,
+  'glm-5': 200000,
+  'glm-4.7': 256000,
+  'glm-4.7-flash': 256000,
+  'kimi-k2.5': 200000,
+  'MiniMax-M2.5': 200000,
+
+  // GLM Models
+  'glm-5.1': 200000,
+  'glm-5.2[1m]': 1000000,
+  'glm-5v-turbo': 200000,
+  'glm-5-turbo': 200000,
+
+  // OpenRouter Models
+  'qwen/qwen3.6-plus:free': 131072,
+  'openrouter/free': 131072,
+
+  // Ollama Models
+  'deepseek-r1:latest': 128000,
+  'qwen2.5-coder:latest': 128000,
+  'llama3.1:latest': 128000,
+  'codellama:latest': 100000,
+
+  // Gemini Models
+  'gemini-2.5-pro': 1000000,
+  'gemini-2.5-flash': 1000000,
+  'gemini-2.5-flash-lite': 1000000,
+
+  // Anthropic Models
+  'claude-opus-4-6-20250205': 200000,
+  'claude-opus-4-5-20251101': 200000,
+  'claude-sonnet-4-6-20250219': 200000,
+  'claude-sonnet-4-5-20250814': 200000,
+  'claude-haiku-4-5-20251015': 200000,
+};
+
+/**
+ * Get current model from Claude settings
+ */
+function getCurrentModel() {
+  try {
+    if (!fs.existsSync(SETTINGS_FILE)) {
+      return 'claude-opus-4-6-20250205'; // Default
+    }
+    
+    const settings = JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf-8'));
+    
+    // Check ANTHROPIC_MODEL env var
+    if (settings.env?.ANTHROPIC_MODEL) {
+      return settings.env.ANTHROPIC_MODEL;
+    }
+    
+    // Check tier map aliases (use opus as primary)
+    if (settings.env?.ANTHROPIC_DEFAULT_OPUS_MODEL) {
+      return settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+    }
+    
+    return 'claude-opus-4-6-20250205';
+  } catch (error) {
+    return 'claude-opus-4-6-20250205';
+  }
+}
+
+/**
+ * Get context window for current model
+ */
+function getContextWindow(modelId) {
+  return MODEL_CONTEXT_WINDOWS[modelId] || 200000; // Default to 200K
+}
+
+/**
+ * Load token usage data
+ */
+function loadTokenUsage() {
+  try {
+    if (!fs.existsSync(TRACKER_FILE)) {
+      return {
+        totalInputTokens: 0,
+        totalOutputTokens: 0,
+        sessionStart: new Date().toISOString(),
+        lastUpdated: new Date().toISOString()
+      };
+    }
+    
+    const data = JSON.parse(fs.readFileSync(TRACKER_FILE, 'utf-8'));
+    if (
+      typeof data.totalInputTokens !== 'number' ||
+      typeof data.totalOutputTokens !== 'number'
+    ) {
+      throw new Error('Invalid token usage data');
+    }
+    return data;
+  } catch (error) {
+    return {
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      sessionStart: new Date().toISOString(),
+      lastUpdated: new Date().toISOString()
+    };
+  }
+}
+
+/**
+ * Save token usage data
+ */
+function saveTokenUsage(usage) {
+  try {
+    fs.writeFileSync(TRACKER_FILE, JSON.stringify(usage, null, 2), 'utf-8');
+  } catch (error) {
+    // Silently fail - don't break Claude Code
+  }
+}
+
+/**
+ * Reset token usage for new session
+ */
+function resetTokenUsage() {
+  const usage = {
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    sessionStart: new Date().toISOString(),
+    lastUpdated: new Date().toISOString()
+  };
+  saveTokenUsage(usage);
+  return usage;
+}
+
+/**
+ * Add tokens to tracker
+ */
+function addTokens(inputTokens, outputTokens) {
+  const usage = loadTokenUsage();
+  usage.totalInputTokens += inputTokens || 0;
+  usage.totalOutputTokens += outputTokens || 0;
+  usage.lastUpdated = new Date().toISOString();
+  saveTokenUsage(usage);
+  return usage;
+}
+
+/**
+ * Format number with commas
+ */
+function formatNumber(num) {
+  return num.toLocaleString();
+}
+
+/**
+ * Create visual context bar
+ */
+function createContextBar(percentage) {
+  const barWidth = 20;
+  const filled = Math.round((percentage / 100) * barWidth);
+  const empty = barWidth - filled;
+  
+  const filledChar = '█';
+  const emptyChar = '░';
+  
+  return filledChar.repeat(filled) + emptyChar.repeat(empty);
+}
+
+/**
+ * Get color based on percentage
+ */
+function getPercentageColor(percentage) {
+  if (percentage < 50) return '\x1b[32m'; // Green
+  if (percentage < 75) return '\x1b[33m'; // Yellow
+  if (percentage < 90) return '\x1b[31m'; // Red
+  return '\x1b[35m'; // Magenta (critical)
+}
+
+/**
+ * Display token usage with context bar
+ */
+function displayTokenUsage() {
+  const model = getCurrentModel();
+  const contextWindow = getContextWindow(model);
+  const usage = loadTokenUsage();
+  
+  const totalTokens = usage.totalInputTokens + usage.totalOutputTokens;
+  const percentage = Math.min((totalTokens / contextWindow) * 100, 100);
+  
+  const color = getPercentageColor(percentage);
+  const reset = '\x1b[0m';
+  const bar = createContextBar(percentage);
+  
+  // Format model name (truncate if too long for the box)
+  let modelName = model.split('-').map(
+    word => word.charAt(0).toUpperCase() + word.slice(1)
+  ).join(' ');
+  if (modelName.length > 41) {
+    modelName = modelName.substring(0, 38) + '...';
+  }
+  
+  console.log('');
+  console.log(`${color}╔══════════════════════════════════════════════════════════════╗${reset}`);
+  console.log(`${color}║${reset}  ${color}🤖 Active Model:${reset} ${modelName.padEnd(41)}${color}║${reset}`);
+  console.log(`${color}╠══════════════════════════════════════════════════════════════╣${reset}`);
+  console.log(`${color}║${reset}  ${color}📊 Token Usage:${reset}${' '.repeat(38)}${color}║${reset}`);
+  console.log(`${color}║${reset}    Input:  ${formatNumber(usage.totalInputTokens).padEnd(10)}tokens${' '.repeat(18)}${color}║${reset}`);
+  console.log(`${color}║${reset}    Output: ${formatNumber(usage.totalOutputTokens).padEnd(10)}tokens${' '.repeat(18)}${color}║${reset}`);
+  console.log(`${color}║${reset}    Total:  ${formatNumber(totalTokens).padEnd(10)}tokens${' '.repeat(18)}${color}║${reset}`);
+  console.log(`${color}╠══════════════════════════════════════════════════════════════╣${reset}`);
+  console.log(`${color}║${reset}  ${color}📈 Context Window:${reset}${' '.repeat(34)}${color}║${reset}`);
+  console.log(`${color}║${reset}    Used:   ${formatNumber(totalTokens).padEnd(10)}tokens${' '.repeat(18)}${color}║${reset}`);
+  console.log(`${color}║${reset}    Total:  ${formatNumber(contextWindow).padEnd(10)}tokens${' '.repeat(18)}${color}║${reset}`);
+  console.log(`${color}║${reset}    ${color}${bar}${reset} ${percentage.toFixed(1).padStart(5)}%${' '.repeat(10)}${color}║${reset}`);
+  console.log(`${color}╚══════════════════════════════════════════════════════════════╝${reset}`);
+  console.log('');
+}
+
+/**
+ * Hook: Called when Claude Code starts
+ */
+function onSessionStart() {
+  resetTokenUsage();
+  displayTokenUsage();
+}
+
+/**
+ * Hook: Called after each API response
+ * This would need to be integrated with Claude Code's response handler
+ */
+function onApiResponse(inputTokens, outputTokens) {
+  addTokens(inputTokens, outputTokens);
+}
+
+/**
+ * Hook: Display current status (can be called manually)
+ */
+function showStatus() {
+  displayTokenUsage();
+}
+
+/**
+ * Export functions for use
+ */
+module.exports = {
+  onSessionStart,
+  onApiResponse,
+  showStatus,
+  addTokens,
+  loadTokenUsage,
+  resetTokenUsage,
+  getCurrentModel,
+  getContextWindow
+};
+
+// Auto-run if called directly
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args.includes('--reset')) {
+    resetTokenUsage();
+    console.log('Token usage reset.');
+  } else {
+    displayTokenUsage();
+  }
+}