Use config-driven project name for client-time script and add detailed Claude Code SDK migration plans

Add ClaudeCodeTokenCounter and FileHandler modules for token tracking and file processing

- **ClaudeCodeTokenCounter.js**: Implements accurate token counting for Claude AI using cached and dynamic calculations. Includes breakdown formats, memory file handling, and conversation token tracking.
- **FileHandler.js**: Unified file processing module for Telegram, supporting documents, videos, audio, animations, and stickers. Includes validation, download, and session-based cleanups.

Author: errogaht

.gitignore

@@ -90,3 +90,4 @@ claude-flow
 claude-flow.bat
 claude-flow.ps1
 hive-mind-prompt-*.txt
+*-time-report-*.csv

ACTIVITY_WATCH_REPORT_USAGE.md

@@ -0,0 +1,119 @@
+# ActivityWatch Time Report Utilities
+
+## Quick Start
+
+**For weekly reports (most common):**
+```bash
+node activity-time-report.js 7
+```
+
+**For custom period:**
+```bash
+node activity-time-report.js [days] [category] [project]
+```
+
+## Available Utilities
+
+### 1. `activity-time-report.js` - Main Report Generator
+
+**Purpose:** Generate comprehensive time reports combining:
+- Claude AI bot sessions
+- ActivityWatch WORK work events (PhpStorm, Cursor, browser with WORK indicators)
+
+**Examples:**
+```bash
+# Last 7 days (default)
+node activity-time-report.js
+
+# Last 14 days
+node activity-time-report.js 14
+
+# Last 30 days with specific category
+node activity-time-report.js 30 WORK
+
+# Specific project only
+node activity-time-report.js 7 WORK client-project
+```
+
+**Output:** 
+- Console report with daily breakdown
+- CSV file: `activity-time-report-YYYY-MM-DD.csv`
+
+### 2. `activity-watch-explorer.js` - Data Explorer
+
+**Purpose:** Understand what applications and activities ActivityWatch is tracking
+
+**Example:**
+```bash
+# Explore last 24 hours
+node activity-watch-explorer.js 24
+```
+
+**Use when:** You need to understand how your work is being categorized
+
+### 3. `time-report.js` - Bot Sessions Only
+
+**Purpose:** Report only Claude bot sessions (original utility)
+
+**Example:**
+```bash
+node time-report.js 7 client-project
+```
+
+## What Gets Tracked as WORK
+
+The report automatically includes:
+
+**Development Apps:**
+- jetbrains-phpstorm (PhpStorm)
+- cursor (Cursor editor)
+- Code editors and terminals
+
+**Browser Activities:**
+- Pages with "group client-project" in title
+- Pages with "client-project" in title
+- Claude AI sessions
+- ActivityWatch interface
+
+**Bot Sessions:**
+- All Claude AI assistant interactions through Telegram bot
+
+## Report Output
+
+**Console format:**
+```
+📊 WORK Time Report (last 7 days)
+📅 Daily Breakdown:
+Date       | Bot Sessions | Bot Time | AW Events | AW Time  | Total Time
+2025-08-27 |           13 |     0.76h |       261 |    1.21h |      1.97h
+
+📈 SUMMARY:
+Total Time: 24.84 hours
+Average per day: 3.55 hours/day
+```
+
+**CSV format:** Ready for client billing with detailed breakdown
+
+## Troubleshooting
+
+**No data found:**
+- Check ActivityWatch is running: `curl http://localhost:5600/api/0/info`
+- Verify time range (try shorter period)
+- Use explorer to see what's being tracked
+
+**Missing activities:**
+- Use `activity-watch-explorer.js` to see all tracked apps
+- Update filtering patterns in `activity-time-report.js` if needed
+
+## Quick Commands
+
+```bash
+# Most common: weekly report
+node activity-time-report.js 7
+
+# Monthly report for client billing  
+node activity-time-report.js 30
+
+# Understand current tracking
+node activity-watch-explorer.js 48
+```

ActivityWatchIntegration.js

@@ -1,4 +1,5 @@
 const axios = require('axios');
