costhawk 1.1.7 → 1.2.0

package/README.md

@@ -1,140 +1,168 @@
 # CostHawk MCP Server
 
-Model Context Protocol (MCP) server that enables AI assistants like Claude to query your CostHawk data — track your spend, see your stats, and monitor your AI API costs directly from the command line.
+Official MCP server for [CostHawk](https://costhawk.ai) - AI API cost monitoring and optimization platform.
 
-## State of the Project
+> **Early Alpha** - CostHawk is currently in early alpha testing. [Join the waitlist](https://costhawk.ai) to get early access.
 
-**We are in active development and currently in early access.**
+## Overview
 
-As of **v1.1.7**, the following features are live:
-- Usage summary and cost tracking across providers
-- Savings calculations for flat-rate subscriptions (Claude Max, OpenAI Pro, etc.)
-- Anomaly detection and cost spike alerts
-- Webhook integrations (Slack, Discord, Teams, PagerDuty)
-- Model pricing lookup with context window info
+CostHawk helps teams track, analyze, and optimize their AI API spending across providers like Anthropic, OpenAI, and Google.
 
-**Versions prior to v1.1.4 were non-functional early builds.** If you installed an earlier version, please update:
+**Key Features:**
+- Real-time usage tracking and cost analytics
+- **Claude Code local usage tracking** (NEW in v1.2.0)
+- Savings analysis for flat-rate subscriptions (Claude Pro/Max, OpenAI Pro)
+- Budget alerts and anomaly detection
+- Webhook notifications (Slack, Discord, PagerDuty)
+
+## Quick Install
 
 ```bash
-npm update -g costhawk
+# Global installation (all projects)
+claude mcp add -s user -e COSTHAWK_API_KEY=YOUR_TOKEN_HERE costhawk -- npx -y costhawk
+
+# Project-specific installation
+claude mcp add -e COSTHAWK_API_KEY=YOUR_TOKEN_HERE costhawk -- npx -y costhawk
 ```
 
-## Getting Started
+Get your access token from [Settings → Developer](https://costhawk.ai/dashboard/settings) in your CostHawk dashboard (requires approved account).
 
-### Step 1: Join the Waitlist
+## Available Tools
 
-**You must first sign up at [costhawk.ai](https://costhawk.ai) to use this package.**
+### Usage Tracking
 
-We're in early access and onboarding new users weekly. Join the waitlist and we'll notify you when your account is ready.
+| Tool | Description |
+|------|-------------|
+| `costhawk_get_usage_summary` | Get usage and costs over a time period (by provider/model) |
+| `costhawk_get_usage_by_tag` | Get usage grouped by custom tags (user_id, feature, etc.) |
+| `costhawk_detect_anomalies` | Check for cost anomalies and unusual usage patterns |
 
-### Step 2: Get Your API Key
+### Claude Code Local Tracking (NEW in v1.2.0)
 
-Once approved:
-1. Log into your [CostHawk dashboard](https://costhawk.ai/dashboard)
-2. Go to **Settings → API Keys**
-3. Create a new key for MCP access
-4. Copy the key (you'll only see it once)
+These tools parse your local Claude Code transcripts from `~/.claude/projects/` to track token usage - including the 4 token types Claude Code uses:
 
-### Step 3: Install the Package
+- `input_tokens` - Regular input
+- `output_tokens` - Regular output
+- `cache_creation_input_tokens` - Writing to prompt cache
+- `cache_read_input_tokens` - Reading from cache (10x cheaper!)
 
-```bash
-npm install -g costhawk
-```
+| Tool | Description |
+|------|-------------|
+| `costhawk_sync_claude_code_usage` | Sync local usage to CostHawk dashboard for savings analysis |
+| `costhawk_get_local_claude_code_usage` | View local usage offline with cost breakdown |
+| `costhawk_list_claude_code_sessions` | List available Claude Code sessions |
 
-### Step 4: Configure Your MCP Client
+**Example: Check local usage offline**
+```
+Use costhawk_get_local_claude_code_usage with subscriptionPlan="max_5x"
+```
 
-#### For Claude Code
+This shows your token usage, costs at retail rates, and whether you're saving money vs your subscription.
 
-Add to `~/.claude/.mcp.json`:
+### Savings Analysis
 
-```json
-{
-  "mcpServers": {
-    "costhawk": {
-      "command": "npx",
-      "args": ["-y", "costhawk"],
-      "env": {
-        "COSTHAWK_API_KEY": "your-api-key-here"
-      }
-    }
-  }
-}
-```
+| Tool | Description |
+|------|-------------|
+| `costhawk_get_savings` | Compare retail costs vs subscription costs |
+| `costhawk_get_savings_breakdown` | Per-model breakdown of usage and costs |
+| `costhawk_list_subscriptions` | List your active flat-rate subscriptions |
 
-Then restart Claude Code.
-
-#### For Claude Desktop
-
-Edit your config file:
-- **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
-- **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
-
-```json
-{
-  "mcpServers": {
-    "costhawk": {
-      "command": "npx",
-      "args": ["-y", "costhawk"],
-      "env": {
-        "COSTHAWK_API_KEY": "your-api-key-here"
-      }
-    }
-  }
-}
-```
+### Pricing & Alerts
 
-Then restart Claude Desktop.
+| Tool | Description |
+|------|-------------|
+| `costhawk_get_model_pricing` | Get current AI model pricing (input/output per 1M tokens) |
+| `costhawk_list_alerts` | List budget warnings, cost spikes, and anomaly alerts |
 
-## Available Tools
+### Webhooks
 
 | Tool | Description |
 |------|-------------|
-| `costhawk_get_usage_summary` | Get usage and cost summary for a date range |
-| `costhawk_get_usage_by_tag` | Break down costs by metadata tags (project, environment, etc.) |
-| `costhawk_detect_anomalies` | Find cost spikes and unusual activity patterns |
-| `costhawk_list_webhooks` | List your configured alert webhooks |
-| `costhawk_create_webhook` | Set up new webhooks for Slack, Discord, Teams, or custom URLs |
-| `costhawk_get_model_pricing` | Look up current model pricing by provider |
-| `costhawk_list_alerts` | View alerts and notifications |
-| `costhawk_get_savings` | Show savings vs retail pricing for flat-rate subscriptions |
-| `costhawk_list_subscriptions` | List active flat-rate subscriptions |
-| `costhawk_get_savings_breakdown` | Show per-model usage and retail cost breakdown |
-
-## Example Prompts
-
-Once configured, you can ask Claude:
-
-- "What's my AI API usage this month?"
-- "Show me costs broken down by project tag"
-- "Are there any cost anomalies I should know about?"
-- "What's the current pricing for Claude Opus?"
-- "Create a Slack webhook for budget alerts"
-- "List my unread alerts"
-- "Show my savings vs retail this month"
-- "List my flat-rate subscriptions"
-- "Break down my savings by model"
+| `costhawk_list_webhooks` | List configured webhook endpoints |
+| `costhawk_create_webhook` | Create webhook for Slack, Discord, Teams, PagerDuty |
+
+## Claude Code Token Types Explained
+
+Claude Code uses caching extensively, which significantly affects your costs:
+
+| Token Type | Description | Sonnet 4 Pricing |
+|------------|-------------|------------------|
+| Input | Regular input tokens | $3/1M |
+| Output | Regular output tokens | $15/1M |
+| Cache Write | Writing to prompt cache | $3.75/1M |
+| Cache Read | Reading from cache | $0.30/1M (10x cheaper!) |
+
+The cache read savings are significant - CostHawk tracks all 4 types to give you accurate cost calculations.
 
 ## Environment Variables
 
-| Variable | Required | Default | Description |
-|----------|----------|---------|-------------|
-| `COSTHAWK_API_KEY` | Yes | - | Your CostHawk API key |
-| `COSTHAWK_API_URL` | No | `https://costhawk.ai` | API base URL (for self-hosted) |
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `COSTHAWK_API_KEY` | Yes* | Your CostHawk API token |
+| `COSTHAWK_API_URL` | No | API base URL (defaults to https://costhawk.ai) |
+
+*Required for most tools. Local Claude Code tools work offline without an API key.
+
+## Getting Started
+
+1. **Get Early Access**: [Join the waitlist](https://costhawk.ai) and wait for approval
+2. **Create API Token**: Go to Settings → Developer → Create Token
+3. **Install MCP Server**: Use the quick install command above
+4. **Start Tracking**: Use the tools in Claude Code or Claude Desktop
+
+## Example Workflows
+
+### Check if your Claude Max subscription is worth it
+
+```
+1. costhawk_list_claude_code_sessions (see what's available)
+2. costhawk_get_local_claude_code_usage with subscriptionPlan="max_5x"
+3. Review the savings breakdown
+```
+
+### Sync usage to dashboard for team visibility
+
+```
+1. costhawk_sync_claude_code_usage (uploads to CostHawk)
+2. View detailed analytics at costhawk.ai/dashboard
+```
+
+### Set up cost spike alerts
+
+```
+1. costhawk_create_webhook with type="slack" and events=["cost_spike", "budget_alert"]
+2. Get notified when costs exceed thresholds
+```
+
+## Changelog
+
+### v1.2.0 (January 2026)
+**Claude Code Local Tracking** - Major new feature release
+
+- **New:** `costhawk_sync_claude_code_usage` - Sync local Claude Code transcripts to CostHawk
+- **New:** `costhawk_get_local_claude_code_usage` - View usage offline with cost breakdown
+- **New:** `costhawk_list_claude_code_sessions` - List available local sessions
+- **New:** Full support for all 4 Claude Code token types (input, output, cache write, cache read)
+- **New:** Offline cost calculation with embedded pricing
+- **New:** Savings comparison vs Claude Pro/Max subscriptions
 
-## Troubleshooting
+### v1.1.x
+- Savings analysis tools (`costhawk_get_savings`, `costhawk_get_savings_breakdown`)
+- Subscription management (`costhawk_list_subscriptions`)
+- Webhook support for Slack, Discord, Teams, PagerDuty
+- Usage tracking and anomaly detection
 
-**"Tool not found" errors:**
-- Ensure Claude was restarted after config changes
-- Verify the config file syntax is valid JSON
+### v1.0.x
+- Initial release
+- Basic usage summary and cost tracking
+- Model pricing lookup
+- Alert notifications
 
-**"Authentication failed" errors:**
-- Verify your API key is correct
-- Check the key is active in CostHawk dashboard
-- Make sure you've been approved from the waitlist
+## Links
 
-**"Connection refused" errors:**
-- Ensure `COSTHAWK_API_URL` is accessible
-- Check your network/firewall settings
+- [Join Waitlist](https://costhawk.ai)
+- [Documentation](https://docs.costhawk.ai)
+- [npm Package](https://www.npmjs.com/package/costhawk)
 
 ## License
 

package/dist/index.js

@@ -2,6 +2,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+// Claude Code local transcript parsing
+import { claudeCodeDirectoryExists, discoverTranscripts, parseAllTranscripts, aggregateUsage, } from "./transcript-parser.js";
+import { calculateCost, formatCost, formatTokens, calculateSavings, CLAUDE_SUBSCRIPTIONS, } from "./pricing-constants.js";
 // Constants
 const CHARACTER_LIMIT = 25000;
 const REQUEST_TIMEOUT_MS = 30000; // 30 seconds
@@ -296,6 +299,75 @@ function formatSavingsBreakdownMarkdown(data) {
     }
     return truncateResponse(output);
 }
+// Claude Code local usage formatters
+function formatClaudeCodeLocalUsageMarkdown(data) {
+    let output = `# Claude Code Local Usage\n\n`;
+    output += `## Summary\n`;
+    output += `| Metric | Value |\n|--------|-------|\n`;
+    output += `| Sessions | ${data.sessions} |\n`;
+    output += `| Total Tokens | ${formatTokens(data.tokens.total)} |\n`;
+    output += `| Input Tokens | ${formatTokens(data.tokens.input)} |\n`;
+    output += `| Output Tokens | ${formatTokens(data.tokens.output)} |\n`;
+    output += `| Cache Write Tokens | ${formatTokens(data.tokens.cacheCreation)} |\n`;
+    output += `| Cache Read Tokens | ${formatTokens(data.tokens.cacheRead)} |\n\n`;
+    output += `## Cost Breakdown (Retail Rates)\n`;
+    output += `| Category | Cost |\n|----------|------|\n`;
+    output += `| Input | ${formatCost(data.cost.inputCost)} |\n`;
+    output += `| Output | ${formatCost(data.cost.outputCost)} |\n`;
+    output += `| Cache Write | ${formatCost(data.cost.cacheWriteCost)} |\n`;
+    output += `| Cache Read | ${formatCost(data.cost.cacheReadCost)} |\n`;
+    output += `| **Total** | **${formatCost(data.cost.totalCost)}** |\n\n`;
+    if (data.savings) {
+        const statusEmoji = data.savings.status === "saving" ? "✅" : data.savings.status === "losing" ? "⚠️" : "➖";
+        output += `## Subscription Savings\n`;
+        output += `| Metric | Value |\n|--------|-------|\n`;
+        output += `| Subscription | ${data.savings.subscriptionPlan} |\n`;
+        output += `| Monthly Cost | ${formatCost(data.savings.subscriptionCost)} |\n`;
+        output += `| Retail Value | ${formatCost(data.cost.totalCost)} |\n`;
+        output += `| Savings | ${formatCost(data.savings.savingsAmount)} |\n`;
+        output += `| Savings Rate | ${data.savings.savingsPercentage.toFixed(1)}% |\n`;
+        output += `| Status | ${statusEmoji} ${data.savings.status} |\n\n`;
+    }
+    if (data.sessionDetails.length > 0) {
+        output += `## Recent Sessions\n`;
+        output += `| Session | Model | Tokens | Cost |\n|---------|-------|--------|------|\n`;
+        for (const session of data.sessionDetails.slice(0, 10)) {
+            const shortId = session.sessionId.slice(0, 8);
+            output += `| ${shortId}... | ${session.model} | ${formatTokens(session.tokens)} | ${formatCost(session.cost)} |\n`;
+        }
+        if (data.sessionDetails.length > 10) {
+            output += `\n*...and ${data.sessionDetails.length - 10} more sessions*\n`;
+        }
+    }
+    return truncateResponse(output);
+}
+function formatClaudeCodeSyncResultMarkdown(data) {
+    const statusEmoji = data.success ? "✅" : "❌";
+    let output = `# Claude Code Sync Result\n\n`;
+    output += `${statusEmoji} ${data.message}\n\n`;
+    output += `| Metric | Value |\n|--------|-------|\n`;
+    output += `| New Sessions | ${data.sessionsNew} |\n`;
+    output += `| Updated Sessions | ${data.sessionsUpdated} |\n`;
+    output += `| Total Tokens | ${formatTokens(data.totalTokens)} |\n`;
+    output += `| Estimated Cost | ${formatCost(data.estimatedCost)} |\n`;
+    return truncateResponse(output);
+}
+function formatClaudeCodeSessionsMarkdown(sessions) {
+    if (sessions.length === 0) {
+        return "# Claude Code Sessions\n\nNo sessions found. Make sure you have used Claude Code recently.";
+    }
+    let output = `# Claude Code Sessions\n\n`;
+    output += `Found ${sessions.length} session(s)\n\n`;
+    output += `| Session ID | Project | Last Modified | Size |\n|------------|---------|---------------|------|\n`;
+    for (const session of sessions) {
+        const shortId = session.sessionId.slice(0, 12);
+        const shortProject = session.projectHash.slice(0, 8);
+        const date = session.lastModified.toISOString().split("T")[0];
+        const sizeKB = (session.size / 1024).toFixed(1);
+        output += `| ${shortId}... | ${shortProject}... | ${date} | ${sizeKB} KB |\n`;
+    }
+    return truncateResponse(output);
+}
 // Create MCP server
 const server = new McpServer({
     name: "costhawk-mcp-server",
@@ -444,6 +516,46 @@ const GetSavingsBreakdownSchema = {
     orgId: z.string().optional().describe("Optional organization ID to scope the breakdown"),
     format: z.enum(["markdown", "json"]).optional().default("markdown").describe("Response format"),
 };
+// Claude Code local transcript schemas
+const SyncClaudeCodeUsageSchema = {
+    apiKey: z
+        .string()
+        .optional()
+        .describe("Your CostHawk API key. If not provided, uses COSTHAWK_API_KEY environment variable."),
+    maxAgeHours: z
+        .number()
+        .min(1)
+        .max(720)
+        .optional()
+        .default(24)
+        .describe("Only sync sessions modified within this many hours (1-720, default 24)"),
+    format: z.enum(["markdown", "json"]).optional().default("markdown").describe("Response format"),
+};
+const GetLocalClaudeCodeUsageSchema = {
+    maxAgeHours: z
+        .number()
+        .min(1)
+        .max(720)
+        .optional()
+        .default(24)
+        .describe("Only include sessions modified within this many hours (1-720, default 24)"),
+    subscriptionPlan: z
+        .enum(["pro", "max_5x", "max_20x"])
+        .optional()
+        .describe("Your Claude subscription plan for savings calculation"),
+    format: z.enum(["markdown", "json"]).optional().default("markdown").describe("Response format"),
+};
+const ListClaudeCodeSessionsSchema = {
+    maxAgeHours: z
+        .number()
+        .min(1)
+        .max(720)
+        .optional()
+        .default(168)
+        .describe("Only include sessions modified within this many hours (1-720, default 168 = 7 days)"),
+    limit: z.number().min(1).max(100).optional().default(20).describe("Maximum number of sessions to show"),
+    format: z.enum(["markdown", "json"]).optional().default("markdown").describe("Response format"),
+};
 // Register tools using registerTool (recommended API)
 server.registerTool("costhawk_get_usage_summary", {
     description: `Get a summary of your AI API usage and costs over a time period. Returns total costs, API calls, and token usage broken down by provider and model. Supports preset periods (last_24h, today, yesterday, last_7d, last_30d) or custom date ranges.`,
@@ -832,6 +944,224 @@ server.registerTool("costhawk_list_alerts", {
         };
     }
 });
+// ============================================================================
+// CLAUDE CODE LOCAL TRANSCRIPT TOOLS
+// ============================================================================
+// These tools parse local Claude Code transcripts from ~/.claude/projects/
+// to track token usage and calculate savings vs subscription costs.
+server.registerTool("costhawk_sync_claude_code_usage", {
+    description: `Sync your local Claude Code usage to CostHawk. Parses transcript files from ~/.claude/projects/ and uploads token counts to your CostHawk dashboard for savings analysis. Requires API key.`,
+    inputSchema: SyncClaudeCodeUsageSchema,
+    annotations: WRITE_ANNOTATIONS,
+}, async (args, _extra) => {
+    const apiKey = getApiKey(args.apiKey);
+    if (!apiKey) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: No API key provided. You must first sign up at https://costhawk.ai to get an API key. Once approved, go to Settings > Developer > Create Token, then set COSTHAWK_API_KEY in your MCP configuration.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    // Check if Claude Code directory exists
+    if (!claudeCodeDirectoryExists()) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: Claude Code directory not found at ~/.claude/projects/. Make sure you have used Claude Code at least once.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        // Parse all transcripts within age limit
+        const maxAgeHours = args.maxAgeHours ?? 24;
+        const sessions = parseAllTranscripts(maxAgeHours);
+        if (sessions.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No Claude Code sessions found within the last ${maxAgeHours} hours. Try increasing maxAgeHours or use Claude Code first.`,
+                    },
+                ],
+            };
+        }
+        // Transform sessions to API payload format
+        const payload = {
+            sessions: sessions.map((session) => ({
+                sessionId: session.sessionId,
+                projectHash: session.projectHash,
+                model: session.model,
+                inputTokens: session.tokens.inputTokens,
+                outputTokens: session.tokens.outputTokens,
+                cacheCreationTokens: session.tokens.cacheCreationTokens,
+                cacheReadTokens: session.tokens.cacheReadTokens,
+                messageCount: session.messageCount,
+                startTime: session.startTime,
+                endTime: session.endTime,
+            })),
+            clientVersion: "1.2.0",
+            syncedAt: new Date().toISOString(),
+        };
+        // Send to CostHawk API
+        const result = await apiRequest("/api/mcp/usage/claude-code", {
+            method: "POST",
+            apiKey,
+            body: payload,
+        });
+        const text = args.format === "json" ? JSON.stringify(result, null, 2) : formatClaudeCodeSyncResultMarkdown(result);
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true,
+        };
+    }
+});
+server.registerTool("costhawk_get_local_claude_code_usage", {
+    description: `Get Claude Code usage from local transcripts WITHOUT uploading to CostHawk. Works offline. Shows token counts, costs at retail rates, and optional savings calculation if you provide your subscription plan.`,
+    inputSchema: GetLocalClaudeCodeUsageSchema,
+    annotations: READ_ONLY_ANNOTATIONS,
+}, async (args, _extra) => {
+    // Check if Claude Code directory exists
+    if (!claudeCodeDirectoryExists()) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: Claude Code directory not found at ~/.claude/projects/. Make sure you have used Claude Code at least once.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        const maxAgeHours = args.maxAgeHours ?? 24;
+        const sessions = parseAllTranscripts(maxAgeHours);
+        if (sessions.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No Claude Code sessions found within the last ${maxAgeHours} hours. Try increasing maxAgeHours or use Claude Code first.`,
+                    },
+                ],
+            };
+        }
+        // Aggregate usage
+        const aggregated = aggregateUsage(sessions);
+        // Calculate total cost using dominant model pricing
+        const dominantModel = Object.entries(aggregated.models).sort((a, b) => b[1] - a[1])[0]?.[0] || "unknown";
+        const cost = calculateCost({
+            inputTokens: aggregated.tokens.inputTokens,
+            outputTokens: aggregated.tokens.outputTokens,
+            cacheCreationTokens: aggregated.tokens.cacheCreationTokens,
+            cacheReadTokens: aggregated.tokens.cacheReadTokens,
+        }, dominantModel);
+        // Build session details
+        const sessionDetails = sessions.map((session) => {
+            const sessionCost = calculateCost(session.tokens, session.model);
+            const totalTokens = session.tokens.inputTokens +
+                session.tokens.outputTokens +
+                session.tokens.cacheCreationTokens +
+                session.tokens.cacheReadTokens;
+            return {
+                sessionId: session.sessionId,
+                projectHash: session.projectHash,
+                model: session.model,
+                tokens: totalTokens,
+                cost: sessionCost.totalCost,
+                startTime: session.startTime,
+                endTime: session.endTime,
+            };
+        });
+        // Build response
+        const response = {
+            sessions: aggregated.totalSessions,
+            tokens: {
+                input: aggregated.tokens.inputTokens,
+                output: aggregated.tokens.outputTokens,
+                cacheCreation: aggregated.tokens.cacheCreationTokens,
+                cacheRead: aggregated.tokens.cacheReadTokens,
+                total: aggregated.totalTokens,
+            },
+            cost,
+            sessionDetails,
+        };
+        // Add savings calculation if subscription plan provided
+        if (args.subscriptionPlan) {
+            const subscription = CLAUDE_SUBSCRIPTIONS[args.subscriptionPlan];
+            const savings = calculateSavings(cost.totalCost, subscription.monthlyFee);
+            response.savings = {
+                subscriptionPlan: subscription.name,
+                subscriptionCost: subscription.monthlyFee,
+                savingsAmount: savings.savings,
+                savingsPercentage: savings.savingsPercentage,
+                status: savings.status,
+            };
+        }
+        const text = args.format === "json" ? JSON.stringify(response, null, 2) : formatClaudeCodeLocalUsageMarkdown(response);
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true,
+        };
+    }
+});
+server.registerTool("costhawk_list_claude_code_sessions", {
+    description: `List available Claude Code sessions from local transcripts. Shows session IDs, project hashes, modification dates, and file sizes. Use this to see what sessions are available before syncing.`,
+    inputSchema: ListClaudeCodeSessionsSchema,
+    annotations: READ_ONLY_ANNOTATIONS,
+}, async (args, _extra) => {
+    // Check if Claude Code directory exists
+    if (!claudeCodeDirectoryExists()) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: Claude Code directory not found at ~/.claude/projects/. Make sure you have used Claude Code at least once.",
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        const maxAgeHours = args.maxAgeHours ?? 168;
+        const limit = args.limit ?? 20;
+        const transcripts = discoverTranscripts(maxAgeHours).slice(0, limit);
+        const text = args.format === "json"
+            ? JSON.stringify(transcripts.map((t) => ({
+                sessionId: t.sessionId,
+                projectHash: t.projectHash,
+                lastModified: t.lastModified.toISOString(),
+                size: t.size,
+                path: t.path,
+            })), null, 2)
+            : formatClaudeCodeSessionsMarkdown(transcripts);
+        return {
+            content: [{ type: "text", text }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+            isError: true,
+        };
+    }
+});
 // Start server
 async function main() {
     const transport = new StdioServerTransport();