claudescreenfix-hardwicksoftware 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jonhardwick-spec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# claudescreenfix-hardwicksoftware | [justcalljon.pro](https://justcalljon.pro/)
+
+yo this fixes the scroll glitch that's been cooking everyone using claude code. you know the one - after like 30 minutes your terminal starts lagging, scrolling takes forever, and eventually the whole thing just dies.
+
+## shoutout to the big dogs who should probably just fix this themselves
+
+hey [@anthropics](https://github.com/anthropics) yall made a sick product but this scrollback thing been cooking people for months lol. maybe steal this fix idc
+
+- [@karpathy](https://github.com/karpathy) - andrej you literally built tesla autopilot you could prob fix this in 5 min
+- [@gdb](https://github.com/gdb) - greg brockman openai president, yall next with codex btw dont make the same mistake
+- [@yoheinakajima](https://github.com/yoheinakajima) - babyagi goat, agent builders been struggling with this
+- [@lllyasviel](https://github.com/lllyasviel) - controlnet legend, sd-forge too, you know terminal pain
+- [@sama](https://github.com/sama) - sam you should try claude code sometime since chatgpt cant even write a working script without refusing half the prompts. also sora slapping watermarks on everything is straight clown behavior, nobody asked for that. yall so worried about "safety" you forgot to make stuff that actually works. openai been mid lately fr
+
+real talk tho [@anthropics](https://github.com/anthropics) just add `\x1b[3J` to your clear command and debounce SIGWINCH. thats literally it. im not even asking for credit just fix it for everyone 💀
+
+## what's the problem
+
+so here's the deal. claude code uses ink (it's like react but for terminals). every time something updates, ink re-renders everything. that's fine normally.
+
+but here's where it gets ugly - it doesn't clear the scrollback buffer. ever. not once.
+
+so after a while you've got thousands of lines sitting in your terminal's memory. every single re-render has to process all of em. resize your window? that triggers a re-render too. tmux users get hit especially hard cuz resize events fire like crazy with no chill.
+
+the result: your terminal slows to a crawl. scrolling back takes 30+ seconds. your fans spin up. it's bad. real talk it's been annoying everyone.
+
+## what this does
+
+hooks into node's stdout at startup and does three things:
+
+1. **clears scrollback periodically** - every 500 renders or 60 seconds, whichever comes first. your buffer won't grow forever anymore
+2. **debounces resize events** - instead of firing 50 times a second, it waits 150ms for things to settle. tmux users you're welcome
+3. **actually clears on /clear** - the /clear command only clears the screen, not scrollback. we fix that. it's kinda wild they didn't do this already
+
+no patches to claude code itself. works with any version. just loads before claude starts and you're good.
+
+## install
+
+```bash
+npm install -g claudescreenfix-hardwicksoftware
+```
+
+that's it. you don't need anything else.
+
+## usage
+
+### option 1: use the wrapper (easiest)
+
+```bash
+claude-fixed
+```
+
+instead of running `claude`, run `claude-fixed`. it finds your claude install and runs it with the fix loaded. couldn't be simpler.
+
+### option 2: alias it
+
+throw this in your `.bashrc` or `.zshrc`:
+
+```bash
+alias claude='claude-fixed'
+```
+
+now `claude` automatically uses the fix. you won't even notice it's there.
+
+### option 3: manual loading
+
+if you're the type who wants full control:
+
+```bash
+node --require claudescreenfix-hardwicksoftware/loader.cjs $(which claude)
+```
+
+or set NODE_OPTIONS if that's more your style:
+
+```bash
+export NODE_OPTIONS="--require $(npm root -g)/claudescreenfix-hardwicksoftware/loader.cjs"
+claude
+```
+
+## config
+
+here's what you can tweak via env vars:
+
+| var | what it does | default |
+|-----|--------------|---------|
+| `CLAUDE_TERMINAL_FIX_DEBUG` | set to `1` for debug logs | off |
+| `CLAUDE_TERMINAL_FIX_DISABLED` | set to `1` to disable entirely | off |
+
+## api
+
+if you wanna use it programmatically here's how:
+
+```javascript
+const fix = require('claudescreenfix-hardwicksoftware');
+
+// install the fix (usually done automatically via loader)
+fix.install();
+
+// manually clear scrollback whenever you want
+fix.clearScrollback();
+
+// check what's going on
+console.log(fix.getStats());
+
+// tweak config at runtime
+fix.setConfig('periodicClearMs', 30000);  // clear every 30s instead
+
+// turn it off if you need to
+fix.disable();
+```
+
+## how it works
+
+the fix hooks `process.stdout.write` before claude loads. when ink writes to the terminal, we check if it's doing a screen clear (which happens on every re-render). after enough renders, we inject the ANSI escape sequence `\x1b[3J` which tells the terminal to dump its scrollback buffer.
+
+for resize events, we intercept `process.on('SIGWINCH', ...)` and debounce the handlers. instead of firing immediately, we wait 150ms. if more resize events come in during that window, we reset the timer. only fires once things settle down.
+
+bottom line: smooth terminal, no lag, no memory bloat. it just works.
+
+## known issues
+
+- some old terminals don't support `\x1b[3J` but that's pretty rare nowadays
+- if you actually want to keep your scrollback history, this ain't for you
+- debug mode writes to stderr which might look weird in some setups
+
+## what this fixes
+
+people have been complaining about:
+- terminal lag after long sessions - fixed
+- scrollback buffer growing unbounded - fixed
+- resize causing massive lag in tmux/screen - fixed
+- /clear not actually clearing everything - fixed
+
+you shouldn't have to restart claude every 30 minutes anymore.
+
+## license
+
+MIT - do whatever you want with it

package/bin/claude-fixed.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * wrapper script - runs claude with the terminal fix loaded
+ *
+ * finds your claude binary and runs it with our fix injected
+ * no manual setup needed, just run claude-fixed instead of claude
+ */
+
+const { spawn, execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+// find the loader path
+const loaderPath = path.join(__dirname, '..', 'loader.cjs');
+
+if (!fs.existsSync(loaderPath)) {
+  console.error('loader not found at ' + loaderPath);
+  process.exit(1);
+}
+
+// find claude binary
+let claudeBin;
+try {
+  claudeBin = execSync('which claude', { encoding: 'utf8' }).trim();
+} catch (e) {
+  console.error('claude not found in PATH - make sure its installed');
+  process.exit(1);
+}
+
+// run claude with our fix loaded via NODE_OPTIONS
+const env = Object.assign({}, process.env, {
+  NODE_OPTIONS: '--require ' + loaderPath + ' ' + (process.env.NODE_OPTIONS || '')
+});
+
+const child = spawn(claudeBin, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: env
+});
+
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});

package/index.cjs

@@ -0,0 +1,186 @@
+'use strict';
+
+/**
+ * claudescreenfix-hardwicksoftware - stops the scroll glitch from cooking your terminal
+ *
+ * the problem:
+ *   claude code uses ink (react for terminals) and it dont clear scrollback
+ *   so after like 30 min your terminal got thousands of lines in the buffer
+ *   every re-render touches ALL of em - O(n) where n keeps growing
+ *   resize events fire with no debounce so tmux/screen users get cooked
+ *
+ * what we do:
+ *   - hook stdout.write to inject scrollback clears periodically
+ *   - debounce SIGWINCH so resize aint thrashing
+ *   - enhance /clear to actually clear scrollback not just the screen
+ */
+
+const CLEAR_SCROLLBACK = '\x1b[3J';
+const CURSOR_SAVE = '\x1b[s';
+const CURSOR_RESTORE = '\x1b[u';
+const CLEAR_SCREEN = '\x1b[2J';
+const HOME_CURSOR = '\x1b[H';
+
+// config - tweak these if needed
+const config = {
+  resizeDebounceMs: 150,        // how long to wait before firing resize
+  periodicClearMs: 60000,       // clear scrollback every 60s
+  clearAfterRenders: 500,       // or after 500 render cycles
+  debug: process.env.CLAUDE_TERMINAL_FIX_DEBUG === '1',
+  disabled: process.env.CLAUDE_TERMINAL_FIX_DISABLED === '1'
+};
+
+// state tracking
+let renderCount = 0;
+let lastResizeTime = 0;
+let resizeTimeout = null;
+let originalWrite = null;
+let installed = false;
+
+function log(...args) {
+  if (config.debug) {
+    process.stderr.write('[terminal-fix] ' + args.join(' ') + '\n');
+  }
+}
+
+/**
+ * installs the fix - hooks into stdout and sigwinch
+ * call this once at startup, calling again is a no-op
+ */
+function install() {
+  if (installed || config.disabled) {
+    if (config.disabled) log('disabled via env var');
+    return;
+  }
+
+  originalWrite = process.stdout.write.bind(process.stdout);
+
+  // hook stdout.write - this is where the magic happens
+  process.stdout.write = function(chunk, encoding, callback) {
+    if (typeof chunk === 'string') {
+      renderCount++;
+
+      // ink clears screen before re-render, we piggyback on that
+      if (chunk.includes(CLEAR_SCREEN) || chunk.includes(HOME_CURSOR)) {
+        if (config.clearAfterRenders > 0 && renderCount >= config.clearAfterRenders) {
+          log('clearing scrollback after ' + renderCount + ' renders');
+          renderCount = 0;
+          chunk = CLEAR_SCROLLBACK + chunk;
+        }
+      }
+
+      // /clear command should actually clear everything
+      if (chunk.includes('Conversation cleared') || chunk.includes('Chat cleared')) {
+        log('/clear detected, nuking scrollback');
+        chunk = CLEAR_SCROLLBACK + chunk;
+      }
+    }
+
+    return originalWrite(chunk, encoding, callback);
+  };
+
+  // debounce resize events - tmux users know the pain
+  installResizeDebounce();
+
+  // periodic cleanup so long sessions dont get cooked
+  if (config.periodicClearMs > 0) {
+    setInterval(() => {
+      if (process.stdout.isTTY) {
+        log('periodic scrollback clear');
+        originalWrite(CURSOR_SAVE + CLEAR_SCROLLBACK + CURSOR_RESTORE);
+      }
+    }, config.periodicClearMs);
+  }
+
+  installed = true;
+  log('installed successfully');
+}
+
+function installResizeDebounce() {
+  const originalOn = process.on.bind(process);
+  let sigwinchHandlers = [];
+
+  function debouncedSigwinch() {
+    const now = Date.now();
+    const timeSince = now - lastResizeTime;
+    lastResizeTime = now;
+
+    if (resizeTimeout) clearTimeout(resizeTimeout);
+
+    // if events coming too fast, batch em
+    if (timeSince < config.resizeDebounceMs) {
+      resizeTimeout = setTimeout(() => {
+        log('firing debounced resize');
+        sigwinchHandlers.forEach(h => { try { h(); } catch(e) {} });
+      }, config.resizeDebounceMs);
+    } else {
+      sigwinchHandlers.forEach(h => { try { h(); } catch(e) {} });
+    }
+  }
+
+  process.on = function(event, handler) {
+    if (event === 'SIGWINCH') {
+      sigwinchHandlers.push(handler);
+      if (sigwinchHandlers.length === 1) {
+        originalOn('SIGWINCH', debouncedSigwinch);
+      }
+      return this;
+    }
+    return originalOn(event, handler);
+  };
+
+  log('resize debounce installed');
+}
+
+/**
+ * manually clear scrollback - call this whenever you want
+ */
+function clearScrollback() {
+  if (originalWrite) {
+    originalWrite(CLEAR_SCROLLBACK);
+  } else {
+    process.stdout.write(CLEAR_SCROLLBACK);
+  }
+  log('manual scrollback clear');
+}
+
+/**
+ * get current stats for debugging
+ */
+function getStats() {
+  return {
+    renderCount,
+    lastResizeTime,
+    installed,
+    config
+  };
+}
+
+/**
+ * update config at runtime
+ */
+function setConfig(key, value) {
+  if (key in config) {
+    config[key] = value;
+    log('config updated: ' + key + ' = ' + value);
+  }
+}
+
+/**
+ * disable the fix (mostly for testing)
+ */
+function disable() {
+  if (originalWrite) {
+    process.stdout.write = originalWrite;
+    log('disabled');
+  }
+}
+
+module.exports = {
+  install,
+  clearScrollback,
+  getStats,
+  setConfig,
+  disable,
+  config
+};

package/loader.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+ * loader for --require usage
+ *
+ * use like: node --require claudescreenfix-hardwicksoftware/loader.cjs $(which claude)
+ *
+ * this auto-installs the fix before claude code even starts
+ * no code changes needed in claude itself
+ */
+
+const fix = require('./index.cjs');
+
+// install immediately on require
+fix.install();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "claudescreenfix-hardwicksoftware",
+  "version": "1.0.0",
+  "description": "fixes the scroll glitch in claude code cli - unbounded scrollback, resize thrashing, all that bs",
+  "main": "index.cjs",
+  "bin": {
+    "claude-fixed": "./bin/claude-fixed.js"
+  },
+  "scripts": {},
+  "keywords": [
+    "claude",
+    "terminal",
+    "fix",
+    "scroll",
+    "ink",
+    "cli",
+    "glitch",
+    "performance"
+  ],
+  "author": "jonhardwick-spec",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jonhardwick-spec/claudescreenfix-hardwicksoftware"
+  },
+  "bugs": {
+    "url": "https://github.com/jonhardwick-spec/claudescreenfix-hardwicksoftware/issues"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "index.cjs",
+    "loader.cjs",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ]
+}