claude-code-wakatime 3.0.2 → 3.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-wakatime",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "WakaTime plugin for Claude Code",
   "bin": {
     "claude-code-wakatime": "dist/index.js"

package/src/dependencies.ts

@@ -8,8 +8,8 @@ import * as semver from 'semver';
 import * as which from 'which';
 
 import { Options, Setting } from './options';
-import { Utils } from './utils';
 import { Logger } from './logger';
+import { buildOptions, isWindows } from './utils';
 
 enum osName {
   darwin = 'darwin',
@@ -49,7 +49,7 @@ export class Dependencies {
 
     const osname = this.osName();
     const arch = this.architecture();
-    const ext = Utils.isWindows() ? '.exe' : '';
+    const ext = isWindows() ? '.exe' : '';
     const binary = `wakatime-cli-${osname}-${arch}${ext}`;
     this.cliLocation = path.join(this.resourcesLocation, binary);
 
@@ -59,7 +59,7 @@ export class Dependencies {
   public getCliLocationGlobal(): string | undefined {
     if (this.cliLocationGlobal) return this.cliLocationGlobal;
 
-    const binaryName = `wakatime-cli${Utils.isWindows() ? '.exe' : ''}`;
+    const binaryName = `wakatime-cli${isWindows() ? '.exe' : ''}`;
     const path = which.sync(binaryName, { nothrow: true });
     if (path) {
       this.cliLocationGlobal = path;
@@ -96,10 +96,10 @@ export class Dependencies {
     }
 
     let args = ['--version'];
-    const options = Utils.buildOptions();
+    const options = buildOptions();
     try {
       child_process.execFile(this.getCliLocation(), args, options, (error, _stdout, stderr) => {
-        if (!(error != null)) {
+        if (!error) {
           let currentVersion = _stdout.toString().trim() + stderr.toString().trim();
           this.logger.debug(`Current wakatime-cli version is ${currentVersion}`);
 
@@ -212,7 +212,7 @@ export class Dependencies {
     this.unzip(zipFile, this.resourcesLocation, (unzipped) => {
       if (!unzipped) {
         this.restoreCli();
-      } else if (!Utils.isWindows()) {
+      } else if (!isWindows()) {
         this.removeCli();
         const cli = this.getCliLocation();
         try {
@@ -221,7 +221,7 @@ export class Dependencies {
         } catch (e) {
           this.logger.warnException(e);
         }
-        const ext = Utils.isWindows() ? '.exe' : '';
+        const ext = isWindows() ? '.exe' : '';
         const link = path.join(this.resourcesLocation, `wakatime-cli${ext}`);
         if (!this.isSymlink(link)) {
           try {
@@ -288,7 +288,7 @@ export class Dependencies {
       });
     } catch (e) {
       this.logger.warnException(e);
-      callback();
+      error();
     }
   }
 

package/src/index.ts

@@ -1,199 +1,25 @@
 #!/usr/bin/env node
 
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
 import { execFile } from 'child_process';
 import { Options } from './options';
 import { VERSION } from './version';
 import { Dependencies } from './dependencies';
-import { Utils } from './utils';
-import { Logger, LogLevel } from './logger';
+import { logger, Logger, LogLevel } from './logger';
+import { Input } from './types';
+import { buildOptions, formatArguments, getEntityFiles, parseInput, shouldSendHeartbeat, updateState } from './utils';
 
-const STATE_FILE = path.join(os.homedir(), '.wakatime', 'claude-code.json');
-const logger = new Logger();
 const options = new Options();
 const deps = new Dependencies(options, logger);
 
-type State = {
-  lastHeartbeatAt?: number;
-};
-
-type Input = {
-  session_id: string;
-  transcript_path: string;
-  cwd: string;
-  hook_event_name: string;
-};
-
-function shouldSendHeartbeat(inp?: Input): boolean {
-  if (inp?.hook_event_name === 'Stop') {
-    return true;
-  }
-
-  try {
-    const last = (JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')) as State).lastHeartbeatAt ?? Utils.timestamp();
-    return Utils.timestamp() - last >= 60;
-  } catch {
-    return true;
-  }
-}
-
-function parseInput() {
-  try {
-    const stdinData = fs.readFileSync(0, 'utf-8');
-    if (stdinData.trim()) {
-      const input: Input = JSON.parse(stdinData);
-      return input;
-    }
-  } catch (err) {
-    console.error(err);
-  }
-  return undefined;
-}
-
-function getLastHeartbeat() {
-  try {
-    const stateData = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')) as State;
-    return stateData.lastHeartbeatAt ?? 0;
-  } catch {
-    return 0;
-  }
-}
-
-function getModifiedFile(transcriptPath: string): string | undefined {
-  try {
-    if (!transcriptPath || !fs.existsSync(transcriptPath)) {
-      return undefined;
-    }
-
-    const content = fs.readFileSync(transcriptPath, 'utf-8');
-    const lines = content.split('\n');
-    const fileLineChanges = new Map<string, number>();
-
-    const lastHeartbeatAt = getLastHeartbeat();
-    for (const line of lines) {
-      if (line.trim()) {
-        try {
-          const logEntry = JSON.parse(line);
-          if (!logEntry.timestamp) continue;
-
-          const entryTimestamp = new Date(logEntry.timestamp).getTime() / 1000;
-          if (entryTimestamp >= lastHeartbeatAt) {
-            let filePath: string | undefined;
-
-            // Check for file paths in tool use results
-            if (logEntry.toolUse?.parameters?.file_path) {
-              filePath = logEntry.toolUse.parameters.file_path;
-            }
-
-            // Check for file paths in tool use results for multi-edit
-            if (logEntry.toolUse?.parameters?.edits) {
-              filePath = logEntry.toolUse.parameters.file_path;
-            }
-
-            // Check for file paths and line changes in structured patch
-            if (logEntry.toolUseResult?.structuredPatch) {
-              const patches = logEntry.toolUseResult.structuredPatch;
-              for (const patch of patches) {
-                if (patch.file) {
-                  filePath = patch.file as string;
-                  if (patch.newLines !== undefined && patch.oldLines !== undefined) {
-                    const lineChanges = Math.abs(patch.newLines - patch.oldLines);
-                    fileLineChanges.set(filePath, (fileLineChanges.get(filePath) || 0) + lineChanges);
-                  }
-                }
-              }
-            }
-
-            if (filePath && !fileLineChanges.has(filePath)) {
-              fileLineChanges.set(filePath, 0);
-            }
-          }
-        } catch {
-          // ignore
-        }
-      }
-    }
-
-    if (fileLineChanges.size === 0) {
-      return undefined;
-    }
-
-    // Find file with most line changes
-    let maxChanges = 0;
-    let mostChangedFile: string | undefined;
-    for (const [file, changes] of fileLineChanges.entries()) {
-      if (changes > maxChanges) {
-        maxChanges = changes;
-        mostChangedFile = file;
-      }
-    }
-
-    return mostChangedFile;
-  } catch {
-    return undefined;
-  }
-}
-
-function calculateLineChanges(transcriptPath: string): number {
-  try {
-    if (!transcriptPath || !fs.existsSync(transcriptPath)) {
-      return 0;
-    }
-
-    const content = fs.readFileSync(transcriptPath, 'utf-8');
-    const lines = content.split('\n');
-    let totalLineChanges = 0;
-
-    const lastHeartbeatAt = getLastHeartbeat();
-    for (const line of lines) {
-      if (line.trim()) {
-        try {
-          const logEntry = JSON.parse(line);
-
-          // Only count changes since last heartbeat
-          if (logEntry.timestamp && logEntry.toolUseResult?.structuredPatch) {
-            const entryTimestamp = new Date(logEntry.timestamp).getTime() / 1000;
-            if (entryTimestamp >= lastHeartbeatAt) {
-              const patches = logEntry.toolUseResult.structuredPatch;
-              for (const patch of patches) {
-                if (patch.newLines !== undefined && patch.oldLines !== undefined) {
-                  totalLineChanges += patch.newLines - patch.oldLines;
-                }
-              }
-            }
-          }
-        } catch {
-          // ignore
-        }
-      }
-    }
-
-    return totalLineChanges;
-  } catch {
-    return 0;
-  }
-}
-
-function updateState() {
-  fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
-  fs.writeFileSync(STATE_FILE, JSON.stringify({ lastHeartbeatAt: Utils.timestamp() } as State, null, 2));
-}
-
-function getEntityFile(inp: Input | undefined): string | undefined {
-  if (!inp?.transcript_path) return;
-  return getModifiedFile(inp.transcript_path);
-}
-
-function sendHeartbeat(inp: Input | undefined) {
+function sendHeartbeat(inp: Input | undefined): boolean {
   const projectFolder = inp?.cwd;
-  try {
-    const entity = getEntityFile(inp);
-    if (!entity) return;
+  const { entities, claudeVersion } = getEntityFiles(inp);
+  if (entities.size === 0) return false;
 
-    const wakatime_cli = deps.getCliLocation();
+  const wakatime_cli = deps.getCliLocation();
 
+  for (const [entity, lineChanges] of entities.entries()) {
+    logger.debug(`Entity: ${entity}`);
     const args: string[] = [
       '--entity',
       entity,
@@ -202,32 +28,29 @@ function sendHeartbeat(inp: Input | undefined) {
       '--category',
       'ai coding',
       '--plugin',
-      `claude-code-wakatime/${VERSION}`,
+      `claude/${claudeVersion} claude-code-wakatime/${VERSION}`,
     ];
     if (projectFolder) {
       args.push('--project-folder');
       args.push(projectFolder);
     }
 
-    if (inp?.transcript_path) {
-      const lineChanges = calculateLineChanges(inp.transcript_path);
-      if (lineChanges) {
-        args.push('--ai-line-changes');
-        args.push(lineChanges.toString());
-      }
+    if (lineChanges) {
+      args.push('--ai-line-changes');
+      args.push(lineChanges.toString());
     }
 
-    logger.debug(`Sending heartbeat: ${wakatime_cli} ${args}`);
+    logger.debug(`Sending heartbeat: ${formatArguments(wakatime_cli, args)}`);
 
-    const execOptions = Utils.buildOptions();
+    const execOptions = buildOptions();
     execFile(wakatime_cli, args, execOptions, (error, stdout, stderr) => {
       const output = stdout.toString().trim() + stderr.toString().trim();
       if (output) logger.error(output);
       if (error) logger.error(error.toString());
     });
-  } catch (err: any) {
-    logger.errorException(err);
   }
+
+  return true;
 }
 
 function main() {
@@ -236,19 +59,18 @@ function main() {
   const debug = options.getSetting('settings', 'debug');
   logger.setLevel(debug === 'true' ? LogLevel.DEBUG : LogLevel.INFO);
 
-  if (inp) {
-    try {
-      logger.debug(JSON.stringify(inp, null, 2));
-    } catch (err) {
-      // ignore
-    }
-  }
+  try {
+    if (inp) logger.debug(JSON.stringify(inp, null, 2));
 
-  deps.checkAndInstallCli();
+    deps.checkAndInstallCli();
 
-  if (shouldSendHeartbeat(inp)) {
-    sendHeartbeat(inp);
-    updateState();
+    if (shouldSendHeartbeat(inp)) {
+      if (sendHeartbeat(inp)) {
+        updateState();
+      }
+    }
+  } catch (err) {
+    logger.errorException(err);
   }
 }
 

package/src/logger.ts

@@ -74,3 +74,11 @@ export class Logger {
     }
   }
 }
+
+const global = globalThis as unknown as {
+  logger: Logger | undefined;
+};
+
+export const logger = global.logger ?? new Logger();
+
+global.logger = logger;

package/src/options.ts

@@ -1,8 +1,7 @@
 import * as child_process from 'child_process';
 import * as fs from 'fs';
 import * as path from 'path';
-
-import { Utils } from './utils';
+import { getHomeDirectory } from './utils';
 
 export interface Setting {
   key: string;
@@ -17,7 +16,7 @@ export class Options {
   public resourcesLocation: string;
 
   constructor() {
-    const home = Utils.getHomeDirectory();
+    const home = getHomeDirectory();
     const wakaFolder = path.join(home, '.wakatime');
     try {
       if (!fs.existsSync(wakaFolder)) {
@@ -35,26 +34,30 @@ export class Options {
   }
 
   public getSetting(section: string, key: string, internal?: boolean): string | undefined {
-    const content = fs.readFileSync(this.getConfigFile(internal ?? false), 'utf-8');
-    if (content.trim()) {
-      let currentSection = '';
-      let lines = content.split('\n');
-      for (var i = 0; i < lines.length; i++) {
-        let line = lines[i];
-        if (this.startsWith(line.trim(), '[') && this.endsWith(line.trim(), ']')) {
-          currentSection = line
-            .trim()
-            .substring(1, line.trim().length - 1)
-            .toLowerCase();
-        } else if (currentSection === section) {
-          let parts = line.split('=');
-          let currentKey = parts[0].trim();
-          if (currentKey === key && parts.length > 1) {
-            return this.removeNulls(parts[1].trim());
+    try {
+      const content = fs.readFileSync(this.getConfigFile(internal ?? false), 'utf-8');
+      if (content.trim()) {
+        let currentSection = '';
+        let lines = content.split('\n');
+        for (var i = 0; i < lines.length; i++) {
+          let line = lines[i];
+          if (this.startsWith(line.trim(), '[') && this.endsWith(line.trim(), ']')) {
+            currentSection = line
+              .trim()
+              .substring(1, line.trim().length - 1)
+              .toLowerCase();
+          } else if (currentSection === section) {
+            let parts = line.split('=');
+            let currentKey = parts[0].trim();
+            if (currentKey === key && parts.length > 1) {
+              return this.removeNulls(parts[1].trim());
+            }
           }
         }
-      }
 
+        return undefined;
+      }
+    } catch (_) {
       return undefined;
     }
   }

package/src/types.ts

@@ -0,0 +1,50 @@
+export type State = {
+  lastHeartbeatAt?: number;
+};
+
+export type Input = {
+  session_id: string;
+  transcript_path: string;
+  cwd: string;
+  hook_event_name: string;
+};
+
+export type TranscriptLog = {
+  parentUuid?: string;
+  isSidechain?: boolean;
+  userType?: string;
+  cwd?: string;
+  sessionId?: string;
+  version?: string;
+  gitBranch?: string;
+  type?: string;
+  message?: {
+    role?: string;
+    content?: [
+      {
+        tool_use_id: string;
+        type: string;
+        content: string;
+      },
+    ];
+  };
+  uuid?: string;
+  timestamp?: string;
+  toolUseResult: {
+    filePath?: string;
+    oldString?: string;
+    newString?: string;
+    originalFile?: string;
+    structuredPatch?: [
+      {
+        oldStart: number;
+        oldLines: number;
+        newStart: number;
+        newLines: number;
+        lines: string[];
+      },
+    ];
+    userModified?: string;
+    replaceAll?: string;
+  };
+};