claude-code-wakatime 3.0.1 → 3.0.3

package/dist/install-hooks.js

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/install-hooks.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var CLAUDE_SETTINGS = import_path.default.join(import_os.default.homedir(), ".claude", "settings.json");
+var HOOK_EVENTS = ["PreToolUse", "PostToolUse", "SessionEnd", "UserPromptSubmit", "PreCompact", "SubagentStop", "Stop"];
+function loadSettings() {
+  if (!import_fs.default.existsSync(CLAUDE_SETTINGS)) {
+    return {};
+  }
+  return JSON.parse(import_fs.default.readFileSync(CLAUDE_SETTINGS, "utf-8"));
+}
+function saveSettings(settings) {
+  import_fs.default.mkdirSync(import_path.default.dirname(CLAUDE_SETTINGS), { recursive: true });
+  import_fs.default.writeFileSync(CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
+}
+function installHooks() {
+  const settings = loadSettings();
+  settings.hooks = settings.hooks || {};
+  const hook = {
+    matcher: "*",
+    hooks: [
+      {
+        type: "command",
+        command: "claude-code-wakatime"
+      }
+    ]
+  };
+  let hookAlreadyExists = true;
+  for (const event of HOOK_EVENTS) {
+    settings.hooks[event] = settings.hooks[event] || [];
+    const existingHook = settings.hooks[event].find(
+      (existingHook2) => existingHook2.hooks && Array.isArray(existingHook2.hooks) && existingHook2.hooks.some((hookItem) => hookItem.command === "claude-code-wakatime")
+    );
+    if (!existingHook) {
+      settings.hooks[event].push(hook);
+      hookAlreadyExists = false;
+    }
+  }
+  if (hookAlreadyExists) {
+    console.log(`WakaTime hooks already installed in Claude ${CLAUDE_SETTINGS}`);
+  } else {
+    saveSettings(settings);
+    console.log(`WakaTime hooks installed in Claude ${CLAUDE_SETTINGS}`);
+  }
+}
+installHooks();

package/hooks/hooks.json

@@ -1,16 +1,5 @@
 {
   "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node ${CLAUDE_PLUGIN_ROOT}/dist/index.js"
-          }
-        ]
-      }
-    ],
     "SessionEnd": [
       {
         "matcher": "",
@@ -89,4 +78,4 @@
       }
     ]
   }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-wakatime",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "WakaTime plugin for Claude Code",
   "bin": {
     "claude-code-wakatime": "dist/index.js"
@@ -8,7 +8,8 @@
   "scripts": {
     "postinstall": "node dist/install-hooks.js",
     "prebuild": "node scripts/generate-version.js",
-    "build": "esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js",
+    "build:legacy": "esbuild src/install-hooks.ts --bundle --platform=node --outfile=dist/install-hooks.js",
+    "build": "npm run build:legacy && esbuild src/index.ts --bundle --platform=node --outfile=dist/index.js",
     "watch": "npm run prebuild && tsc --watch",
     "release:major": "npm run build && npm version major && npm publish && git push && git push --tags",
     "release:minor": "npm run build && npm version minor && npm publish && git push && git push --tags",

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,196 +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 WAKATIME_CLI = path.join(os.homedir(), '.wakatime', 'wakatime-cli');
-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();
+
+  for (const [entity, lineChanges] of entities.entries()) {
+    logger.debug(`Entity: ${entity}`);
     const args: string[] = [
       '--entity',
       entity,
@@ -199,57 +28,49 @@ 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: ${args}`);
+    logger.debug(`Sending heartbeat: ${formatArguments(wakatime_cli, args)}`);
 
-    const options = Utils.buildOptions();
-    execFile(WAKATIME_CLI, args, options, (error, stdout, stderr) => {
+    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() {
   const inp = parseInput();
 
-  const options = new Options();
   const debug = options.getSetting('settings', 'debug');
   logger.setLevel(debug === 'true' ? LogLevel.DEBUG : LogLevel.INFO);
-  const deps = new Dependencies(options, logger);
 
-  if (inp) {
-    try {
-      logger.debug(JSON.stringify(inp, null, 2));
-    } catch (err) {
-      // ignore
-    }
-  }
+  try {
+    if (inp) logger.debug(JSON.stringify(inp, null, 2));
 
-  if (inp?.hook_event_name === 'SessionStart') {
     deps.checkAndInstallCli();
-  }
 
-  if (shouldSendHeartbeat(inp)) {
-    sendHeartbeat(inp);
-    updateState();
+    if (shouldSendHeartbeat(inp)) {
+      if (sendHeartbeat(inp)) {
+        updateState();
+      }
+    }
+  } catch (err) {
+    logger.errorException(err);
   }
 }
 

package/src/install-hooks.ts

@@ -3,16 +3,7 @@ import path from 'path';
 import os from 'os';
 
 const CLAUDE_SETTINGS = path.join(os.homedir(), '.claude', 'settings.json');
-const HOOK_EVENTS = [
-  'PreToolUse',
-  'PostToolUse',
-  'SessionStart',
-  'SessionEnd',
-  'UserPromptSubmit',
-  'PreCompact',
-  'SubagentStop',
-  'Stop',
-];
+const HOOK_EVENTS = ['PreToolUse', 'PostToolUse', 'SessionEnd', 'UserPromptSubmit', 'PreCompact', 'SubagentStop', 'Stop'];
 
 function loadSettings(): any {
   if (!fs.existsSync(CLAUDE_SETTINGS)) {

package/src/logger.ts

@@ -1,7 +1,6 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
-import { Utils } from './utils';
 
 export enum LogLevel {
   DEBUG = 0,
@@ -75,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;
+  };
+};