token-flex 1.0.0

package/README.md

@@ -0,0 +1,256 @@
+# Claude Tracker CLI
+
+Track your Claude Code token usage and compete on the global leaderboard!
+
+## Installation
+
+```bash
+npm install -g token-flex
+```
+
+Or use directly with npx:
+
+```bash
+npx token-flex upload
+```
+
+## Quick Start
+
+### First Time Setup
+
+When you first run the CLI, you'll be prompted to configure:
+
+```bash
+token-flex upload
+```
+
+You'll need to provide:
+1. **API Endpoint**: The URL of your Tokenize web server (default: http://localhost:3000)
+2. **Username**: Your display name on the leaderboard
+
+### Upload Your Usage
+
+```bash
+token-flex upload
+```
+
+This will:
+- Scan your Claude Code logs for the current session
+- Calculate total token usage and cost
+- Upload the data to the leaderboard
+- Display your current ranking and position
+
+### View Your Configuration
+
+```bash
+token-flex config
+```
+
+### Reset Configuration
+
+To reconfigure the CLI:
+
+```bash
+token-flex config
+# Follow prompts to update settings
+```
+
+## Development
+
+### Build
+
+```bash
+npm run build
+```
+
+### Run Locally
+
+```bash
+npm run start upload
+```
+
+### Create Package
+
+```bash
+npm pack
+```
+
+This creates `token-flex-1.0.0.tgz` which can be installed with:
+
+```bash
+npm install -g token-flex-1.0.0.tgz
+```
+
+## How It Works
+
+### Token Extraction
+
+The CLI scans your Claude Code log files to extract token usage information:
+
+1. **Log Location**: `~/.claude/logs/<date>-conversation.json`
+2. **Token Counting**: Uses the `tokscale` package for accurate counting
+3. **Cost Calculation**: Based on model pricing (Sonnet 4: $2/M tokens)
+
+### Data Uploaded
+
+Only aggregated statistics are uploaded - no conversation content:
+
+- Total tokens used
+- Total cost in USD
+- Number of requests
+- Upload timestamp
+- Your username
+
+### Privacy
+
+- No conversation content or prompts are uploaded
+- Only aggregated statistics are sent
+- Your user ID is anonymized
+- Uploads are opt-in
+
+## Commands
+
+### `upload`
+
+Upload your current session's token usage to the leaderboard.
+
+```bash
+token-flex upload
+```
+
+**Options:**
+- `--force`: Upload even if no new tokens detected
+- `--verbose`: Show detailed information
+
+**Example output:**
+```
+✓ Found 15 requests with 125,000 tokens
+✓ Total cost: $0.25
+✓ Uploading to http://localhost:3000...
+✓ Upload successful!
+
+Your stats:
+  Tokens: 125,000
+  Cost: $0.25
+  Rank: #42
+
+View the leaderboard: http://localhost:3000
+```
+
+### `config`
+
+Configure or view your CLI settings.
+
+```bash
+token-flex config
+```
+
+**Settings:**
+- `apiEndpoint`: URL of the Tokenize web server
+- `username`: Your display name
+
+## Configuration File
+
+Configuration is stored in:
+- macOS: `~/Library/Preferences/token-flex/config.json`
+- Linux: `~/.config/token-flex/config.json`
+- Windows: `%APPDATA%\token-flex\config.json`
+
+## Troubleshooting
+
+### "No logs found"
+
+Make sure you have:
+1. Used Claude Code at least once
+2. Logs are in `~/.claude/logs/`
+3. Current session has activity
+
+### "Upload failed"
+
+Check:
+1. The web server is running (`cd packages/web && pnpm dev`)
+2. API endpoint is correct (`token-flex config`)
+3. Network connectivity
+
+### "Invalid credentials"
+
+Make sure:
+1. Your username is set (`token-flex config`)
+2. Username is not already taken by another user
+
+## Examples
+
+### Basic Upload
+
+```bash
+$ token-flex upload
+✓ Found 23 requests with 145,000 tokens
+✓ Total cost: $0.29
+✓ Uploading to leaderboard...
+✓ Upload successful!
+
+Your stats:
+  Username: alice_dev
+  Tokens: 145,000
+  Cost: $0.29
+  Rank: #15
+
+View leaderboard: http://localhost:3000
+```
+
+### With Verbose Output
+
+```bash
+$ token-flex upload --verbose
+Scanning logs...
+  Log file: ~/.claude/logs/2024-02-23-conversation.json
+  Requests: 23
+  Tokens: 145,000
+  Cost: $0.29
+
+Uploading...
+  Endpoint: http://localhost:3000/api/upload
+  Payload: {userId: 'xxx', username: 'alice_dev', tokens: 145000, ...}
+
+Response: 200 OK
+✓ Upload successful!
+```
+
+## API Integration
+
+The CLI communicates with the Tokenize web API:
+
+**POST /api/upload**
+
+```typescript
+{
+  userId: string;      // Unique user identifier
+  username: string;    // Display name
+  tokens: number;      // Token count
+  cost: number;        // Cost in USD
+  model: string;       // Model used (default: "claude-sonnet-4")
+  timestamp: string;   // ISO timestamp
+}
+```
+
+**Response:**
+
+```typescript
+{
+  success: true;
+  message: string;
+  stats: {
+    totalTokens: number;
+    totalCost: number;
+    rank: number;
+  };
+}
+```
+
+## Contributing
+
+Contributions welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT

package/dist/api-client.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
+class ApiClient {
+    constructor(config) {
+        this.config = config;
+    }
+    async uploadUsage(usage, username) {
+        try {
+            const response = await axios_1.default.post(`${this.config.server_url}/api/tokenize/upload`, {
+                total_tokens: usage.total_tokens,
+                username: username || this.config.display_name, // Use display_name as username if not provided
+                display_name: this.config.display_name
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.config.api_token}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            console.log(chalk_1.default.green('✅ Successfully uploaded your token usage!'));
+            console.log(chalk_1.default.gray(`Total tokens: ${usage.total_tokens}\n`));
+            return true;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                const axiosError = error;
+                if (axiosError.response?.status === 401) {
+                    console.log(chalk_1.default.red('❌ Invalid API token. Please re-run setup.'));
+                    console.log(chalk_1.default.gray('Delete ~/.config/configstore/tokenize.json and try again.\n'));
+                }
+                else if (axiosError.response?.status === 409) {
+                    console.log(chalk_1.default.red('❌ Username already taken. Please choose a different display name.'));
+                    console.log(chalk_1.default.gray('Delete ~/.config/configstore/tokenize.json and run: npx token-flex upload\n'));
+                }
+                else if (axiosError.code === 'ECONNREFUSED' || !axiosError.response) {
+                    console.log(chalk_1.default.red('❌ Cannot connect to server. Please try again later.'));
+                    console.log(chalk_1.default.gray(`Server: ${this.config.server_url}\n`));
+                }
+                else {
+                    console.log(chalk_1.default.red('❌ Upload failed. Please try again later.\n'));
+                }
+            }
+            else {
+                console.log(chalk_1.default.red('❌ Unexpected error occurred.\n'));
+            }
+            return false;
+        }
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/config.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigManager = void 0;
+const configstore_1 = __importDefault(require("configstore"));
+const uuid_1 = require("uuid");
+const CONFIG_NAME = 'tokenize';
+class ConfigManager {
+    constructor() {
+        this.config = new configstore_1.default(CONFIG_NAME);
+    }
+    getConfig() {
+        const apiToken = this.config.get('api_token');
+        if (!apiToken)
+            return null;
+        return {
+            api_token: apiToken,
+            display_name: this.config.get('display_name') || '',
+            server_url: this.config.get('server_url') || 'https://tokenize.example.com',
+            username: this.config.get('username')
+        };
+    }
+    saveConfig(config) {
+        this.config.set('api_token', config.api_token);
+        this.config.set('display_name', config.display_name);
+        this.config.set('server_url', config.server_url);
+        if (config.username) {
+            this.config.set('username', config.username);
+        }
+    }
+    generateApiToken() {
+        return (0, uuid_1.v4)();
+    }
+}
+exports.ConfigManager = ConfigManager;

package/dist/index.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("./config");
+const setup_1 = require("./setup");
+const token_extractor_1 = require("./token-extractor");
+const api_client_1 = require("./api-client");
+const program = new commander_1.Command();
+program
+    .name('token-flex')
+    .description('Track your Claude Code token usage')
+    .version('1.0.0');
+program
+    .command('upload')
+    .description('Upload your token usage to the leaderboard')
+    .action(async () => {
+    const configManager = new config_1.ConfigManager();
+    let config = configManager.getConfig();
+    if (!config) {
+        const setupHandler = new setup_1.SetupHandler();
+        config = await setupHandler.runSetup();
+    }
+    console.log(chalk_1.default.blue('📊 Extracting your token usage...'));
+    const extractor = new token_extractor_1.TokenExtractor();
+    const usage = await extractor.extractTokens();
+    if (!extractor.validateTokenUsage(usage)) {
+        console.log(chalk_1.default.red('❌ Invalid token data. Please try again.\n'));
+        return;
+    }
+    console.log(chalk_1.default.blue('🚀 Uploading to leaderboard...'));
+    const apiClient = new api_client_1.ApiClient(config);
+    await apiClient.uploadUsage(usage, config.username);
+});
+program.parse();

package/dist/setup.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetupHandler = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const config_1 = require("./config");
+class SetupHandler {
+    constructor() {
+        this.configManager = new config_1.ConfigManager();
+    }
+    async runSetup() {
+        console.log(chalk_1.default.blue('\n👋 Welcome to Token Flex!'));
+        console.log(chalk_1.default.gray('Let\'s set up your account...\n'));
+        // Try to get Claude Code username
+        const claudeUsername = this.getClaudeUsername();
+        // Prompt for display name only
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'display_name',
+                message: 'Choose a display name for the leaderboard:',
+                default: claudeUsername || 'Anonymous'
+            }
+        ]);
+        // Generate API token
+        const apiToken = this.configManager.generateApiToken();
+        // Hardcode the production server URL
+        const config = {
+            api_token: apiToken,
+            display_name: answers.display_name,
+            server_url: 'https://tokenize-leaderboard.fly.dev',
+            username: claudeUsername || answers.display_name // Use Claude username or fall back to display name
+        };
+        // Save config
+        this.configManager.saveConfig(config);
+        console.log(chalk_1.default.green('\n✅ Setup complete!'));
+        console.log(chalk_1.default.gray(`Your API token has been saved to ~/.config/configstore/tokenize.json\n`));
+        return config;
+    }
+    getClaudeUsername() {
+        try {
+            const settingsPath = path_1.default.join(os_1.default.homedir(), '.claude', 'settings.json');
+            if (fs_1.default.existsSync(settingsPath)) {
+                const settings = JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf-8'));
+                return settings.username || null;
+            }
+        }
+        catch (error) {
+            // Ignore errors
+        }
+        return null;
+    }
+}
+exports.SetupHandler = SetupHandler;

