claude-code-wakatime 3.0.2 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-wakatime",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "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)) {

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;
+  };
+};

package/src/utils.ts

@@ -2,96 +2,143 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as child_process from 'child_process';
 import { StdioOptions } from 'child_process';
+import { Input, State, TranscriptLog } from './types';
+import path from 'path';
+import { logger } from './logger';
 
-export class Utils {
-  public static quote(str: string): string {
-    if (str.includes(' ')) return `"${str.replace('"', '\\"')}"`;
-    return str;
-  }
+const STATE_FILE = path.join(os.homedir(), '.wakatime', 'claude-code.json');
 
-  public static apiKeyInvalid(key?: string): string {
-    const err = 'Invalid api key... check https://wakatime.com/api-key for your key';
-    if (!key) return err;
-    const re = new RegExp('^(waka_)?[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$', 'i');
-    if (!re.test(key)) return err;
-    return '';
+export 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;
+}
 
-  public static formatDate(date: Date): String {
-    let months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-    let ampm = 'AM';
-    let hour = date.getHours();
-    if (hour > 11) {
-      ampm = 'PM';
-      hour = hour - 12;
-    }
-    if (hour == 0) {
-      hour = 12;
-    }
-    let minute = date.getMinutes();
-    return `${months[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()} ${hour}:${minute < 10 ? `0${minute}` : minute} ${ampm}`;
+export function shouldSendHeartbeat(inp?: Input): boolean {
+  if (inp?.hook_event_name === 'Stop') {
+    return true;
   }
 
-  public static obfuscateKey(key: string): string {
-    let newKey = '';
-    if (key) {
-      newKey = key;
-      if (key.length > 4) newKey = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXX' + key.substring(key.length - 4);
-    }
-    return newKey;
+  try {
+    const last = (JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')) as State).lastHeartbeatAt ?? timestamp();
+    return timestamp() - last >= 60;
+  } catch {
+    return true;
   }
+}
+
+export function updateState() {
+  fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
+  fs.writeFileSync(STATE_FILE, JSON.stringify({ lastHeartbeatAt: timestamp() } as State, null, 2));
+}
 
-  public static wrapArg(arg: string): string {
-    if (arg.indexOf(' ') > -1) return '"' + arg.replace(/"/g, '\\"') + '"';
-    return arg;
+export function getEntityFiles(inp: Input | undefined): { entities: Map<string, number>; claudeVersion: string } {
+  const entities = new Map<string, number>();
+  let claudeVersion = '';
+
+  const transcriptPath = inp?.transcript_path;
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    return { entities, claudeVersion };
   }
 
-  public static formatArguments(binary: string, args: string[]): string {
-    let clone = args.slice(0);
-    clone.unshift(this.wrapArg(binary));
-    let newCmds: string[] = [];
-    let lastCmd = '';
-    for (let i = 0; i < clone.length; i++) {
-      if (lastCmd == '--key') newCmds.push(this.wrapArg(this.obfuscateKey(clone[i])));
-      else newCmds.push(this.wrapArg(clone[i]));
-      lastCmd = clone[i];
+  const lastHeartbeatAt = getLastHeartbeat();
+
+  const content = fs.readFileSync(transcriptPath, 'utf-8');
+  for (const logLine of content.split('\n')) {
+    if (!logLine.trim()) continue;
+
+    try {
+      const log = JSON.parse(logLine) as TranscriptLog;
+      if (!log.timestamp) continue;
+
+      if (log.version) claudeVersion = log.version;
+
+      const timestamp = new Date(log.timestamp).getTime() / 1000;
+      if (timestamp < lastHeartbeatAt) continue;
+
+      const filePath = log.toolUseResult?.filePath;
+      if (!filePath) continue;
+
+      const patches = log.toolUseResult?.structuredPatch;
+      if (!patches) continue;
+
+      const lineChanges = patches.map((patch) => patch.newLines - patch.oldLines).reduce((p, c) => p + c, 0);
+
+      entities.set(filePath, (entities.get(filePath) ?? 0) + lineChanges);
+    } catch (err) {
+      logger.warnException(err);
     }
-    return newCmds.join(' ');
   }
 
-  public static apiUrlToDashboardUrl(url: string): string {
-    url = url
-      .replace('://api.', '://')
-      .replace('/api/v1', '')
-      .replace(/^api\./, '')
-      .replace('/api', '');
-    return url;
-  }
+  return { entities, claudeVersion };
+}
 
-  public static isWindows(): boolean {
-    return os.platform() === 'win32';
+export function formatArguments(binary: string, args: string[]): string {
+  let clone = args.slice(0);
+  clone.unshift(wrapArg(binary));
+  let newCmds: string[] = [];
+  let lastCmd = '';
+  for (let i = 0; i < clone.length; i++) {
+    if (lastCmd == '--key') newCmds.push(wrapArg(obfuscateKey(clone[i])));
+    else newCmds.push(wrapArg(clone[i]));
+    lastCmd = clone[i];
   }
+  return newCmds.join(' ');
+}
 
-  public static getHomeDirectory(): string {
-    let home = process.env.WAKATIME_HOME;
-    if (home && home.trim() && fs.existsSync(home.trim())) return home.trim();
-    return process.env[this.isWindows() ? 'USERPROFILE' : 'HOME'] || process.cwd();
+export function isWindows(): boolean {
+  return os.platform() === 'win32';
+}
+
+export function getHomeDirectory(): string {
+  let home = process.env.WAKATIME_HOME;
+  if (home && home.trim() && fs.existsSync(home.trim())) return home.trim();
+  return process.env[isWindows() ? 'USERPROFILE' : 'HOME'] || process.cwd();
+}
+
+export function buildOptions(stdin?: boolean): Object {
+  const options: child_process.ExecFileOptions = {
+    windowsHide: true,
+  };
+  if (stdin) {
+    (options as any).stdio = ['pipe', 'pipe', 'pipe'] as StdioOptions;
+  }
+  if (!isWindows() && !process.env.WAKATIME_HOME && !process.env.HOME) {
+    options['env'] = { ...process.env, WAKATIME_HOME: getHomeDirectory() };
   }
+  return options;
+}
 
-  public static buildOptions(stdin?: boolean): Object {
-    const options: child_process.ExecFileOptions = {
-      windowsHide: true,
-    };
-    if (stdin) {
-      (options as any).stdio = ['pipe', 'pipe', 'pipe'] as StdioOptions;
-    }
-    if (!this.isWindows() && !process.env.WAKATIME_HOME && !process.env.HOME) {
-      options['env'] = { ...process.env, WAKATIME_HOME: this.getHomeDirectory() };
-    }
-    return options;
+function getLastHeartbeat() {
+  try {
+    const stateData = JSON.parse(fs.readFileSync(STATE_FILE, 'utf-8')) as State;
+    return stateData.lastHeartbeatAt ?? 0;
+  } catch {
+    return 0;
   }
+}
+
+function timestamp() {
+  return Date.now() / 1000;
+}
+
+function wrapArg(arg: string): string {
+  if (arg.indexOf(' ') > -1) return '"' + arg.replace(/"/g, '\\"') + '"';
+  return arg;
+}
 
-  public static timestamp() {
-    return Date.now() / 1000;
+function obfuscateKey(key: string): string {
+  let newKey = '';
+  if (key) {
+    newKey = key;
+    if (key.length > 4) newKey = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXX' + key.substring(key.length - 4);
   }
+  return newKey;
 }