chisle 3.2.0 → 3.3.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Maximum-efficiency dev mode. Zero-fluff prose combined with YAGNI/ladder-first code decisions. One persona: the senior dev who deletes code for fun and bills by the syllable.",
   "hooks": {
     "SessionStart": [

package/README.md

@@ -144,21 +144,30 @@ Preview first with `npx chisle --dry-run`, scope with `--only claude` or `--only
 
 ### Upgrading
 
-Same command as installing. It is idempotent and overwrites the previous copy:
+```bash
+npx chisle@latest --update
+```
+
+That refreshes every agent that already has Chisle and installs it into none that don't. Two details it exists to handle:
+
+- **Plain `npx chisle` does not upgrade.** Every install path skips what is already present, so an upgrade run reports success and changes nothing. `--update` pairs the refresh with that check.
+- **`@latest` matters.** `npx chisle` can serve a cached copy of the package from a previous run, so the pin is what guarantees you get the new one.
+
+Per-agent equivalents, if you prefer the native tool:
 
 ```bash
-npx chisle              # npm / standalone install
-claude plugin update chisle@chisle   # Claude Code plugin install
+claude plugin update chisle@chisle    # Claude Code plugin install
+pi install npm:chisle                 # Pi package
+gemini extensions install https://github.com/JayPokale/Chisle
 ```
 
-Chisle checks npm on session start and mentions it once when a **major** version
-is out (cached 3 days, `CHISLE_UPDATE_CHECK=0` to silence). Minor and patch
-releases stay quiet on purpose.
+Project-scoped agents (Cursor, Windsurf, Cline, Kiro, Copilot) keep their rule file inside the repo, so run the update once per project that has one.
+
+Not sure what you are running? `npx chisle --list` prints the agents it detects, and `claude plugin list` shows the installed plugin and its version.
+
+Chisle checks npm on session start and mentions it once when a **major** version is out (cached 3 days, `CHISLE_UPDATE_CHECK=0` to silence). Minor and patch releases stay quiet on purpose.
 
-Upgrading to 3.0.0 from 2.x needs nothing: a `lite`/`full`/`ultra` value in
-`CHISLE_DEFAULT_MODE` or `config.json` is no longer meaningful, falls through to
-the default, and Chisle stays active. It says so once so the setting is not
-ignored silently. Replace it with `on`/`off` or delete it.
+Upgrading to 3.0.0 from 2.x needs nothing: a `lite`/`full`/`ultra` value in `CHISLE_DEFAULT_MODE` or `config.json` is no longer meaningful, falls through to the default, and Chisle stays active. It says so once so the setting is not ignored silently. Replace it with `on`/`off` or delete it.
 
 ### Claude Code plugin (marketplace)
 
@@ -331,7 +340,7 @@ node benchmarks/replay-compress.js       # Claude Code
 node benchmarks/replay-compress.js pi    # Pi
 ```
 
-Outputs over 8k chars are elided. `stop chisle`, `CHISLE_COMPRESS=0`, `CHISLE_COMPRESS_SCRUB=0`, `CHISLE_COMPRESS_DEDUP=0`. Every tier has an off switch.
+Outputs over 8k chars are elided, and the elided original spills to `<config>/chisle-spill/` so the dropped middle stays reachable. The marker carries the path, so recovering one line is a targeted grep rather than a re-run of the command, which matters most when the command is not idempotent: a test run, a build, a `git log` at a moment in time. The newest 40 spills are kept, owner-readable only. `stop chisle`, `CHISLE_COMPRESS=0`, `CHISLE_COMPRESS_SCRUB=0`, `CHISLE_COMPRESS_DEDUP=0`, `CHISLE_COMPRESS_SPILL=0`. Every tier has an off switch.
 
 ### Pi arm: where the output axis lost
 

package/bin/install.js

@@ -58,7 +58,7 @@ const PROVIDERS = [
 // ── argv ────────────────────────────────────────────────────────────────────
 function parseArgs(argv) {
   const opts = { dryRun: false, force: false, list: false, uninstall: false,
-                 noColor: false, help: false, stats: false, only: [], configDir: null };
+                 noColor: false, help: false, stats: false, update: false, only: [], configDir: null };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     switch (a) {
@@ -66,6 +66,9 @@ function parseArgs(argv) {
       case '--force': opts.force = true; break;
       case '--list': opts.list = true; break;
       case '--stats': opts.stats = true; break;
+      // --update is --force narrowed to what is already there: refresh every
+      // agent that has Chisle, add it to none that don't.
+      case '--update': opts.update = true; opts.force = true; break;
       case '--uninstall': case '-u': opts.uninstall = true; break;
       case '--no-color': opts.noColor = true; break;
       case '-h': case '--help': opts.help = true; break;
@@ -165,6 +168,49 @@ function claudeDir(opts) {
   return path.join(os.homedir(), '.claude');
 }
 
+// ── what is already installed ───────────────────────────────────────────────
+// Every install path skips when Chisle is already present, which is right for
+// `npx chisle` and useless for an upgrade: the run reports success and changes
+// nothing. --update pairs this check with --force so a refresh touches exactly
+// the agents that already have it.
+function installedFor(id, opts) {
+  try {
+    switch (id) {
+      case 'claude': {
+        if (hasCmd('claude')) {
+          const r = capture('claude', ['plugin', 'list']);
+          if (r.status === 0 && /chisle/i.test(r.stdout || '')) return true;
+        }
+        const settings = SETTINGS.readSettings(path.join(claudeDir(opts), 'settings.json'));
+        const hooks = (settings && settings.hooks) || {};
+        for (const event of Object.keys(hooks)) {
+          for (const entry of hooks[event] || []) {
+            for (const h of (entry && entry.hooks) || []) {
+              if (typeof h.command === 'string' && h.command.includes('chisle-')) return true;
+            }
+          }
+        }
+        return false;
+      }
+      case 'pi':
+        return hasCmd('pi') && piSources(capture('pi', ['list']).stdout).length > 0;
+      case 'gemini': {
+        if (!hasCmd('gemini')) return false;
+        const r = capture('gemini', ['extensions', 'list']);
+        return r.status === 0 && /chisle/i.test(r.stdout || '');
+      }
+      case 'codex': {
+        const md = path.join(os.homedir(), '.codex', 'AGENTS.md');
+        return fs.existsSync(md) && fs.readFileSync(md, 'utf8').includes(FENCE_BEGIN);
+      }
+      default: {
+        const prov = PROVIDERS.find(x => x.id === id);
+        return !!(prov && prov.rule && fs.existsSync(path.join(process.cwd(), prov.rule)));
+      }
+    }
+  } catch (e) { return false; }
+}
+
 // ── Claude Code ─────────────────────────────────────────────────────────────
 function installClaude(ctx) {
   const { say, note, warn, opts, results } = ctx;
@@ -412,8 +458,10 @@ function uninstall(ctx) {
         touched++;
       }
     }
-    const hooksDst = path.join(cfg, 'chisle-hooks');
-    if (fs.existsSync(hooksDst)) { if (!opts.dryRun) fs.rmSync(hooksDst, { recursive: true, force: true }); note(`  removed ${hooksDst}`); touched++; }
+    for (const d of ['chisle-hooks', 'chisle-spill']) {
+      const dst = path.join(cfg, d);
+      if (fs.existsSync(dst)) { if (!opts.dryRun) fs.rmSync(dst, { recursive: true, force: true }); note(`  removed ${dst}`); touched++; }
+    }
 
     for (const f of ['.chisle-active', '.chisle-session-turns', '.chisle-statusline-suffix',
                      '.chisle-compress-stats.json', '.chisle-compress-last.json', '.chisle-update-check.json']) {
@@ -459,6 +507,7 @@ Usage:
 Flags:
   --list           Detect agents and print them; install nothing
   --stats          Print tool-output savings recorded so far; change nothing
+  --update         Refresh every agent that already has Chisle; install none
   --only <id>      Limit install/uninstall to one agent (repeatable)
   --dry-run        Print actions, change nothing
   --force          Reinstall / overwrite even if already present
@@ -474,6 +523,7 @@ Examples:
   npx chisle --only claude    # just Claude Code
   npx chisle --dry-run        # preview
   npx chisle --stats          # what the compressor has saved
+  npx chisle@latest --update  # upgrade what is already installed
 `);
 }
 
@@ -544,12 +594,20 @@ function main() {
 
   if (opts.uninstall) return uninstall(ctx);
 
-  say(c.orange('╭─ Chisle installer ─╮'));
+  say(c.orange(opts.update ? '╭─ Chisle updater ─╮' : '╭─ Chisle installer ─╮'));
   say(c.dim(opts.dryRun ? '  (dry run, nothing will change)' : '  maximum signal, minimum noise'));
   say('');
 
-  const targets = PROVIDERS.filter(p => opts.only.length ? opts.only.includes(p.id) : detectMatch(p.detect));
+  let targets = PROVIDERS.filter(p => opts.only.length ? opts.only.includes(p.id) : detectMatch(p.detect));
+  if (opts.update) targets = targets.filter(p => installedFor(p.id, opts));
   if (targets.length === 0) {
+    if (opts.update) {
+      warn('Nothing to update: Chisle is not installed for any detected agent.');
+      note('Run `npx chisle` to install it, or `npx chisle --list` to see what we look for.');
+      note('Project-scoped agents (Cursor, Windsurf, Cline, Kiro, Copilot) are per-repo:');
+      note('run this from the project that has the rule file.');
+      return;
+    }
     warn('No supported agents detected.');
     note('Run `npx chisle --list` to see what we look for, or `--only <id>` to force one.');
     return;

package/hooks/chisle-compress-output.js

@@ -31,8 +31,11 @@
 //   CHISLE_COMPRESS_HEAD_LINES        — lines kept from the top
 //   CHISLE_COMPRESS_TAIL_LINES        — lines kept from the bottom
 //   CHISLE_COMPRESS_TOOLS=Bash,Grep   — override the tool allowlist
+//   CHISLE_COMPRESS_SPILL=0           — elide without writing the recovery copy
 //
 // Savings accrue in <claudeDir>/.chisle-compress-stats.json for the statusline.
+// Elided originals spill to <claudeDir>/chisle-spill/ so the dropped middle can
+// be grepped back instead of re-running the command; the newest 40 are kept.
 
 const fs = require('fs');
 const path = require('path');
@@ -174,17 +177,59 @@ function dedupCheck(toolName, text, sessionId, toolUseId) {
 // ── Tier 2: elision ──────────────────────────────────────────────────────────
 // Keep head + tail; salvage error-looking lines from the elided middle so the
 // one line that mattered in a 3000-line build log survives the cut.
-function compress(text, limits) {
+// ── recoverable elision ─────────────────────────────────────────────────────
+// Elision used to destroy the middle. If the agent then needed a line from it,
+// its only recourse was re-running the command: more expensive than the elision
+// saved, and wrong outright when the command is not idempotent (a test run, a
+// build, `git log` at a moment in time). So the full text spills to disk first
+// and the marker carries the path. Recovery becomes a targeted grep instead of
+// a re-run. Best-effort throughout: if the spill fails, the elision still
+// happens, it just loses the escape hatch.
+const SPILL_DIR = 'chisle-spill';
+const SPILL_KEEP = 40;
+
+function spillDir() {
+  return path.join(getClaudeDir(), SPILL_DIR);
+}
+
+// Keep the directory bounded. Oldest-first by mtime; cheap enough at this size
+// and it runs at most once per elided output.
+function pruneSpill(dir) {
+  try {
+    const files = fs.readdirSync(dir)
+      .filter(f => f.endsWith('.txt'))
+      .map(f => { const p = path.join(dir, f); return { p, t: fs.statSync(p).mtimeMs }; })
+      .sort((a, b) => b.t - a.t);
+    for (const f of files.slice(SPILL_KEEP)) { try { fs.unlinkSync(f.p); } catch (e) {} }
+  } catch (e) {}
+}
+
+function spill(text, toolName) {
+  if (process.env.CHISLE_COMPRESS_SPILL === '0') return null;
+  try {
+    const dir = spillDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const hash = crypto.createHash('sha256').update(text).digest('hex').slice(0, 12);
+    const safeTool = String(toolName || 'tool').replace(/[^A-Za-z0-9_-]/g, '') || 'tool';
+    const file = path.join(dir, `${safeTool}-${hash}.txt`);
+    if (!fs.existsSync(file)) fs.writeFileSync(file, text, { mode: 0o600 });
+    pruneSpill(dir);
+    return file;
+  } catch (e) { return null; }
+}
+
+function compress(text, limits, spillPath) {
   const { maxChars, headLines, tailLines } = limits;
   const lines = text.split('\n');
+  const recover = spillPath ? ' Full output: ' + spillPath + ' (grep it, do not re-run)' : '';
 
   if (lines.length <= headLines + tailLines) {
-    // Big in bytes, few lines (one giant line) — hard char cut.
+    // Big in bytes, few lines (one giant line): hard char cut.
     const keep = Math.floor(maxChars / 2);
     const elided = text.length - 2 * keep;
     if (elided <= 0) return null;
     return text.slice(0, keep) +
-      '\n... [chisle: elided ' + elided.toLocaleString('en-US') + ' chars from the middle] ...\n' +
+      '\n... [chisle: elided ' + elided.toLocaleString('en-US') + ' chars from the middle.' + recover + '] ...\n' +
       text.slice(-keep);
   }
 
@@ -199,8 +244,9 @@ function compress(text, limits) {
   }
 
   const marker = '... [chisle: elided ' + middle.length.toLocaleString('en-US') +
-    ' lines — kept first ' + headLines + ', last ' + tailLines +
-    (salvaged.length ? ', and ' + salvaged.length + ' error-like line(s) below' : '') + '] ...';
+    ' lines, kept first ' + headLines + ', last ' + tailLines +
+    (salvaged.length ? ', and ' + salvaged.length + ' error-like line(s) below' : '') +
+    '.' + recover + '] ...';
 
   const out = head.concat([marker], salvaged, tail).join('\n');
   return out.length < text.length ? out : null;
@@ -227,11 +273,11 @@ function recordSavings(saved) {
 
 // Scrub + elide on plain text → transformed text, or null if no meaningful
 // win. Stateless — this is what the replay benchmark measures.
-function transform(text, limits) {
+function transform(text, limits, toolName) {
   if (!text || text.length <= SCRUB_MIN) return null;
   let t = process.env.CHISLE_COMPRESS_SCRUB === '0' ? text : scrub(text);
   if (t.length > limits.maxChars) {
-    const elided = compress(t, limits);
+    const elided = compress(t, limits, toolName ? spill(t, toolName) : null);
     if (elided != null) t = elided;
   }
   return text.length - t.length >= MIN_WIN ? t : null;
@@ -275,7 +321,7 @@ function processPayload(payload, mode) {
   if (!text) return null;
   const dup = dedupCheck(payload.tool_name, text, payload.session_id, payload.tool_use_id);
   if (dup != null && dup.length < text.length) return dup;
-  return transform(text, limitsFor());
+  return transform(text, limitsFor(), payload.tool_name);
 }
 
 function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chisle",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Maximum-efficiency dev mode for AI coding agents. Zero-fluff prose, YAGNI-first code, and safe tool-output compression.",
   "keywords": [
     "claude-code",

package/pi-extension/index.js

@@ -166,7 +166,7 @@ function chisleExtension(pi) {
           lastByToolBlock.set(key, hash);
           if (previous === hash) updated = duplicateMarker(event.toolName, text, 'earlier');
         }
-        if (updated == null) updated = transform(text, limitsFor());
+        if (updated == null) updated = transform(text, limitsFor(), event.toolName);
         if (updated == null || updated.length >= text.length) return block;
         changed = true;
         savedChars += text.length - updated.length;