codeusage-cli 0.1.10 → 0.1.11

package/README.md

@@ -1,4 +1,4 @@
-# CodeUsage CLI
+# Codeusage CLI
 
 Track your team's AI coding tool usage with zero friction.
 

package/dist/index.cjs

@@ -21374,10 +21374,12 @@ var toolUsageSchema = exports_external.object({
   name: exports_external.string().min(1),
   count: exports_external.number().int().min(0)
 });
+var fileChangeTypeSchema = exports_external.enum(["created", "modified", "deleted"]);
 var fileChangeDetailSchema = exports_external.object({
   path: exports_external.string().min(1),
   additions: exports_external.number().int().min(0),
-  deletions: exports_external.number().int().min(0)
+  deletions: exports_external.number().int().min(0),
+  change_type: fileChangeTypeSchema
 });
 var toolSourceSchema = exports_external.enum(["claude_code", "codex"]);
 var hookScopeSchema = exports_external.enum(["global", "project"]);
@@ -21391,6 +21393,9 @@ var telemetryPayloadSchema = exports_external.object({
   cache_tokens: exports_external.number().int().min(0),
   cost_usd: exports_external.number().min(0).max(50),
   files_changed: exports_external.number().int().min(0),
+  files_created: exports_external.number().int().min(0),
+  files_modified: exports_external.number().int().min(0),
+  files_deleted: exports_external.number().int().min(0),
   files_changed_details: exports_external.array(fileChangeDetailSchema).default([]),
   tools_used: exports_external.array(toolUsageSchema),
   task_duration_sec: exports_external.number().int().min(0),
@@ -21650,7 +21655,10 @@ async function validateApiKey(apiKey) {
       return { valid: false, error: "Invalid API key" };
     }
     const errorBody = await response.text().catch(() => "");
-    return { valid: false, error: `Unexpected response ${response.status} from ${apiUrl}: ${errorBody}` };
+    return {
+      valid: false,
+      error: `Unexpected response ${response.status} from ${apiUrl}: ${errorBody}`
+    };
   } catch (err) {
     const error = err;
     const cause = error.cause ? ` (cause: ${JSON.stringify(error.cause)})` : "";
@@ -28207,21 +28215,21 @@ var claudeCodeConfig = {
     const s = settings || {};
     s.hooks = s.hooks || {};
     const stopHooks = s.hooks.Stop || [];
-    const hasStopCodeUsage = stopHooks.some((entry) => entry.hooks?.some((h2) => h2.command.startsWith("codeusage")));
-    if (!hasStopCodeUsage) {
+    const hasStopCodeusage = stopHooks.some((entry) => entry.hooks?.some((h2) => h2.command.startsWith("codeusage")));
+    if (!hasStopCodeusage) {
       s.hooks.Stop = [...stopHooks, createClaudeHookEntry("codeusage hook stop --provider claude_code")];
     }
     const postToolHooks = s.hooks.PostToolUse || [];
-    const hasPostToolCodeUsage = postToolHooks.some((entry) => entry.hooks?.some((h2) => h2.command.startsWith("codeusage")));
-    if (!hasPostToolCodeUsage) {
+    const hasPostToolCodeusage = postToolHooks.some((entry) => entry.hooks?.some((h2) => h2.command.startsWith("codeusage")));
+    if (!hasPostToolCodeusage) {
       s.hooks.PostToolUse = [
         ...postToolHooks,
         createClaudeHookEntry("codeusage hook post-tool-use --provider claude_code")
       ];
     }
     const notifHooks = s.hooks.Notification || [];
-    const hasNotifCodeUsage = notifHooks.some((entry) => entry.hooks?.some((h2) => h2.command.startsWith("codeusage")));
-    if (!hasNotifCodeUsage) {
+    const hasNotifCodeusage = notifHooks.some((entry) => entry.hooks?.some((h2) => h2.command.startsWith("codeusage")));
+    if (!hasNotifCodeusage) {
       s.hooks.Notification = [
         ...notifHooks,
         createClaudeHookEntry("codeusage hook notification --provider claude_code")
@@ -28244,7 +28252,7 @@ var claudeCodeConfig = {
     }
     return s;
   },
-  hasCodeUsage: (settings) => {
+  hasCodeusage: (settings) => {
     const s = settings;
     if (!s?.hooks?.Stop)
       return false;
@@ -28262,11 +28270,11 @@ var codexConfig = {
     const s = settings || {};
     s.hooks = s.hooks || {};
     const stopHooks = s.hooks.Stop || [];
-    const hasStopCodeUsage = stopHooks.some((h2) => h2.command.startsWith("codeusage"));
-    if (!hasStopCodeUsage) {
+    const hasStopCodeusage = stopHooks.some((h2) => h2.command.startsWith("codeusage"));
+    if (!hasStopCodeusage) {
       s.hooks.Stop = [
         ...stopHooks,
-        createCodexHookCommand("codeusage hook stop --provider codex", "Syncing to CodeUsage...")
+        createCodexHookCommand("codeusage hook stop --provider codex", "Syncing to Codeusage...")
       ];
     }
     return s;
@@ -28280,7 +28288,7 @@ var codexConfig = {
     }
     return s;
   },
-  hasCodeUsage: (settings) => {
+  hasCodeusage: (settings) => {
     const s = settings;
     if (!s?.hooks?.Stop)
       return false;
@@ -28342,15 +28350,15 @@ async function areHooksRegistered(scope, cwd, providerId = DEFAULT_PROVIDER) {
   try {
     const content = await import_promises12.default.readFile(filePath, "utf-8");
     const settings = JSON.parse(content);
-    return config2.hasCodeUsage(settings);
+    return config2.hasCodeusage(settings);
   } catch {}
   return false;
 }
 
 // src/commands/init.ts
-var initCommand = new Command("init").description("Initialize CodeUsage CLI and connect to your workspace").option("--force", "Reinitialize even if already configured").action(async (options) => {
+var initCommand = new Command("init").description("Initialize Codeusage CLI and connect to your workspace").option("--force", "Reinitialize even if already configured").action(async (options) => {
   console.log(source_default.bold(`
-\uD83D\uDCCA CodeUsage CLI Setup
+\uD83D\uDCCA Codeusage CLI Setup
 `));
   if (isConfigured() && !options.force) {
     const config2 = getConfig();
@@ -28385,7 +28393,7 @@ Selected provider is not available yet.
 Using ${providerInfo.displayName}
 `));
   console.log(source_default.dim(`
-Get your workspace key from the CodeUsage dashboard Settings page.
+Get your workspace key from the Codeusage dashboard Settings page.
 `));
   const workspaceKey = await dist_default5({
     message: "Workspace API key:",
@@ -28451,7 +28459,7 @@ ${err.message}
     project_overrides: {}
   });
   console.log(source_default.green(`
-✅ CodeUsage is ready!
+✅ Codeusage is ready!
 `));
   console.log(source_default.dim(`Your ${providerInfo.displayName} sessions will now be tracked.`));
   console.log(source_default.dim(`View your dashboard at: https://codeusage.dev
@@ -28526,9 +28534,9 @@ async function clearBuffer() {
 }
 
 // src/commands/status.ts
-var statusCommand = new Command("status").description("Show current CodeUsage configuration and connection status").action(async () => {
+var statusCommand = new Command("status").description("Show current Codeusage configuration and connection status").action(async () => {
   console.log(source_default.bold(`
-\uD83D\uDCCA CodeUsage Status
+\uD83D\uDCCA Codeusage Status
 `));
   if (!isConfigured()) {
     console.log(source_default.yellow(`Not configured. Run: codeusage init
@@ -28739,7 +28747,7 @@ ${newProvider.displayName} is coming soon!`));
     console.log(source_default.green(`
 ✓ ${newProvider.displayName} hooks registered!
 `));
-    console.log(source_default.dim(`Both providers are now active. Tasks from either tool will sync to CodeUsage.
+    console.log(source_default.dim(`Both providers are now active. Tasks from either tool will sync to Codeusage.
 `));
   } catch (err) {
     console.log(source_default.red(`
@@ -28836,7 +28844,7 @@ Syncing ${bufferCount} buffered task(s)...
 });
 
 // src/commands/config.ts
-var configCommand = new Command("config").description("View or modify CodeUsage configuration");
+var configCommand = new Command("config").description("View or modify Codeusage configuration");
 configCommand.command("show").description("Show current configuration").action(async () => {
   if (!isConfigured()) {
     console.log(source_default.yellow(`
@@ -28847,7 +28855,7 @@ Not configured. Run: codeusage init
   const config2 = getConfig();
   const enabledProviders = getProviders();
   console.log(source_default.bold(`
-CodeUsage Configuration:
+Codeusage Configuration:
 `));
   const maskedKey = config2.workspace_key.slice(0, 10) + "••••••••••••";
   console.log(`  Workspace Key: ${source_default.dim(maskedKey)}`);
@@ -29071,7 +29079,7 @@ function confirm(question) {
     });
   });
 }
-var logoutCommand = new Command("logout").description("Disconnect from CodeUsage and remove local configuration").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
+var logoutCommand = new Command("logout").description("Disconnect from Codeusage and remove local configuration").option("-f, --force", "Skip confirmation prompt").action(async (options) => {
   if (!isConfigured()) {
     console.log(source_default.dim(`
 Not configured. Nothing to logout from.
@@ -29113,6 +29121,664 @@ Cleaning up...`));
 var import_promises14 = __toESM(require("fs/promises"));
 var import_path4 = __toESM(require("path"));
 var import_os3 = __toESM(require("os"));
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/base.js
+class Diff {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    } else if ("callback" in options) {
+      callback = options.callback;
+    }
+    const oldString = this.castInput(oldStr, options);
+    const newString = this.castInput(newStr, options);
+    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
+    const newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    const done = (value) => {
+      value = this.postProcess(value, options);
+      if (callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return;
+      } else {
+        return value;
+      }
+    };
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let editLength = 1;
+    let maxEditLength = newLen + oldLen;
+    if (options.maxEditLength != null) {
+      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
+    }
+    const maxExecutionTime = (_a = options.timeout) !== null && _a !== undefined ? _a : Infinity;
+    const abortAfterTimestamp = Date.now() + maxExecutionTime;
+    const bestPath = [{ oldPos: -1, lastComponent: undefined }];
+    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
+    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
+    }
+    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
+    const execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength);diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath;
+        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        if (removePath) {
+          bestPath[diagonalPath - 1] = undefined;
+        }
+        let canAdd = false;
+        if (addPath) {
+          const addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
+        if (!canAdd && !canRemove) {
+          bestPath[diagonalPath] = undefined;
+          continue;
+        }
+        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
+          basePath = this.addToPath(addPath, true, false, 0, options);
+        } else {
+          basePath = this.addToPath(removePath, false, true, 1, options);
+        }
+        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
+        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
+        } else {
+          bestPath[diagonalPath] = basePath;
+          if (basePath.oldPos + 1 >= oldLen) {
+            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
+          }
+          if (newPos + 1 >= newLen) {
+            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
+          }
+        }
+      }
+      editLength++;
+    };
+    if (callback) {
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
+            return callback(undefined);
+          }
+          if (!execEditLength()) {
+            exec();
+          }
+        }, 0);
+      })();
+    } else {
+      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
+        const ret = execEditLength();
+        if (ret) {
+          return ret;
+        }
+      }
+    }
+  }
+  addToPath(path13, added, removed, oldPosInc, options) {
+    const last = path13.lastComponent;
+    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
+      return {
+        oldPos: path13.oldPos + oldPosInc,
+        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+      };
+    } else {
+      return {
+        oldPos: path13.oldPos + oldPosInc,
+        lastComponent: { count: 1, added, removed, previousComponent: last }
+      };
+    }
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    const newLen = newTokens.length, oldLen = oldTokens.length;
+    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
+      newPos++;
+      oldPos++;
+      commonCount++;
+      if (options.oneChangePerToken) {
+        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
+      }
+    }
+    if (commonCount && !options.oneChangePerToken) {
+      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    }
+    basePath.oldPos = oldPos;
+    return newPos;
+  }
+  equals(left, right, options) {
+    if (options.comparator) {
+      return options.comparator(left, right);
+    } else {
+      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+    }
+  }
+  removeEmpty(array) {
+    const ret = [];
+    for (let i2 = 0;i2 < array.length; i2++) {
+      if (array[i2]) {
+        ret.push(array[i2]);
+      }
+    }
+    return ret;
+  }
+  castInput(value, options) {
+    return value;
+  }
+  tokenize(value, options) {
+    return Array.from(value);
+  }
+  join(chars) {
+    return chars.join("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return false;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    const components = [];
+    let nextComponent;
+    while (lastComponent) {
+      components.push(lastComponent);
+      nextComponent = lastComponent.previousComponent;
+      delete lastComponent.previousComponent;
+      lastComponent = nextComponent;
+    }
+    components.reverse();
+    const componentLen = components.length;
+    let componentPos = 0, newPos = 0, oldPos = 0;
+    for (;componentPos < componentLen; componentPos++) {
+      const component = components[componentPos];
+      if (!component.removed) {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i2) {
+            const oldValue = oldTokens[oldPos + i2];
+            return oldValue.length > value2.length ? oldValue : value2;
+          });
+          component.value = this.join(value);
+        } else {
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        }
+        newPos += component.count;
+        if (!component.added) {
+          oldPos += component.count;
+        }
+      } else {
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
+        oldPos += component.count;
+      }
+    }
+    return components;
+  }
+}
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/character.js
+class CharacterDiff extends Diff {
+}
+var characterDiff = new CharacterDiff;
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/util/string.js
+function longestCommonPrefix(str1, str2) {
+  let i2;
+  for (i2 = 0;i2 < str1.length && i2 < str2.length; i2++) {
+    if (str1[i2] != str2[i2]) {
+      return str1.slice(0, i2);
+    }
+  }
+  return str1.slice(0, i2);
+}
+function longestCommonSuffix(str1, str2) {
+  let i2;
+  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1]) {
+    return "";
+  }
+  for (i2 = 0;i2 < str1.length && i2 < str2.length; i2++) {
+    if (str1[str1.length - (i2 + 1)] != str2[str2.length - (i2 + 1)]) {
+      return str1.slice(-i2);
+    }
+  }
+  return str1.slice(-i2);
+}
+function replacePrefix(string, oldPrefix, newPrefix) {
+  if (string.slice(0, oldPrefix.length) != oldPrefix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+  }
+  return newPrefix + string.slice(oldPrefix.length);
+}
+function replaceSuffix(string, oldSuffix, newSuffix) {
+  if (!oldSuffix) {
+    return string + newSuffix;
+  }
+  if (string.slice(-oldSuffix.length) != oldSuffix) {
+    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+  }
+  return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+function removePrefix(string, oldPrefix) {
+  return replacePrefix(string, oldPrefix, "");
+}
+function removeSuffix(string, oldSuffix) {
+  return replaceSuffix(string, oldSuffix, "");
+}
+function maximumOverlap(string1, string2) {
+  return string2.slice(0, overlapCount(string1, string2));
+}
+function overlapCount(a2, b) {
+  let startA = 0;
+  if (a2.length > b.length) {
+    startA = a2.length - b.length;
+  }
+  let endB = b.length;
+  if (a2.length < b.length) {
+    endB = a2.length;
+  }
+  const map = Array(endB);
+  let k = 0;
+  map[0] = 0;
+  for (let j = 1;j < endB; j++) {
+    if (b[j] == b[k]) {
+      map[j] = map[k];
+    } else {
+      map[j] = k;
+    }
+    while (k > 0 && b[j] != b[k]) {
+      k = map[k];
+    }
+    if (b[j] == b[k]) {
+      k++;
+    }
+  }
+  k = 0;
+  for (let i2 = startA;i2 < a2.length; i2++) {
+    while (k > 0 && a2[i2] != b[k]) {
+      k = map[k];
+    }
+    if (a2[i2] == b[k]) {
+      k++;
+    }
+  }
+  return k;
+}
+function segment(string, segmenter2) {
+  const parts = [];
+  for (const segmentObj of Array.from(segmenter2.segment(string))) {
+    const segment2 = segmentObj.segment;
+    if (parts.length && /\s/.test(parts[parts.length - 1]) && /\s/.test(segment2)) {
+      parts[parts.length - 1] += segment2;
+    } else {
+      parts.push(segment2);
+    }
+  }
+  return parts;
+}
+function trailingWs(string, segmenter2) {
+  if (segmenter2) {
+    return leadingAndTrailingWs(string, segmenter2)[1];
+  }
+  let i2;
+  for (i2 = string.length - 1;i2 >= 0; i2--) {
+    if (!string[i2].match(/\s/)) {
+      break;
+    }
+  }
+  return string.substring(i2 + 1);
+}
+function leadingWs(string, segmenter2) {
+  if (segmenter2) {
+    return leadingAndTrailingWs(string, segmenter2)[0];
+  }
+  const match = string.match(/^\s*/);
+  return match ? match[0] : "";
+}
+function leadingAndTrailingWs(string, segmenter2) {
+  if (!segmenter2) {
+    return [leadingWs(string), trailingWs(string)];
+  }
+  if (segmenter2.resolvedOptions().granularity != "word") {
+    throw new Error('The segmenter passed must have a granularity of "word"');
+  }
+  const segments = segment(string, segmenter2);
+  const firstSeg = segments[0];
+  const lastSeg = segments[segments.length - 1];
+  const head = /\s/.test(firstSeg) ? firstSeg : "";
+  const tail = /\s/.test(lastSeg) ? lastSeg : "";
+  return [head, tail];
+}
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/word.js
+var extendedWordChars = "a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}";
+var tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
+
+class WordDiff extends Diff {
+  equals(left, right, options) {
+    if (options.ignoreCase) {
+      left = left.toLowerCase();
+      right = right.toLowerCase();
+    }
+    return left.trim() === right.trim();
+  }
+  tokenize(value, options = {}) {
+    let parts;
+    if (options.intlSegmenter) {
+      const segmenter2 = options.intlSegmenter;
+      if (segmenter2.resolvedOptions().granularity != "word") {
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      }
+      parts = segment(value, segmenter2);
+    } else {
+      parts = value.match(tokenizeIncludingWhitespace) || [];
+    }
+    const tokens = [];
+    let prevPart = null;
+    parts.forEach((part) => {
+      if (/\s/.test(part)) {
+        if (prevPart == null) {
+          tokens.push(part);
+        } else {
+          tokens.push(tokens.pop() + part);
+        }
+      } else if (prevPart != null && /\s/.test(prevPart)) {
+        if (tokens[tokens.length - 1] == prevPart) {
+          tokens.push(tokens.pop() + part);
+        } else {
+          tokens.push(prevPart + part);
+        }
+      } else {
+        tokens.push(part);
+      }
+      prevPart = part;
+    });
+    return tokens;
+  }
+  join(tokens) {
+    return tokens.map((token, i2) => {
+      if (i2 == 0) {
+        return token;
+      } else {
+        return token.replace(/^\s+/, "");
+      }
+    }).join("");
+  }
+  postProcess(changes, options) {
+    if (!changes || options.oneChangePerToken) {
+      return changes;
+    }
+    let lastKeep = null;
+    let insertion = null;
+    let deletion = null;
+    changes.forEach((change) => {
+      if (change.added) {
+        insertion = change;
+      } else if (change.removed) {
+        deletion = change;
+      } else {
+        if (insertion || deletion) {
+          dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter);
+        }
+        lastKeep = change;
+        insertion = null;
+        deletion = null;
+      }
+    });
+    if (insertion || deletion) {
+      dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter);
+    }
+    return changes;
+  }
+}
+var wordDiff = new WordDiff;
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter2) {
+  if (deletion && insertion) {
+    const [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter2);
+    const [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter2);
+    if (startKeep) {
+      const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
+      deletion.value = removePrefix(deletion.value, commonWsPrefix);
+      insertion.value = removePrefix(insertion.value, commonWsPrefix);
+    }
+    if (endKeep) {
+      const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
+      deletion.value = removeSuffix(deletion.value, commonWsSuffix);
+      insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+    }
+  } else if (insertion) {
+    if (startKeep) {
+      const ws = leadingWs(insertion.value, segmenter2);
+      insertion.value = insertion.value.substring(ws.length);
+    }
+    if (endKeep) {
+      const ws = leadingWs(endKeep.value, segmenter2);
+      endKeep.value = endKeep.value.substring(ws.length);
+    }
+  } else if (startKeep && endKeep) {
+    const newWsFull = leadingWs(endKeep.value, segmenter2), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter2);
+    const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+    deletion.value = removePrefix(deletion.value, newWsStart);
+    const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+    deletion.value = removeSuffix(deletion.value, newWsEnd);
+    endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
+    startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+  } else if (endKeep) {
+    const endKeepWsPrefix = leadingWs(endKeep.value, segmenter2);
+    const deletionWsSuffix = trailingWs(deletion.value, segmenter2);
+    const overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+    deletion.value = removeSuffix(deletion.value, overlap);
+  } else if (startKeep) {
+    const startKeepWsSuffix = trailingWs(startKeep.value, segmenter2);
+    const deletionWsPrefix = leadingWs(deletion.value, segmenter2);
+    const overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, overlap);
+  }
+}
+
+class WordsWithSpaceDiff extends Diff {
+  tokenize(value) {
+    const regex2 = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
+    return value.match(regex2) || [];
+  }
+}
+var wordsWithSpaceDiff = new WordsWithSpaceDiff;
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/line.js
+class LineDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes(`
+`)) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes(`
+`)) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith(`
+`)) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith(`
+`)) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  }
+}
+var lineDiff = new LineDiff;
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  if (options.stripTrailingCr) {
+    value = value.replace(/\r\n/g, `
+`);
+  }
+  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+    linesAndNewlines.pop();
+  }
+  for (let i2 = 0;i2 < linesAndNewlines.length; i2++) {
+    const line = linesAndNewlines[i2];
+    if (i2 % 2 && !options.newlineIsToken) {
+      retLines[retLines.length - 1] += line;
+    } else {
+      retLines.push(line);
+    }
+  }
+  return retLines;
+}
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/sentence.js
+function isSentenceEndPunct(char) {
+  return char == "." || char == "!" || char == "?";
+}
+
+class SentenceDiff extends Diff {
+  tokenize(value) {
+    var _a;
+    const result = [];
+    let tokenStartI = 0;
+    for (let i2 = 0;i2 < value.length; i2++) {
+      if (i2 == value.length - 1) {
+        result.push(value.slice(tokenStartI));
+        break;
+      }
+      if (isSentenceEndPunct(value[i2]) && value[i2 + 1].match(/\s/)) {
+        result.push(value.slice(tokenStartI, i2 + 1));
+        i2 = tokenStartI = i2 + 1;
+        while ((_a = value[i2 + 1]) === null || _a === undefined ? undefined : _a.match(/\s/)) {
+          i2++;
+        }
+        result.push(value.slice(tokenStartI, i2 + 1));
+        tokenStartI = i2 + 1;
+      }
+    }
+    return result;
+  }
+}
+var sentenceDiff = new SentenceDiff;
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/css.js
+class CssDiff extends Diff {
+  tokenize(value) {
+    return value.split(/([{}:;,]|\s+)/);
+  }
+}
+var cssDiff = new CssDiff;
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/json.js
+class JsonDiff extends Diff {
+  constructor() {
+    super(...arguments);
+    this.tokenize = tokenize;
+  }
+  get useLongestToken() {
+    return true;
+  }
+  castInput(value, options) {
+    const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === "undefined" ? undefinedReplacement : v } = options;
+    return typeof value === "string" ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, "  ");
+  }
+  equals(left, right, options) {
+    return super.equals(left.replace(/,([\r\n])/g, "$1"), right.replace(/,([\r\n])/g, "$1"), options);
+  }
+}
+var jsonDiff = new JsonDiff;
+function canonicalize(obj, stack, replacementStack, replacer, key) {
+  stack = stack || [];
+  replacementStack = replacementStack || [];
+  if (replacer) {
+    obj = replacer(key === undefined ? "" : key, obj);
+  }
+  let i2;
+  for (i2 = 0;i2 < stack.length; i2 += 1) {
+    if (stack[i2] === obj) {
+      return replacementStack[i2];
+    }
+  }
+  let canonicalizedObj;
+  if (Object.prototype.toString.call(obj) === "[object Array]") {
+    stack.push(obj);
+    canonicalizedObj = new Array(obj.length);
+    replacementStack.push(canonicalizedObj);
+    for (i2 = 0;i2 < obj.length; i2 += 1) {
+      canonicalizedObj[i2] = canonicalize(obj[i2], stack, replacementStack, replacer, String(i2));
+    }
+    stack.pop();
+    replacementStack.pop();
+    return canonicalizedObj;
+  }
+  if (obj && obj.toJSON) {
+    obj = obj.toJSON();
+  }
+  if (typeof obj === "object" && obj !== null) {
+    stack.push(obj);
+    canonicalizedObj = {};
+    replacementStack.push(canonicalizedObj);
+    const sortedKeys = [];
+    let key2;
+    for (key2 in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key2)) {
+        sortedKeys.push(key2);
+      }
+    }
+    sortedKeys.sort();
+    for (i2 = 0;i2 < sortedKeys.length; i2 += 1) {
+      key2 = sortedKeys[i2];
+      canonicalizedObj[key2] = canonicalize(obj[key2], stack, replacementStack, replacer, key2);
+    }
+    stack.pop();
+    replacementStack.pop();
+  } else {
+    canonicalizedObj = obj;
+  }
+  return canonicalizedObj;
+}
+
+// ../../node_modules/.bun/diff@8.0.4/node_modules/diff/libesm/diff/array.js
+class ArrayDiff extends Diff {
+  tokenize(value) {
+    return value.slice();
+  }
+  join(value) {
+    return value;
+  }
+  removeEmpty(value) {
+    return value;
+  }
+}
+var arrayDiff = new ArrayDiff;
+
+// src/lib/session-log.ts
+function calculateLineDiff(oldString, newString) {
+  const changes = diffLines(oldString, newString);
+  let additions = 0;
+  let deletions = 0;
+  for (const change of changes) {
+    if (change.added) {
+      additions += change.count ?? 0;
+    } else if (change.removed) {
+      deletions += change.count ?? 0;
+    }
+  }
+  return { additions, deletions };
+}
 async function getGitRoot(cwd) {
   try {
     const { stdout } = await execa("git", ["rev-parse", "--show-toplevel"], {
@@ -29207,14 +29873,12 @@ async function parseClaudeCodeSession(cwd) {
                   if (filePath && typeof filePath === "string") {
                     const oldString = block.input?.old_string || "";
                     const newString = block.input?.new_string || "";
-                    const deletions = oldString.split(`
-`).length;
-                    const additions = newString.split(`
-`).length;
-                    const existing = fileChanges.get(filePath) || { additions: 0, deletions: 0 };
+                    const { additions, deletions } = calculateLineDiff(oldString, newString);
+                    const existing = fileChanges.get(filePath) || { additions: 0, deletions: 0, change_type: "modified" };
                     fileChanges.set(filePath, {
                       additions: existing.additions + additions,
-                      deletions: existing.deletions + deletions
+                      deletions: existing.deletions + deletions,
+                      change_type: existing.change_type
                     });
                   }
                 } else if (block.name === "Write") {
@@ -29223,11 +29887,20 @@ async function parseClaudeCodeSession(cwd) {
                     const content2 = block.input?.content || "";
                     const additions = content2.split(`
 `).length;
-                    const existing = fileChanges.get(filePath) || { additions: 0, deletions: 0 };
-                    fileChanges.set(filePath, {
-                      additions: existing.additions + additions,
-                      deletions: existing.deletions
-                    });
+                    const existing = fileChanges.get(filePath);
+                    if (existing) {
+                      fileChanges.set(filePath, {
+                        additions: existing.additions + additions,
+                        deletions: existing.deletions,
+                        change_type: existing.change_type
+                      });
+                    } else {
+                      fileChanges.set(filePath, {
+                        additions,
+                        deletions: 0,
+                        change_type: "created"
+                      });
+                    }
                   }
                 }
               }
@@ -29241,11 +29914,15 @@ async function parseClaudeCodeSession(cwd) {
       count: count2
     }));
     const duration_sec = startTime && endTime ? Math.round((endTime - startTime) / 1000) : 0;
-    const files_changed_details = Array.from(fileChanges.entries()).map(([path14, stats]) => ({
-      path: path14,
+    const files_changed_details = Array.from(fileChanges.entries()).map(([filePath, stats]) => ({
+      path: filePath,
       additions: stats.additions,
-      deletions: stats.deletions
+      deletions: stats.deletions,
+      change_type: stats.change_type
     }));
+    const files_created = files_changed_details.filter((f) => f.change_type === "created").length;
+    const files_modified = files_changed_details.filter((f) => f.change_type === "modified").length;
+    const files_deleted = files_changed_details.filter((f) => f.change_type === "deleted").length;
     return {
       session_id: sessionId,
       input_tokens: inputTokens,
@@ -29255,6 +29932,9 @@ async function parseClaudeCodeSession(cwd) {
       tools_used,
       tool_counts: toolCounts,
       files_changed: fileChanges.size,
+      files_created,
+      files_modified,
+      files_deleted,
       files_changed_details,
       duration_sec,
       start_time: startTime,
@@ -29306,16 +29986,10 @@ async function findLatestCodexSession() {
   }
   return null;
 }
-function extractCodexSessionId(filename) {
-  const basename = import_path4.default.basename(filename, ".jsonl");
-  const match = basename.match(/rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)/);
-  return match ? match[1] : basename;
-}
-async function parseCodexSession(cwd) {
+async function parseCodexSession(_cwd) {
   const sessionFile = await findLatestCodexSession();
   if (!sessionFile)
     return null;
-  const sessionId = extractCodexSessionId(sessionFile);
   try {
     const content = await import_promises14.default.readFile(sessionFile, "utf-8");
     const lines = content.trim().split(`
@@ -29343,7 +30017,7 @@ async function parseCodexSession(cwd) {
               startIndex: i2,
               startTime: new Date(entry.timestamp).getTime()
             };
-          } else if (payload.type === "task_complete" && payload.turn_id && currentTurn) {
+          } else if (payload.type === "task_complete" && payload.turn_id && currentTurn && currentTurn.turnId) {
             if (currentTurn.turnId === payload.turn_id) {
               turns.push({
                 turnId: currentTurn.turnId,
@@ -29411,12 +30085,13 @@ async function parseCodexSession(cwd) {
             const updateMatches = patchContent.matchAll(/\*\*\* Update File: ([^\n]+)/g);
             for (const match of updateMatches) {
               const filePath = match[1].trim();
-              const existing = fileChanges.get(filePath) || { additions: 0, deletions: 0 };
+              const existing = fileChanges.get(filePath) || { additions: 0, deletions: 0, change_type: "modified" };
               const additions = (patchContent.match(/^\+[^+]/gm) || []).length;
               const deletions = (patchContent.match(/^-[^-]/gm) || []).length;
               fileChanges.set(filePath, {
                 additions: existing.additions + additions,
-                deletions: existing.deletions + deletions
+                deletions: existing.deletions + deletions,
+                change_type: existing.change_type
               });
             }
             const addMatches = patchContent.matchAll(/\*\*\* Add File: ([^\n]+)/g);
@@ -29424,7 +30099,14 @@ async function parseCodexSession(cwd) {
               const filePath = match[1].trim();
               const additions = patchContent.split(`
 `).length || 1;
-              fileChanges.set(filePath, { additions, deletions: 0 });
+              fileChanges.set(filePath, { additions, deletions: 0, change_type: "created" });
+            }
+            const deleteMatches = patchContent.matchAll(/\*\*\* Delete File: ([^\n]+)/g);
+            for (const match of deleteMatches) {
+              const filePath = match[1].trim();
+              const existing = fileChanges.get(filePath);
+              const deletions = existing?.additions || 0;
+              fileChanges.set(filePath, { additions: 0, deletions, change_type: "deleted" });
             }
           }
         }
@@ -29448,8 +30130,12 @@ async function parseCodexSession(cwd) {
     const files_changed_details = Array.from(fileChanges.entries()).map(([filePath, stats]) => ({
       path: filePath,
       additions: stats.additions,
-      deletions: stats.deletions
+      deletions: stats.deletions,
+      change_type: stats.change_type
     }));
+    const files_created = files_changed_details.filter((f) => f.change_type === "created").length;
+    const files_modified = files_changed_details.filter((f) => f.change_type === "modified").length;
+    const files_deleted = files_changed_details.filter((f) => f.change_type === "deleted").length;
     return {
       session_id: lastTurn.turnId,
       input_tokens: inputTokens,
@@ -29459,6 +30145,9 @@ async function parseCodexSession(cwd) {
       tools_used,
       tool_counts: toolCounts,
       files_changed: fileChanges.size,
+      files_created,
+      files_modified,
+      files_deleted,
       files_changed_details,
       duration_sec,
       start_time: lastTurn.startTime,
@@ -29525,6 +30214,9 @@ function calculateDelta(current, previous) {
       output_tokens: current.output_tokens,
       cache_tokens: current.cache_tokens,
       files_changed: current.files_changed,
+      files_created: current.files_created,
+      files_modified: current.files_modified,
+      files_deleted: current.files_deleted,
       files_changed_details: current.files_changed_details,
       tools_used: Object.entries(current.tool_counts).map(([name, count2]) => ({
         name,
@@ -29553,17 +30245,23 @@ function calculateDelta(current, previous) {
         deltaFileDetails.push({
           path: file.path,
           additions: deltaAdditions,
-          deletions: deltaDeletions
+          deletions: deltaDeletions,
+          change_type: file.change_type
         });
       }
     }
   }
-  const filesChangedDelta = deltaFileDetails.length;
+  const filesCreatedDelta = deltaFileDetails.filter((f) => f.change_type === "created").length;
+  const filesModifiedDelta = deltaFileDetails.filter((f) => f.change_type === "modified").length;
+  const filesDeletedDelta = deltaFileDetails.filter((f) => f.change_type === "deleted").length;
   return {
     input_tokens: Math.max(0, current.input_tokens - previous.input_tokens),
     output_tokens: Math.max(0, current.output_tokens - previous.output_tokens),
     cache_tokens: Math.max(0, current.cache_tokens - previous.cache_tokens),
-    files_changed: filesChangedDelta,
+    files_changed: deltaFileDetails.length,
+    files_created: filesCreatedDelta,
+    files_modified: filesModifiedDelta,
+    files_deleted: filesDeletedDelta,
     files_changed_details: deltaFileDetails,
     tools_used: Object.entries(deltaToolCounts).map(([name, count2]) => ({
       name,
@@ -29611,6 +30309,9 @@ var hookStopCommand = new Command("stop").description("Handle AI coding tool sto
     output_tokens: session.output_tokens,
     cache_tokens: session.cache_tokens,
     files_changed: session.files_changed,
+    files_created: session.files_created,
+    files_modified: session.files_modified,
+    files_deleted: session.files_deleted,
     files_changed_details: session.files_changed_details,
     tool_counts: session.tool_counts
   }, previousState);
@@ -29635,6 +30336,9 @@ var hookStopCommand = new Command("stop").description("Handle AI coding tool sto
     cache_tokens: delta.cache_tokens,
     cost_usd: cost,
     files_changed: delta.files_changed,
+    files_created: delta.files_created,
+    files_modified: delta.files_modified,
+    files_deleted: delta.files_deleted,
     files_changed_details: delta.files_changed_details,
     tools_used: delta.tools_used,
     task_duration_sec: taskDuration,
@@ -29654,7 +30358,7 @@ var hookStopCommand = new Command("stop").description("Handle AI coding tool sto
       console.log(`Cache: ${source_default.green(payload.cache_tokens.toLocaleString())} tokens`);
     }
     console.log(`Cost: ${source_default.green(`~$${payload.cost_usd.toFixed(4)}`)}`);
-    console.log(`Files changed: ${source_default.yellow(payload.files_changed)}`);
+    console.log(`Files: ${source_default.yellow(payload.files_changed)} changed (${source_default.green(`+${payload.files_created}`)} created, ${source_default.blue(`~${payload.files_modified}`)} modified, ${source_default.red(`-${payload.files_deleted}`)} deleted)`);
     console.log(`Duration: ${source_default.yellow(payload.task_duration_sec)}s`);
     if (payload.tools_used.length > 0) {
       console.log(`Tools: ${payload.tools_used.map((t) => `${t.name}(${t.count})`).join(", ")}`);
@@ -29676,7 +30380,11 @@ var hookStopCommand = new Command("stop").description("Handle AI coding tool sto
     console.log(source_default.green("✓ Task synced"));
     const file_stats = {};
     for (const file of session.files_changed_details) {
-      file_stats[file.path] = { additions: file.additions, deletions: file.deletions };
+      file_stats[file.path] = {
+        additions: file.additions,
+        deletions: file.deletions,
+        change_type: file.change_type
+      };
     }
     const newState = {
       session_id: session.session_id,
@@ -29684,6 +30392,9 @@ var hookStopCommand = new Command("stop").description("Handle AI coding tool sto
       output_tokens: session.output_tokens,
       cache_tokens: session.cache_tokens,
       files_changed: session.files_changed,
+      files_created: session.files_created,
+      files_modified: session.files_modified,
+      files_deleted: session.files_deleted,
       file_stats,
       tool_counts: session.tool_counts,
       last_timestamp: session.end_time || Date.now(),
@@ -29698,7 +30409,11 @@ var hookStopCommand = new Command("stop").description("Handle AI coding tool sto
     await bufferTask(payload);
     const bufferedFileStats = {};
     for (const file of session.files_changed_details) {
-      bufferedFileStats[file.path] = { additions: file.additions, deletions: file.deletions };
+      bufferedFileStats[file.path] = {
+        additions: file.additions,
+        deletions: file.deletions,
+        change_type: file.change_type
+      };
     }
     const newState = {
       session_id: session.session_id,
@@ -29706,6 +30421,9 @@ var hookStopCommand = new Command("stop").description("Handle AI coding tool sto
       output_tokens: session.output_tokens,
       cache_tokens: session.cache_tokens,
       files_changed: session.files_changed,
+      files_created: session.files_created,
+      files_modified: session.files_modified,
+      files_deleted: session.files_deleted,
       file_stats: bufferedFileStats,
       tool_counts: session.tool_counts,
       last_timestamp: session.end_time || Date.now(),
@@ -29723,7 +30441,7 @@ var hookNotificationCommand = new Command("notification").description("Handle Cl
 
 // src/index.ts
 var program2 = new Command;
-program2.name("codeusage").description("CLI for CodeUsage - AI coding tool intelligence platform").version("0.1.8");
+program2.name("codeusage").description("CLI for Codeusage - AI coding tool intelligence platform").version("0.1.8");
 program2.addCommand(initCommand);
 program2.addCommand(statusCommand);
 program2.addCommand(projectCommand);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codeusage-cli",
-  "version": "0.1.10",
-  "description": "CLI for CodeUsage - AI coding tool intelligence platform",
+  "version": "0.1.11",
+  "description": "CLI for Codeusage - AI coding tool intelligence platform",
   "author": "Hashim",
   "license": "MIT",
   "type": "module",
@@ -25,12 +25,14 @@
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "conf": "^13.1.0",
+    "diff": "^8.0.4",
     "execa": "^9.5.2",
     "ora": "^8.2.0",
     "zod": "^3.25.76"
   },
   "devDependencies": {
     "@codeusage/shared": "workspace:*",
+    "@types/diff": "^8.0.0",
     "@types/node": "^20.19.0",
     "tsup": "^8.5.0",
     "tsx": "^4.19.0",