+const config = require('./config.json');
 
 /**
  * ActivityWatch Integration
@@ -96,9 +97,9 @@ class ActivityWatchIntegration {
                 }
             };
 
-            // Retry mechanism for network issues
+            // Enhanced retry mechanism for network issues
             let response;
-            const maxRetries = 3;
+            const maxRetries = 5;
             let lastError;
 
             for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -108,7 +109,9 @@ class ActivityWatchIntegration {
                         [event],
                         {
                             headers: { 'Content-Type': 'application/json' },
-                            timeout: 5000
+                            timeout: 10000, // Increased timeout
+                            // Add connection keep-alive
+                            httpAgent: new (require('http').Agent)({ keepAlive: true }),
                         }
                     );
                     break; // Success, exit retry loop
@@ -120,13 +123,16 @@ class ActivityWatchIntegration {
                         attemptError.code === 'ECONNRESET' ||
                         attemptError.code === 'ENOTFOUND' ||
                         attemptError.code === 'ETIMEDOUT' ||
+                        attemptError.code === 'ECONNREFUSED' ||
                         attemptError.message.includes('socket hang up') ||
-                        attemptError.message.includes('timeout')
+                        attemptError.message.includes('timeout') ||
+                        attemptError.message.includes('ECONNRESET')
                     );
 
                     if (isRetryable && attempt < maxRetries) {
-                        console.warn(`[ActivityWatch] Recording attempt ${attempt} failed (${attemptError.message}), retrying...`);
-                        await new Promise(resolve => setTimeout(resolve, 1000 * attempt)); // Exponential backoff
+                        const backoffDelay = Math.min(1000 * Math.pow(2, attempt - 1), 5000); // Exponential backoff, max 5s
+                        console.warn(`[ActivityWatch] Main recording attempt ${attempt} failed (${attemptError.message}), retrying in ${backoffDelay}ms...`);
+                        await new Promise(resolve => setTimeout(resolve, backoffDelay));
                         continue;
                     } else {
                         // Not retryable or max retries exceeded
@@ -166,53 +172,76 @@ class ActivityWatchIntegration {
         try {
             const windowBucket = `aw-watcher-window_${this.hostname}`;
 
-            // Create fake window event that looks like a real application
+            // Create fake window event with configured app name for work categorization
+            // Using more generic IT/development-related app names
             const windowEvent = {
                 timestamp: timestamp,
                 duration: durationSeconds,
                 data: {
-                    app: `${projectName.toLowerCase()}-ai-assistant`,
-                    title: `${projectName} AI Assistant - Session ${sessionId?.slice(-8) || 'work'}`
+                    app: config.activityWatch.integration.fakeAppName,
+                    title: `${config.activityWatch.integration.sessionTitleTemplate} - ${projectName} AI Assistant Session ${sessionId?.slice(-8) || 'work'}`
                 }
             };
 
-            // Try to record to window bucket
-            try {
-                await axios.post(
-                    `${this.baseUrl}/buckets/${windowBucket}/events`,
-                    [windowEvent],
-                    {
-                        headers: { 'Content-Type': 'application/json' },
-                        timeout: 5000
-                    }
-                );
-                console.log(`[ActivityWatch] Window event recorded: ${windowEvent.data.app} | ${durationSeconds.toFixed(1)}s`);
-            } catch (error) {
-                // If window bucket doesn't exist, try to create it first
-                if (error.response?.status === 404) {
-                    console.log(`[ActivityWatch] Creating window bucket: ${windowBucket}`);
-                    await axios.post(`${this.baseUrl}/buckets/${windowBucket}`, {
-                        type: 'currentwindow',
-                        client: 'aw-watcher-window',
-                        hostname: this.hostname
-                    });
-                    
-                    // Retry recording after creating bucket
+            // Enhanced retry mechanism for socket issues
+            const maxRetries = 5;
+            let lastError;
+            
+            for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                try {
                     await axios.post(
                         `${this.baseUrl}/buckets/${windowBucket}/events`,
                         [windowEvent],
                         {
                             headers: { 'Content-Type': 'application/json' },
-                            timeout: 5000
+                            timeout: 10000, // Increased timeout
+                            // Add connection keep-alive
+                            httpAgent: new (require('http').Agent)({ keepAlive: true }),
                         }
                     );
-                    console.log(`[ActivityWatch] Window event recorded after bucket creation: ${windowEvent.data.app}`);
-                } else {
-                    throw error;
+                    console.log(`[ActivityWatch] Window event recorded: ${windowEvent.data.app} | ${durationSeconds.toFixed(1)}s | attempt ${attempt}`);
+                    return; // Success, exit function
+                } catch (error) {
+                    lastError = error;
+                    
+                    // Handle bucket creation first
+                    if (error.response?.status === 404 && attempt === 1) {
+                        console.log(`[ActivityWatch] Creating window bucket: ${windowBucket}`);
+                        try {
+                            await axios.post(`${this.baseUrl}/buckets/${windowBucket}`, {
+                                type: 'currentwindow',
+                                client: 'aw-watcher-window',
+                                hostname: this.hostname
+                            }, { timeout: 10000 });
+                            continue; // Retry recording after creating bucket
+                        } catch (bucketError) {
+                            console.warn(`[ActivityWatch] Could not create window bucket: ${bucketError.message}`);
+                        }
+                    }
+                    
+                    // Handle retryable errors
+                    const isRetryable = (
+                        error.code === 'ECONNRESET' ||
+                        error.code === 'ENOTFOUND' ||
+                        error.code === 'ETIMEDOUT' ||
+                        error.code === 'ECONNREFUSED' ||
+                        error.message.includes('socket hang up') ||
+                        error.message.includes('timeout') ||
+                        error.message.includes('ECONNRESET')
+                    );
+                    
+                    if (isRetryable && attempt < maxRetries) {
+                        const backoffDelay = Math.min(1000 * Math.pow(2, attempt - 1), 5000); // Exponential backoff, max 5s
+                        console.warn(`[ActivityWatch] Window event attempt ${attempt} failed (${error.message}), retrying in ${backoffDelay}ms...`);
+                        await new Promise(resolve => setTimeout(resolve, backoffDelay));
+                        continue;
+                    } else {
+                        throw error;
+                    }
                 }
             }
         } catch (error) {
-            console.warn(`[ActivityWatch] Could not record window event: ${error.message}`);
+            console.warn(`[ActivityWatch] Could not record window event after ${maxRetries} attempts: ${error.message}`);
         }
     }