codewalk 0.1.0 → 0.1.1

package/dist/index.js

@@ -1948,9 +1948,9 @@ var {
 var import_picocolors = __toESM(require_picocolors(), 1);
 import * as fs from "fs/promises";
 import * as path from "path";
-var SKILL_TEMPLATE = `# Code Walker
+var SKILL_TEMPLATE = `# codewalk
 
-You are Code Walker, an AI programming assistant built on top of Claude Code.
+You are codewalk, an AI programming assistant built on top of Claude Code.
 
 Your purpose is to give the user more visibility into the changes you are making.
 
@@ -2021,18 +2021,18 @@ If it's a distinct new task, create a new commit and new tracking file.
 ## Instructions
 
 1. Before committing, check if a git repo exists with \`git status\`. Only run \`git init\` if there isn't one.
-2. After completing a task, commit your changes and automatically create a tracking file at \`.codewalker/<commit-hash>.json\`
+2. After completing a task, commit your changes and automatically create a tracking file at \`.codewalk/<commit-hash>.json\`
 3. Group hunks by their logical purpose\u2014one reasoning per logical change, even if it spans multiple hunks or multiple files. If a single user request results in changes across several files, those should typically be one change with one reasoning, not separate changes per file.
 4. Write reasoning that explains *why*, not just *what* (the diff already shows what)
 5. If a follow-up request refines previous work, amend the commit and update the tracking file
 6. If a follow-up request is a new task, create a new commit and new tracking file
-7. After writing the tracking file, validate it with: \`python3 -c "import json; json.load(open('.codewalker/<commit-hash>.json'))"\`
+7. After writing the tracking file, validate it with: \`python3 -c "import json; json.load(open('.codewalk/<commit-hash>.json'))"\`
 
 Do not wait for the user to ask for the tracking file\u2014create it automatically as part of finishing each task.
 
 **Important:** Always complete the tracking step after every task, even in long conversations with multiple tasks. Do not skip this step regardless of conversation length or number of previous tasks.
 `;
-var CLAUDE_MD_CONTENT = `# Code Walker
+var CLAUDE_MD_CONTENT = `# codewalk
 
 **CRITICAL REQUIREMENT**: You MUST create git commits for your changes AND create tracking files after EVERY task. No exceptions.
 
@@ -2040,13 +2040,13 @@ var CLAUDE_MD_CONTENT = `# Code Walker
 1. Make your code changes using Write/Edit tools
 2. **COMMIT the changes**: \`git add -A && git commit -m "descriptive message"\`
 3. Get the commit hash: \`git rev-parse --short HEAD\`
-4. **IMMEDIATELY** create \`.codewalker/<commit-hash>.json\` with the tracking data
-5. Commit the tracking file: \`git add .codewalker/<hash>.json && git commit -m "Add tracking file for <hash>"\`
+4. **IMMEDIATELY** create \`.codewalk/<commit-hash>.json\` with the tracking data
+5. Commit the tracking file: \`git add .codewalk/<hash>.json && git commit -m "Add tracking file for <hash>"\`
 6. Only THEN respond to the user
 
 **DO NOT** skip commits. **DO NOT** respond to the user until both the code commit AND tracking file commit are done.
 
-See \`.claude/skills/codewalker.md\` for the complete schema and examples.
+See \`.claude/skills/codewalk.md\` for the complete schema and examples.
 `;
 var SETTINGS_CONTENT = {
   hooks: {
@@ -2055,7 +2055,7 @@ var SETTINGS_CONTENT = {
         hooks: [
           {
             type: "prompt",
-            prompt: "Check if the assistant made code changes in this session. If code changes were made, verify: 1) Changes were committed with git, 2) A tracking file was created at .codewalker/<commit-hash>.json, 3) The tracking file was also committed. If any of these are missing, block stopping and instruct to complete the codewalker workflow. If no code changes were made, or all steps are complete, approve stopping.",
+            prompt: "Check if the assistant made code changes in this session. If code changes were made, verify: 1) Changes were committed with git, 2) A tracking file was created at .codewalk/<commit-hash>.json, 3) The tracking file was also committed. If any of these are missing, block stopping and instruct to complete the codewalk workflow. If no code changes were made, or all steps are complete, approve stopping.",
             timeout: 30
           }
         ]
@@ -2073,39 +2073,39 @@ async function fileExists(filePath) {
 }
 async function initCommand(options) {
   const { cwd } = options;
-  console.log(import_picocolors.default.bold(`Initializing CodeWalker...
+  console.log(import_picocolors.default.bold(`Initializing codewalk...
 `));
   const skillsDir = path.join(cwd, ".claude", "skills");
   await fs.mkdir(skillsDir, { recursive: true });
-  const skillPath = path.join(skillsDir, "codewalker.md");
+  const skillPath = path.join(skillsDir, "codewalk.md");
   const skillExists = await fileExists(skillPath);
   if (!skillExists) {
     await fs.writeFile(skillPath, SKILL_TEMPLATE);
-    console.log(import_picocolors.default.green("\u2713") + " Created .claude/skills/codewalker.md");
+    console.log(import_picocolors.default.green("\u2713") + " Created .claude/skills/codewalk.md");
   } else {
-    console.log(import_picocolors.default.yellow("\u25CB") + " .claude/skills/codewalker.md already exists, skipping");
+    console.log(import_picocolors.default.yellow("\u25CB") + " .claude/skills/codewalk.md already exists, skipping");
   }
   const claudePath = path.join(cwd, "CLAUDE.md");
   let claudeContent = "";
   try {
     claudeContent = await fs.readFile(claudePath, "utf-8");
   } catch {}
-  if (!claudeContent.includes(".claude/skills/codewalker.md")) {
+  if (!claudeContent.includes(".claude/skills/codewalk.md")) {
     const newContent = claudeContent ? claudeContent + `
 
 ` + CLAUDE_MD_CONTENT : CLAUDE_MD_CONTENT;
     await fs.writeFile(claudePath, newContent);
-    console.log(import_picocolors.default.green("\u2713") + " Updated CLAUDE.md with CodeWalker instructions");
+    console.log(import_picocolors.default.green("\u2713") + " Updated CLAUDE.md with codewalk instructions");
   } else {
-    console.log(import_picocolors.default.yellow("\u25CB") + " CLAUDE.md already references CodeWalker, skipping");
+    console.log(import_picocolors.default.yellow("\u25CB") + " CLAUDE.md already references codewalk, skipping");
   }
-  const codewalkerDir = path.join(cwd, ".codewalker");
-  const codewalkerExists = await fileExists(codewalkerDir);
-  await fs.mkdir(codewalkerDir, { recursive: true });
-  if (!codewalkerExists) {
-    console.log(import_picocolors.default.green("\u2713") + " Created .codewalker/ directory");
+  const codewalkDir = path.join(cwd, ".codewalk");
+  const codewalkExists = await fileExists(codewalkDir);
+  await fs.mkdir(codewalkDir, { recursive: true });
+  if (!codewalkExists) {
+    console.log(import_picocolors.default.green("\u2713") + " Created .codewalk/ directory");
   } else {
-    console.log(import_picocolors.default.yellow("\u25CB") + " .codewalker/ directory already exists");
+    console.log(import_picocolors.default.yellow("\u25CB") + " .codewalk/ directory already exists");
   }
   const settingsPath = path.join(cwd, ".claude", "settings.local.json");
   let existingSettings = {};
@@ -2129,20 +2129,20 @@ async function initCommand(options) {
     console.log(import_picocolors.default.yellow("\u25CB") + " Stop hook already configured, skipping");
   }
   console.log(import_picocolors.default.bold(`
-CodeWalker initialized successfully!`));
+codewalk initialized successfully!`));
   console.log(`
 Next steps:`);
   console.log("  1. Start Claude Code in this directory");
   console.log("  2. Make changes - Claude will automatically track them");
-  console.log("  3. Run " + import_picocolors.default.cyan("codewalker visualize") + " to browse changes");
+  console.log("  3. Run " + import_picocolors.default.cyan("codewalk visualize") + " to browse changes");
 }
 
 // src/commands/visualize.ts
 var import_picocolors2 = __toESM(require_picocolors(), 1);
-import * as fs4 from "fs";
-import * as path5 from "path";
+import * as fs5 from "fs";
+import * as path7 from "path";
 
-// ../../node_modules/@opentui/core/index-zj0wwh9d.js
+// ../../node_modules/@opentui/core/index-cr95zpf8.js
 import { Buffer as Buffer2 } from "buffer";
 import { EventEmitter } from "events";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -2183,7 +2183,7 @@ var highlights_default5 = "./highlights-hk7bwhj4.scm";
 // ../../node_modules/@opentui/core/assets/zig/tree-sitter-zig.wasm
 var tree_sitter_zig_default = "./tree-sitter-zig-e78zbjpm.wasm";
 
-// ../../node_modules/@opentui/core/index-zj0wwh9d.js
+// ../../node_modules/@opentui/core/index-cr95zpf8.js
 import { resolve as resolve2, isAbsolute, parse } from "path";
 import { existsSync } from "fs";
 import { basename, join as join2 } from "path";
@@ -4525,6 +4525,7 @@ class KeyEvent {
   baseCode;
   repeated;
   _defaultPrevented = false;
+  _propagationStopped = false;
   constructor(key) {
     this.name = key.name;
     this.ctrl = key.ctrl;
@@ -4547,23 +4548,36 @@ class KeyEvent {
   get defaultPrevented() {
     return this._defaultPrevented;
   }
+  get propagationStopped() {
+    return this._propagationStopped;
+  }
   preventDefault() {
     this._defaultPrevented = true;
   }
+  stopPropagation() {
+    this._propagationStopped = true;
+  }
 }
 
 class PasteEvent {
   text;
   _defaultPrevented = false;
+  _propagationStopped = false;
   constructor(text) {
     this.text = text;
   }
   get defaultPrevented() {
     return this._defaultPrevented;
   }
+  get propagationStopped() {
+    return this._propagationStopped;
+  }
   preventDefault() {
     this._defaultPrevented = true;
   }
+  stopPropagation() {
+    this._propagationStopped = true;
+  }
 }
 
 class KeyHandler extends EventEmitter {
@@ -4615,10 +4629,22 @@ class InternalKeyHandler extends KeyHandler {
   }
   emitWithPriority(event, ...args) {
     let hasGlobalListeners = false;
-    try {
-      hasGlobalListeners = super.emit(event, ...args);
-    } catch (error) {
-      console.error(`[KeyHandler] Error in global ${event} handler:`, error);
+    const globalListeners = this.listeners(event);
+    if (globalListeners.length > 0) {
+      hasGlobalListeners = true;
+      for (const listener of globalListeners) {
+        try {
+          listener(...args);
+        } catch (error) {
+          console.error(`[KeyHandler] Error in global ${event} handler:`, error);
+        }
+        if (event === "keypress" || event === "keyrelease" || event === "paste") {
+          const keyEvent = args[0];
+          if (keyEvent.propagationStopped) {
+            return hasGlobalListeners;
+          }
+        }
+      }
     }
     const renderableSet = this.renderableHandlers.get(event);
     const renderableHandlers = renderableSet && renderableSet.size > 0 ? [...renderableSet] : [];
@@ -4629,6 +4655,8 @@ class InternalKeyHandler extends KeyHandler {
         const keyEvent = args[0];
         if (keyEvent.defaultPrevented)
           return hasGlobalListeners || hasRenderableListeners;
+        if (keyEvent.propagationStopped)
+          return hasGlobalListeners || hasRenderableListeners;
       }
       for (const handler of renderableHandlers) {
         try {
@@ -4636,6 +4664,12 @@ class InternalKeyHandler extends KeyHandler {
         } catch (error) {
           console.error(`[KeyHandler] Error in renderable ${event} handler:`, error);
         }
+        if (event === "keypress" || event === "keyrelease" || event === "paste") {
+          const keyEvent = args[0];
+          if (keyEvent.propagationStopped) {
+            return hasGlobalListeners || hasRenderableListeners;
+          }
+        }
       }
     }
     return hasGlobalListeners || hasRenderableListeners;
@@ -8658,6 +8692,26 @@ function getOpenTUILib(libPath) {
       args: ["ptr", "i32", "i32", "u32", "u32", "u32"],
       returns: "void"
     },
+    clearCurrentHitGrid: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    hitGridPushScissorRect: {
+      args: ["ptr", "i32", "i32", "u32", "u32"],
+      returns: "void"
+    },
+    hitGridPopScissorRect: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    hitGridClearScissorRects: {
+      args: ["ptr"],
+      returns: "void"
+    },
+    addToCurrentHitGridClipped: {
+      args: ["ptr", "i32", "i32", "u32", "u32", "u32"],
+      returns: "void"
+    },
     checkHit: {
       args: ["ptr", "u32", "u32"],
       returns: "u32"
@@ -9754,6 +9808,21 @@ class FFIRenderLib {
   addToHitGrid(renderer, x, y, width, height, id) {
     this.opentui.symbols.addToHitGrid(renderer, x, y, width, height, id);
   }
+  clearCurrentHitGrid(renderer) {
+    this.opentui.symbols.clearCurrentHitGrid(renderer);
+  }
+  hitGridPushScissorRect(renderer, x, y, width, height) {
+    this.opentui.symbols.hitGridPushScissorRect(renderer, x, y, width, height);
+  }
+  hitGridPopScissorRect(renderer) {
+    this.opentui.symbols.hitGridPopScissorRect(renderer);
+  }
+  hitGridClearScissorRects(renderer) {
+    this.opentui.symbols.hitGridClearScissorRects(renderer);
+  }
+  addToCurrentHitGridClipped(renderer, x, y, width, height, id) {
+    this.opentui.symbols.addToCurrentHitGridClipped(renderer, x, y, width, height, id);
+  }
   checkHit(renderer, x, y) {
     return this.opentui.symbols.checkHit(renderer, x, y);
   }
@@ -11134,9 +11203,9 @@ class Renderable extends BaseRenderable {
     if (this._translateX === value)
       return;
     this._translateX = value;
-    this.requestRender();
     if (this.parent)
       this.parent.childrenPrimarySortDirty = true;
+    this.requestRender();
   }
   get translateY() {
     return this._translateY;
@@ -11145,9 +11214,9 @@ class Renderable extends BaseRenderable {
     if (this._translateY === value)
       return;
     this._translateY = value;
-    this.requestRender();
     if (this.parent)
       this.parent.childrenPrimarySortDirty = true;
+    this.requestRender();
   }
   get x() {
     if (this.parent) {
@@ -11780,7 +11849,9 @@ class Renderable extends BaseRenderable {
         x: scissorRect.x,
         y: scissorRect.y,
         width: scissorRect.width,
-        height: scissorRect.height
+        height: scissorRect.height,
+        screenX: this.x,
+        screenY: this.y
       });
     }
     const visibleChildren = this._getVisibleChildren();
@@ -11996,6 +12067,7 @@ class RootRenderable extends Renderable {
     }
     this.renderList.length = 0;
     this.updateLayout(deltaTime, this.renderList);
+    this._ctx.clearHitGridScissorRects();
     for (let i = 1;i < this.renderList.length; i++) {
       const command = this.renderList[i];
       switch (command.action) {
@@ -12006,9 +12078,11 @@ class RootRenderable extends Renderable {
           break;
         case "pushScissorRect":
           buffer.pushScissorRect(command.x, command.y, command.width, command.height);
+          this._ctx.pushHitGridScissorRect(command.screenX, command.screenY, command.width, command.height);
           break;
         case "popScissorRect":
           buffer.popScissorRect();
+          this._ctx.popHitGridScissorRect();
           break;
         case "pushOpacity":
           buffer.pushOpacity(command.opacity);
@@ -13524,6 +13598,8 @@ class CliRenderer extends EventEmitter9 {
   exitSignals;
   _exitListenersAdded = false;
   _isDestroyed = false;
+  _destroyPending = false;
+  _destroyFinalized = false;
   nextRenderBuffer;
   currentRenderBuffer;
   _isRunning = false;
@@ -13609,6 +13685,7 @@ class CliRenderer extends EventEmitter9 {
   }).bind(this);
   _capabilities = null;
   _latestPointer = { x: 0, y: 0 };
+  _hasPointer = false;
   _currentFocusedRenderable = null;
   lifecyclePasses = new Set;
   _openConsoleOnError = true;
@@ -13790,11 +13867,26 @@ Captured output:
     }
     this._currentFocusedRenderable = renderable;
   }
+  setCapturedRenderable(renderable) {
+    if (this.capturedRenderable === renderable) {
+      return;
+    }
+    this.capturedRenderable = renderable;
+  }
   addToHitGrid(x, y, width, height, id) {
     if (id !== this.capturedRenderable?.num) {
       this.lib.addToHitGrid(this.rendererPtr, x, y, width, height, id);
     }
   }
+  pushHitGridScissorRect(x, y, width, height) {
+    this.lib.hitGridPushScissorRect(this.rendererPtr, x, y, width, height);
+  }
+  popHitGridScissorRect() {
+    this.lib.hitGridPopScissorRect(this.rendererPtr);
+  }
+  clearHitGridScissorRects() {
+    this.lib.hitGridClearScissorRects(this.rendererPtr);
+  }
   get widthMethod() {
     const caps = this.capabilities;
     return caps?.unicode === "wcwidth" ? "wcwidth" : "unicode";
@@ -13989,7 +14081,11 @@ Captured output:
       const backgroundColor = this.backgroundColor.toInts();
       const newlines = " ".repeat(this.width) + `
 `.repeat(space);
-      clear = ANSI.setRgbBackground(backgroundColor[0], backgroundColor[1], backgroundColor[2]) + newlines + ANSI.resetBackground;
+      if (backgroundColor[3] === 0) {
+        clear = newlines;
+      } else {
+        clear = ANSI.setRgbBackground(backgroundColor[0], backgroundColor[1], backgroundColor[2]) + newlines + ANSI.resetBackground;
+      }
     }
     this.writeOut(flush + move + output + clear);
     return true;
@@ -14000,7 +14096,7 @@ Captured output:
   }
   disableMouse() {
     this._useMouse = false;
-    this.capturedRenderable = undefined;
+    this.setCapturedRenderable(undefined);
     this.mouseParser.reset();
     this.lib.disableMouse(this.rendererPtr);
   }
@@ -14118,6 +14214,7 @@ Captured output:
       }
       this._latestPointer.x = mouseEvent.x;
       this._latestPointer.y = mouseEvent.y;
+      this._hasPointer = true;
       if (this._console.visible) {
         const consoleBounds = this._console.bounds;
         if (mouseEvent.x >= consoleBounds.x && mouseEvent.x < consoleBounds.x + consoleBounds.width && mouseEvent.y >= consoleBounds.y && mouseEvent.y < consoleBounds.y + consoleBounds.height) {
@@ -14128,7 +14225,7 @@ Captured output:
         }
       }
       if (mouseEvent.type === "scroll") {
-        const maybeRenderableId2 = this.lib.checkHit(this.rendererPtr, mouseEvent.x, mouseEvent.y);
+        const maybeRenderableId2 = this.hitTest(mouseEvent.x, mouseEvent.y);
         const maybeRenderable2 = Renderable.renderablesByNumber.get(maybeRenderableId2);
         if (maybeRenderable2) {
           const event2 = new MouseEvent(maybeRenderable2, mouseEvent);
@@ -14136,7 +14233,7 @@ Captured output:
         }
         return true;
       }
-      const maybeRenderableId = this.lib.checkHit(this.rendererPtr, mouseEvent.x, mouseEvent.y);
+      const maybeRenderableId = this.hitTest(mouseEvent.x, mouseEvent.y);
       const sameElement = maybeRenderableId === this.lastOverRenderableNum;
       this.lastOverRenderableNum = maybeRenderableId;
       const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
@@ -14205,20 +14302,20 @@ Captured output:
         }
         this.lastOverRenderable = this.capturedRenderable;
         this.lastOverRenderableNum = this.capturedRenderable.num;
-        this.capturedRenderable = undefined;
+        this.setCapturedRenderable(undefined);
         this.requestRender();
       }
       let event = undefined;
       if (maybeRenderable) {
         if (mouseEvent.type === "drag" && mouseEvent.button === 0) {
-          this.capturedRenderable = maybeRenderable;
+          this.setCapturedRenderable(maybeRenderable);
         } else {
-          this.capturedRenderable = undefined;
+          this.setCapturedRenderable(undefined);
         }
         event = new MouseEvent(maybeRenderable, mouseEvent);
         maybeRenderable.processMouseEvent(event);
       } else {
-        this.capturedRenderable = undefined;
+        this.setCapturedRenderable(undefined);
         this.lastOverRenderable = undefined;
       }
       if (!event?.defaultPrevented && mouseEvent.type === "down" && this.currentSelection) {
@@ -14228,6 +14325,9 @@ Captured output:
     }
     return false;
   }
+  hitTest(x, y) {
+    return this.lib.checkHit(this.rendererPtr, x, y);
+  }
   takeMemorySnapshot() {
     if (this._isDestroyed)
       return;
@@ -14288,7 +14388,7 @@ Captured output:
     this._terminalWidth = width;
     this._terminalHeight = height;
     this.queryPixelResolution();
-    this.capturedRenderable = undefined;
+    this.setCapturedRenderable(undefined);
     this.mouseParser.reset();
     if (this._splitHeight > 0) {
       if (width < prevWidth) {
@@ -14500,6 +14600,17 @@ Captured output:
     if (this._isDestroyed)
       return;
     this._isDestroyed = true;
+    this._destroyPending = true;
+    if (this.rendering) {
+      return;
+    }
+    this.finalizeDestroy();
+  }
+  finalizeDestroy() {
+    if (this._destroyFinalized)
+      return;
+    this._destroyFinalized = true;
+    this._destroyPending = false;
     process.removeListener("SIGWINCH", this.sigwinchHandler);
     process.removeListener("uncaughtException", this.handleError);
     process.removeListener("unhandledRejection", this.handleError);
@@ -14531,7 +14642,7 @@ Captured output:
     }
     this._isRunning = false;
     this.waitingForPixelResolution = false;
-    this.capturedRenderable = undefined;
+    this.setCapturedRenderable(undefined);
     try {
       this.root.destroyRecursively();
     } catch (e) {
@@ -14576,65 +14687,71 @@ Captured output:
       clearTimeout(this.renderTimeout);
       this.renderTimeout = null;
     }
-    const now = Date.now();
-    const elapsed = now - this.lastTime;
-    const deltaTime = elapsed;
-    this.lastTime = now;
-    this.frameCount++;
-    if (now - this.lastFpsTime >= 1000) {
-      this.currentFps = this.frameCount;
-      this.frameCount = 0;
-      this.lastFpsTime = now;
-    }
-    this.renderStats.frameCount++;
-    this.renderStats.fps = this.currentFps;
-    const overallStart = performance.now();
-    const frameRequests = Array.from(this.animationRequest.values());
-    this.animationRequest.clear();
-    const animationRequestStart = performance.now();
-    frameRequests.forEach((callback) => {
-      callback(deltaTime);
-      this.dropLive();
-    });
-    const animationRequestEnd = performance.now();
-    const animationRequestTime = animationRequestEnd - animationRequestStart;
-    const start = performance.now();
-    for (const frameCallback of this.frameCallbacks) {
-      try {
-        await frameCallback(deltaTime);
-      } catch (error) {
-        console.error("Error in frame callback:", error);
-      }
-    }
-    const end = performance.now();
-    this.renderStats.frameCallbackTime = end - start;
-    this.root.render(this.nextRenderBuffer, deltaTime);
-    for (const postProcessFn of this.postProcessFns) {
-      postProcessFn(this.nextRenderBuffer, deltaTime);
-    }
-    this._console.renderToBuffer(this.nextRenderBuffer);
-    if (!this._isDestroyed) {
-      this.renderNative();
-      const overallFrameTime = performance.now() - overallStart;
-      this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
-      if (this.gatherStats) {
-        this.collectStatSample(overallFrameTime);
-      }
-      if (this._isRunning || this.immediateRerenderRequested) {
-        const targetFrameTime = this.immediateRerenderRequested ? this.minTargetFrameTime : this.targetFrameTime;
-        const delay = Math.max(1, targetFrameTime - Math.floor(overallFrameTime));
-        this.immediateRerenderRequested = false;
-        this.renderTimeout = setTimeout(() => {
+    try {
+      const now = Date.now();
+      const elapsed = now - this.lastTime;
+      const deltaTime = elapsed;
+      this.lastTime = now;
+      this.frameCount++;
+      if (now - this.lastFpsTime >= 1000) {
+        this.currentFps = this.frameCount;
+        this.frameCount = 0;
+        this.lastFpsTime = now;
+      }
+      this.renderStats.frameCount++;
+      this.renderStats.fps = this.currentFps;
+      const overallStart = performance.now();
+      const frameRequests = Array.from(this.animationRequest.values());
+      this.animationRequest.clear();
+      const animationRequestStart = performance.now();
+      for (const callback of frameRequests) {
+        callback(deltaTime);
+        this.dropLive();
+      }
+      const animationRequestEnd = performance.now();
+      const animationRequestTime = animationRequestEnd - animationRequestStart;
+      const start = performance.now();
+      for (const frameCallback of this.frameCallbacks) {
+        try {
+          await frameCallback(deltaTime);
+        } catch (error) {
+          console.error("Error in frame callback:", error);
+        }
+      }
+      const end = performance.now();
+      this.renderStats.frameCallbackTime = end - start;
+      this.root.render(this.nextRenderBuffer, deltaTime);
+      for (const postProcessFn of this.postProcessFns) {
+        postProcessFn(this.nextRenderBuffer, deltaTime);
+      }
+      this._console.renderToBuffer(this.nextRenderBuffer);
+      if (!this._isDestroyed) {
+        this.renderNative();
+        const overallFrameTime = performance.now() - overallStart;
+        this.lib.updateStats(this.rendererPtr, overallFrameTime, this.renderStats.fps, this.renderStats.frameCallbackTime);
+        if (this.gatherStats) {
+          this.collectStatSample(overallFrameTime);
+        }
+        if (this._isRunning || this.immediateRerenderRequested) {
+          const targetFrameTime = this.immediateRerenderRequested ? this.minTargetFrameTime : this.targetFrameTime;
+          const delay = Math.max(1, targetFrameTime - Math.floor(overallFrameTime));
+          this.immediateRerenderRequested = false;
+          this.renderTimeout = setTimeout(() => {
+            this.renderTimeout = null;
+            this.loop();
+          }, delay);
+        } else {
+          clearTimeout(this.renderTimeout);
           this.renderTimeout = null;
-          this.loop();
-        }, delay);
-      } else {
-        clearTimeout(this.renderTimeout);
-        this.renderTimeout = null;
+        }
       }
+    } finally {
+      this.rendering = false;
+      if (this._destroyPending) {
+        this.finalizeDestroy();
+      }
+      this.resolveIdleIfNeeded();
     }
-    this.rendering = false;
-    this.resolveIdleIfNeeded();
   }
   intermediateRender() {
     this.immediateRerenderRequested = true;
@@ -14739,7 +14856,7 @@ Captured output:
   requestSelectionUpdate() {
     if (this.currentSelection?.isSelecting) {
       const pointer = this._latestPointer;
-      const maybeRenderableId = this.lib.checkHit(this.rendererPtr, pointer.x, pointer.y);
+      const maybeRenderableId = this.hitTest(pointer.x, pointer.y);
       const maybeRenderable = Renderable.renderablesByNumber.get(maybeRenderableId);
       this.updateSelection(maybeRenderable, pointer.x, pointer.y);
     }
@@ -17950,7 +18067,8 @@ class TextRenderable extends TextBufferRenderable {
       const chunks = this.rootTextNode.gatherWithInheritedStyle({
         fg: this._defaultFg,
         bg: this._defaultBg,
-        attributes: this._defaultAttributes
+        attributes: this._defaultAttributes,
+        link: undefined
       });
       this.textBuffer.setStyledText(new StyledText(chunks));
       this.refreshLocalSelection();
@@ -20664,6 +20782,16 @@ function isGitRepo(cwd) {
     return false;
   }
 }
+function getRepoRoot(cwd) {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8"
+    }).trim();
+  } catch {
+    throw new Error("Not a git repository");
+  }
+}
 function getMainBranch(cwd) {
   try {
     const result = execSync('git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || echo "refs/heads/main"', {
@@ -20746,10 +20874,10 @@ function getCommitFileDiffs(cwd, commitSha) {
 // src/utils/tracking.ts
 import * as fs3 from "fs/promises";
 import * as path3 from "path";
-async function loadTrackingFiles(cwd, commits) {
+async function loadTrackingFiles(trackingDir, commits) {
   const result = [];
   for (const commit of commits) {
-    const trackingPath = path3.join(cwd, ".codewalker", `${commit.shortSha}.json`);
+    const trackingPath = path3.join(trackingDir, `${commit.shortSha}.json`);
     let tracking = null;
     try {
       const content = await fs3.readFile(trackingPath, "utf-8");
@@ -20809,11 +20937,89 @@ function aggregateByReasoning(cwd, trackedCommits) {
   return Array.from(reasoningMap.values()).filter((group) => group.files.length > 0).sort((a, b) => b.files.length - a.files.length);
 }
 
+// src/utils/settings.ts
+import * as fs4 from "fs/promises";
+import * as path5 from "path";
+import * as os2 from "os";
+import { execSync as execSync2 } from "child_process";
+var DEFAULT_SETTINGS = {
+  storage: "local",
+  autoCommit: true,
+  globalDir: "~/.codewalk"
+};
+function parseYamlFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match)
+    return null;
+  const yaml = match[1];
+  const result = {};
+  for (const line of yaml.split(`
+`)) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value === "true")
+      value = true;
+    else if (value === "false")
+      value = false;
+    result[key] = value;
+  }
+  return result;
+}
+function expandTilde(filepath) {
+  if (filepath.startsWith("~/")) {
+    return path5.join(os2.homedir(), filepath.slice(2));
+  }
+  if (filepath === "~") {
+    return os2.homedir();
+  }
+  return filepath;
+}
+function getRepoName(cwd) {
+  try {
+    const repoRoot = execSync2("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return path5.basename(repoRoot);
+  } catch {
+    return path5.basename(cwd);
+  }
+}
+async function loadSettings(cwd) {
+  const settingsPath = path5.join(cwd, ".claude", "codewalk.local.md");
+  try {
+    const content = await fs4.readFile(settingsPath, "utf-8");
+    const parsed = parseYamlFrontmatter(content);
+    if (!parsed) {
+      return { ...DEFAULT_SETTINGS, globalDir: expandTilde(DEFAULT_SETTINGS.globalDir) };
+    }
+    return {
+      storage: parsed.storage === "global" ? "global" : "local",
+      autoCommit: parsed.autoCommit !== false,
+      globalDir: expandTilde(String(parsed.globalDir || DEFAULT_SETTINGS.globalDir))
+    };
+  } catch {
+    return { ...DEFAULT_SETTINGS, globalDir: expandTilde(DEFAULT_SETTINGS.globalDir) };
+  }
+}
+function getTrackingDirectory(cwd, settings) {
+  if (settings.storage === "global") {
+    const repoName = getRepoName(cwd);
+    return path5.join(settings.globalDir, repoName);
+  }
+  return path5.join(cwd, ".codewalk");
+}
+
 // src/tui/app.ts
-function createAppState(branch, reasoningGroups) {
+function createAppState(branch, reasoningGroups, trackingDir) {
   return {
     branch,
     reasoningGroups,
+    trackingDir,
     selectedIndex: 0,
     expandedReasonings: new Set,
     expandedFiles: new Set
@@ -21018,14 +21224,26 @@ class TreeView {
     for (const child of headerChildren) {
       this.headerBox.remove(child.id);
     }
+    const headerContainer = new BoxRenderable(this.renderer, {
+      width: "100%",
+      flexDirection: "row",
+      paddingLeft: 1,
+      paddingRight: 1
+    });
     const totalChanges = this.state.reasoningGroups.length;
     const headerText = new TextRenderable(this.renderer, {
-      content: ` CodeWalker - ${this.state.branch} (${totalChanges} logical changes)`,
+      content: ` codewalk - ${this.state.branch} (${totalChanges} logical changes)`,
       fg: "#88ccff",
-      paddingTop: 0,
-      paddingLeft: 1
+      flexGrow: 1
+    });
+    headerContainer.add(headerText);
+    const trackingPath = this.state.trackingDir.replace(process.env.HOME || "", "~");
+    const trackingText = new TextRenderable(this.renderer, {
+      content: trackingPath,
+      fg: "#666666"
     });
-    this.headerBox.add(headerText);
+    headerContainer.add(trackingText);
+    this.headerBox.add(headerContainer);
   }
   buildContent() {
     if (this.state.reasoningGroups.length === 0) {
@@ -21312,13 +21530,13 @@ class TreeView {
 }
 
 // src/commands/visualize.ts
-async function loadBranchData(cwd) {
+async function loadBranchData(cwd, trackingDir) {
   const branch = getCurrentBranch(cwd);
   const commits = getBranchCommits(cwd);
   if (commits.length === 0) {
     return { branch, reasoningGroups: [] };
   }
-  const allTrackedCommits = await loadTrackingFiles(cwd, commits);
+  const allTrackedCommits = await loadTrackingFiles(trackingDir, commits);
   const trackedCommits = getTrackedCommits(allTrackedCommits);
   if (trackedCommits.length === 0) {
     return { branch, reasoningGroups: [] };
@@ -21332,8 +21550,11 @@ async function visualizeCommand(options) {
     console.error(import_picocolors2.default.red("Error: Not a git repository"));
     process.exit(1);
   }
+  const repoRoot = getRepoRoot(cwd);
+  const settings = await loadSettings(repoRoot);
+  const trackingDir = getTrackingDirectory(repoRoot, settings);
   console.log(import_picocolors2.default.dim("Loading tracking data..."));
-  const { branch, reasoningGroups } = await loadBranchData(cwd);
+  const { branch, reasoningGroups } = await loadBranchData(repoRoot, trackingDir);
   console.log(import_picocolors2.default.dim("Starting visualizer..."));
   const renderer = await createCliRenderer({
     exitOnCtrlC: true,
@@ -21341,16 +21562,15 @@ async function visualizeCommand(options) {
     useMouse: true,
     backgroundColor: "#0f0f1a"
   });
-  const state = createAppState(branch, reasoningGroups);
+  const state = createAppState(branch, reasoningGroups, trackingDir);
   const treeView = new TreeView(renderer, state);
   let currentBranch = branch;
-  const codewalkerDir = path5.join(cwd, ".codewalker");
-  const gitHeadPath = path5.join(cwd, ".git", "HEAD");
+  const gitHeadPath = path7.join(repoRoot, ".git", "HEAD");
   let trackingWatcher = null;
   let branchWatcher = null;
   let debounceTimer = null;
   const reloadData = async (branchChanged = false) => {
-    const { branch: newBranch, reasoningGroups: newGroups } = await loadBranchData(cwd);
+    const { branch: newBranch, reasoningGroups: newGroups } = await loadBranchData(repoRoot, trackingDir);
     if (branchChanged || newBranch !== currentBranch) {
       currentBranch = newBranch;
       treeView.updateData(newGroups, newBranch);
@@ -21359,7 +21579,8 @@ async function visualizeCommand(options) {
     }
   };
   try {
-    trackingWatcher = fs4.watch(codewalkerDir, (eventType, filename) => {
+    await fs5.promises.mkdir(trackingDir, { recursive: true });
+    trackingWatcher = fs5.watch(trackingDir, (eventType, filename) => {
       if (filename && filename.endsWith(".json")) {
         if (debounceTimer)
           clearTimeout(debounceTimer);
@@ -21368,7 +21589,7 @@ async function visualizeCommand(options) {
     });
   } catch {}
   try {
-    branchWatcher = fs4.watch(gitHeadPath, () => {
+    branchWatcher = fs5.watch(gitHeadPath, () => {
       if (debounceTimer)
         clearTimeout(debounceTimer);
       debounceTimer = setTimeout(() => reloadData(true), 100);
@@ -21415,8 +21636,8 @@ async function visualizeCommand(options) {
 
 // src/index.ts
 var program2 = new Command;
-program2.name("codewalker").description("CLI tool for visualizing AI-assisted code changes").version("0.1.0");
-program2.command("init").description("Initialize CodeWalker in the current project").action(async () => {
+program2.name("codewalk").description("CLI tool for visualizing AI-assisted code changes").version("0.1.0");
+program2.command("init").description("Initialize codewalk in the current project").action(async () => {
   try {
     await initCommand({ cwd: process.cwd() });
   } catch (error) {