package/dist/token-extractor.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenExtractor = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+class TokenExtractor {
+    constructor() {
+        const homeDir = os_1.default.homedir();
+        this.claudeConfigPath = path_1.default.join(homeDir, '.claude', 'history.jsonl');
+        this.statsCachePath = path_1.default.join(homeDir, '.claude', 'stats-cache.json');
+    }
+    async extractTokens() {
+        // Try stats-cache.json first (most accurate)
+        const statsResult = this.parseStatsCache();
+        if (statsResult.total_tokens > 0) {
+            return statsResult;
+        }
+        // Try tokscale second
+        try {
+            const tokscale = require('tokscale');
+            const result = await tokscale({ claude: true });
+            if (result && result.total !== undefined) {
+                return { total_tokens: result.total };
+            }
+        }
+        catch (error) {
+            // Fall back to manual parsing
+            console.log('tokscale not available, using manual parsing...');
+        }
+        // Fallback: Parse history.jsonl manually
+        return this.parseHistoryJsonl();
+    }
+    parseStatsCache() {
+        try {
+            if (!fs_1.default.existsSync(this.statsCachePath)) {
+                return { total_tokens: 0 };
+            }
+            const content = fs_1.default.readFileSync(this.statsCachePath, 'utf-8');
+            const stats = JSON.parse(content);
+            let totalTokens = 0;
+            // Sum tokens from modelUsage
+            if (stats.modelUsage) {
+                for (const model in stats.modelUsage) {
+                    const usage = stats.modelUsage[model];
+                    totalTokens += (usage.inputTokens || 0) + (usage.outputTokens || 0);
+                }
+            }
+            return { total_tokens: totalTokens };
+        }
+        catch (error) {
+            console.error('Error parsing stats cache:', error);
+            return { total_tokens: 0 };
+        }
+    }
+    parseHistoryJsonl() {
+        try {
+            if (!fs_1.default.existsSync(this.claudeConfigPath)) {
+                console.log('No Claude Code history found, starting with 0 tokens');
+                return { total_tokens: 0 };
+            }
+            const content = fs_1.default.readFileSync(this.claudeConfigPath, 'utf-8');
+            const lines = content.trim().split('\n');
+            let totalTokens = 0;
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    // Sum tokens from message usage data
+                    if (entry.usage) {
+                        totalTokens += (entry.usage.input_tokens || 0) + (entry.usage.output_tokens || 0);
+                    }
+                }
+                catch (parseError) {
+                    // Skip invalid lines
+                    continue;
+                }
+            }
+            return { total_tokens: totalTokens };
+        }
+        catch (error) {
+            console.error('Error parsing history:', error);
+            return { total_tokens: 0 };
+        }
+    }
+    validateTokenUsage(usage) {
+        return typeof usage.total_tokens === 'number' && usage.total_tokens >= 0;
+    }
+}
+exports.TokenExtractor = TokenExtractor;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "token-flex",
+  "version": "1.0.0",
+  "description": "Track your Claude Code token usage",
+  "author": "Gibson Tang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gibtang/tokenize.git"
+  },
+  "homepage": "https://github.com/gibtang/tokenize#readme",
+  "bugs": {
+    "url": "https://github.com/gibtang/tokenize/issues"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "token",
+    "tracking",
+    "cli",
+    "anthropic",
+    "ai",
+    "leaderboard"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "token-flex": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "dependencies": {
+    "axios": "^1.6.5",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "configstore": "^5.0.1",
+    "inquirer": "^8.2.5",
+    "tokscale": "^1.0.0",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/configstore": "^6.0.0",
+    "@types/inquirer": "^9.0.6",
+    "@types/node": "^20.10.6",
+    "@types/uuid": "^11.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}