kompactor 0.5.0__py3-none-any.whl

kompactor/samples.py

@@ -0,0 +1,217 @@
+"""Realistic sample outputs used by the dashboard's live preview, so users can
+see what Claude would receive at each quality/savings setting."""
+
+
+def _pytest():
+    passed = "\n".join(f"tests/test_api.py::test_endpoint_{i} PASSED{' ' * 30}[{i:3d}%]" for i in range(1, 61))
+    return f"""============================= test session starts ==============================
+platform linux -- Python 3.12.4, pytest-8.3.2, pluggy-1.5.0
+rootdir: /home/dev/shop-api
+configfile: pyproject.toml
+plugins: anyio-4.4.0, cov-5.0.0
+collected 61 items
+
+{passed}
+tests/test_orders.py::test_create_order FAILED                           [100%]
+
+=================================== FAILURES ===================================
+______________________________ test_create_order _______________________________
+
+client = <FlaskClient <Flask 'shop'>>
+
+    def test_create_order(client):
+>       resp = client.post("/orders", json={{"sku": "A-1", "qty": 2}})
+
+tests/test_orders.py:14:
+_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+.venv/lib/python3.12/site-packages/werkzeug/test.py:1167: in post
+    return self.open(*args, method="POST", **kw)
+.venv/lib/python3.12/site-packages/flask/testing.py:235: in open
+    response = super().open(
+.venv/lib/python3.12/site-packages/werkzeug/test.py:1116: in open
+    response_parts = self.run_wsgi_app(request.environ, buffered=buffered)
+.venv/lib/python3.12/site-packages/werkzeug/test.py:988: in run_wsgi_app
+    rv = run_wsgi_app(self.application, environ, buffered=buffered)
+.venv/lib/python3.12/site-packages/werkzeug/test.py:1264: in run_wsgi_app
+    app_rv = app(environ, start_response)
+.venv/lib/python3.12/site-packages/flask/app.py:1498: in __call__
+    return self.wsgi_app(environ, start_response)
+.venv/lib/python3.12/site-packages/flask/app.py:1476: in wsgi_app
+    response = self.handle_exception(e)
+.venv/lib/python3.12/site-packages/flask/app.py:1473: in wsgi_app
+    response = self.full_dispatch_request()
+.venv/lib/python3.12/site-packages/flask/app.py:882: in full_dispatch_request
+    rv = self.handle_user_exception(e)
+.venv/lib/python3.12/site-packages/flask/app.py:880: in full_dispatch_request
+    rv = self.dispatch_request()
+.venv/lib/python3.12/site-packages/flask/app.py:865: in dispatch_request
+    return self.ensure_sync(self.view_functions[rule.endpoint])(**view_args)
+shop/orders.py:41: in create_order
+    total = price_for(sku) * payload["qty"]
+shop/pricing.py:18: in price_for
+    return CATALOG[sku].price
+E   KeyError: 'A-1'
+
+shop/pricing.py:18: KeyError
+=========================== short test summary info ============================
+FAILED tests/test_orders.py::test_create_order - KeyError: 'A-1'
+========================= 1 failed, 60 passed in 2.31s ========================="""
+
+
+def _gotest():
+    runs = "\n".join(f"=== RUN   TestHandler/case_{i}\n--- PASS: TestHandler/case_{i} (0.00s)" for i in range(1, 41))
+    return f"""go: downloading github.com/stretchr/testify v1.9.0
+go: downloading github.com/davecgh/go-spew v1.1.1
+go: downloading gopkg.in/yaml.v3 v3.0.1
+?   	example.com/shop/cmd/server	[no test files]
+?   	example.com/shop/internal/version	[no test files]
+=== RUN   TestHandler
+{runs}
+--- PASS: TestHandler (0.02s)
+=== RUN   TestCheckout
+--- FAIL: TestCheckout (0.00s)
+panic: runtime error: invalid memory address or nil pointer dereference [recovered]
+	panic: runtime error: invalid memory address or nil pointer dereference
+[signal SIGSEGV: segmentation violation code=0x1 addr=0x18 pc=0x6b2f1a]
+
+goroutine 21 [running]:
+testing.tRunner.func1.2({{0x6f1e40, 0x9a8b30}})
+	/usr/local/go/src/testing/testing.go:1631 +0x24a
+testing.tRunner.func1()
+	/usr/local/go/src/testing/testing.go:1634 +0x377
+panic({{0x6f1e40?, 0x9a8b30?}})
+	/usr/local/go/src/runtime/panic.go:770 +0x132
+example.com/shop/internal/cart.(*Cart).Total(0x0)
+	/home/dev/shop/internal/cart/cart.go:58 +0x1a
+example.com/shop/internal/checkout.Checkout(0xc0000a6000)
+	/home/dev/shop/internal/checkout/checkout.go:33 +0x45
+example.com/shop/internal/checkout.TestCheckout(0xc0001044e0)
+	/home/dev/shop/internal/checkout/checkout_test.go:21 +0x5d
+testing.tRunner(0xc0001044e0, 0x7486a8)
+	/usr/local/go/src/testing/testing.go:1689 +0xfb
+created by testing.(*T).Run in goroutine 1
+	/usr/local/go/src/testing/testing.go:1742 +0x390
+FAIL	example.com/shop/internal/checkout	0.014s
+ok  	example.com/shop/internal/cart	0.009s
+ok  	example.com/shop/internal/http	0.031s
+FAIL"""
+
+
+def _vitest():
+    ok = "\n".join(f" ✓ src/components/ProductCard.test.tsx > ProductCard > renders variant {i} {3 + i % 7}ms"
+                   for i in range(1, 46))
+    return f"""
+ RUN  v2.0.5 /home/dev/storefront
+
+{ok}
+ ❯ src/hooks/useCart.test.ts (3 tests | 1 failed) 18ms
+   × useCart > adds item and updates total 9ms
+     → expected 0 to be 2400 // Object.is equality
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ Failed Tests 1 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
+
+ FAIL  src/hooks/useCart.test.ts > useCart > adds item and updates total
+AssertionError: expected 0 to be 2400 // Object.is equality
+
+- Expected
++ Received
+
+- 2400
++ 0
+
+ ❯ src/hooks/useCart.test.ts:27:32
+     25|     act(() => result.current.add({{ sku: 'A-1', price: 1200 }}, 2));
+     26|
+     27|     expect(result.current.total).toBe(2400);
+       |                                ^
+     28|   }});
+    at Object.toBe (node_modules/@vitest/expect/dist/index.js:1235:20)
+    at Proxy.<anonymous> (node_modules/chai/chai.js:1661:16)
+    at Proxy.methodWrapper (node_modules/chai/chai.js:1584:25)
+    at node_modules/@vitest/runner/dist/index.js:146:14
+    at node_modules/@vitest/runner/dist/index.js:61:7
+    at runTest (node_modules/@vitest/runner/dist/index.js:960:17)
+    at processTicksAndRejections (node:internal/process/task_queues:95:5)
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
+
+ Test Files  1 failed | 4 passed (5)
+      Tests  1 failed | 47 passed (48)
+   Start at  10:42:11
+   Duration  1.94s"""
+
+
+def _gitlog():
+    authors = ["Priya Shah <priya@shop.dev>", "Marco Rossi <marco@shop.dev>", "Lee Kim <lee@shop.dev>"]
+    msgs = ["fix cart total rounding", "add checkout retry", "bump vite to 5.4", "refactor pricing service",
+            "handle empty SKU", "add order webhook", "tidy logging", "split ProductCard", "cache catalog lookups",
+            "go: upgrade to 1.23"]
+    out = []
+    for i in range(24):
+        out.append(f"commit {('%040x' % (0x9f3a1c * (i + 7)))[-40:]}\nAuthor: {authors[i % 3]}\n"
+                   f"Date:   Tue Oct {20 - i % 19} 1{i % 10}:0{i % 6}:12 2026 +0000\n\n    {msgs[i % 10]}\n\n"
+                   f"    {'Longer explanation of why this change was needed and how it was tested.' if i % 2 else ''}\n")
+    return "\n".join(out)
+
+
+def _npm_build():
+    chunks = "\n".join(f"dist/assets/{n}-{abs(hash(n)) % 10**8:08x}.js   {12 + i * 3.7:6.2f} kB │ gzip: {4 + i:5.2f} kB"
+                       for i, n in enumerate(["index", "vendor", "react-dom", "router", "cart", "checkout", "product",
+                                              "account", "search", "icons", "charts", "i18n", "auth", "admin"]))
+    deps = "\n".join(f"npm http fetch GET 200 https://registry.npmjs.org/{p} {20 + i}ms (cache revalidated)"
+                     for i, p in enumerate(["react", "react-dom", "vite", "typescript", "zod", "@tanstack/react-query",
+                                            "clsx", "date-fns", "eslint", "vitest", "msw", "postcss"] * 6))
+    return f"""{deps}
+npm WARN deprecated inflight@1.0.6: This module is not supported, and leaks memory.
+npm WARN deprecated glob@7.2.3: Glob versions prior to v9 are no longer supported
+npm WARN deprecated rimraf@3.0.2: Rimraf versions prior to v4 are no longer supported
+
+added 412 packages, and audited 413 packages in 9s
+
+> storefront@1.4.0 build
+> tsc -b && vite build
+
+vite v5.4.2 building for production...
+transforming...
+✓ 1324 modules transformed.
+rendering chunks...
+computing gzip size...
+dist/index.html                     0.62 kB │ gzip:  0.38 kB
+dist/assets/index-4c1e2b9a.css     18.40 kB │ gzip:  4.12 kB
+{chunks}
+(!) Some chunks are larger than 500 kB after minification.
+✓ built in 6.81s"""
+
+
+def _gitdiff():
+    body = "\n".join(f"     const line{i} = compute({i});" for i in range(1, 19))
+    lock = "\n".join(f'+    "node_modules/pkg-{i}": {{ "version": "1.{i}.0", "resolved": "https://registry.npmjs.org/pkg-{i}/-/pkg-{i}-1.{i}.0.tgz" }},'
+                     for i in range(60))
+    return f"""diff --git a/src/hooks/useCart.ts b/src/hooks/useCart.ts
+index 3f2a1c4..9b7e2d0 100644
+--- a/src/hooks/useCart.ts
++++ b/src/hooks/useCart.ts
+@@ -10,30 +10,31 @@ export function useCart() {{
+{body}
+-  const total = items.reduce((sum, i) => sum + i.price, 0);
++  const total = items.reduce((sum, i) => sum + i.price * i.qty, 0);
+{body}
+diff --git a/package-lock.json b/package-lock.json
+index 11aa22b..33cc44d 100644
+--- a/package-lock.json
++++ b/package-lock.json
+@@ -1,6 +1,66 @@
+{lock}"""
+
+
+SAMPLES = [
+    {"id": "pytest", "short": "pytest", "lang": "python", "label": "Python · pytest -v (1 failure)", "cmd": "pytest -v", "text": _pytest()},
+    {"id": "gotest", "short": "go test", "lang": "go", "label": "Go · go test -v ./... (panic)", "cmd": "go test -v ./...", "text": _gotest()},
+    {"id": "vitest", "short": "vitest", "lang": "react", "label": "React · vitest run (1 failure)", "cmd": "npx vitest run",
+     "text": _vitest()},
+    {"id": "build", "short": "npm build", "lang": "typescript", "label": "TypeScript · npm install && npm run build",
+     "cmd": "npm install && npm run build", "text": _npm_build()},
+    {"id": "gitdiff", "short": "git diff", "lang": "typescript", "label": "git diff (with lock file)", "cmd": "git diff",
+     "text": _gitdiff()},
+    {"id": "gitlog", "short": "git log", "lang": "any", "label": "git log -n 24", "cmd": "git log -n 24", "text": _gitlog()},
+]

kompactor/server.py

@@ -0,0 +1,301 @@
+"""Local settings & savings dashboard: `kompactor ui`.
+
+Stdlib only. Binds to 127.0.0.1, checks the Host header (DNS rebinding) and a
+per-launch token on every write (CSRF), so other websites can't change settings.
+"""
+
+import json
+import os
+import secrets
+import socket
+import threading
+import time
+import webbrowser
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+import difflib
+import mimetypes
+
+from . import __version__, config, estimate, filters, graph, installer, langs, samples, store, tokens
+
+TOKEN = secrets.token_urlsafe(24)
+UI_FILE = Path(__file__).with_name("ui.html")
+STATIC = Path(__file__).with_name("static")
+
+
+# ---------------------------------------------------------------------------
+# API
+
+
+def preview(knobs: dict, languages) -> list:
+    out = []
+    for s in samples.SAMPLES:
+        cfg = dict(knobs, languages=languages)
+        raw = tokens.count(s["text"])
+        if not cfg.get("bash", True) or raw < cfg.get("bash_min_tokens", 0):
+            text = s["text"]
+        else:
+            text = filters.compress(s["cmd"], s["text"], 0, stash_id=42, opts=cfg)
+            if tokens.count(text) > raw * 0.9:
+                text = s["text"]
+        out.append({"id": s["id"], "label": s["label"], "short": s.get("short", s["id"]), "lang": s["lang"],
+                    "cmd": s["cmd"], "raw": raw,
+                    "kept": tokens.count(text), "before": s["text"], "after": text,
+                    "segments": segments(s["text"], text)})
+    return out
+
+
+def segments(before: str, after: str) -> list:
+    """Line-level view of what was kept, dropped or added (notes) — for the preview."""
+    a, b = filters.clean(before), after.split("\n")
+    out = []
+    for op, i1, i2, j1, j2 in difflib.SequenceMatcher(None, a, b, autojunk=False).get_opcodes():
+        if op == "equal":
+            out += [["keep", ln] for ln in a[i1:i2]]
+        else:
+            out += [["drop", ln] for ln in a[i1:i2]]
+            out += [["note", ln] for ln in b[j1:j2]]
+    return out
+
+
+def preset_savings() -> dict:
+    res = {}
+    for p, preset in config.PRESETS.items():
+        rows = preview({k: preset[k] for k in config.KNOBS}, [])
+        r, k = sum(x["raw"] for x in rows), sum(x["kept"] for x in rows)
+        res[p] = round(100 * (r - k) / r) if r else 0
+    return res
+
+
+def state() -> dict:
+    data = config.read_file()
+    with store.connect() as db:
+        projects = [r[0] for r in db.execute(
+            "SELECT project FROM events WHERE project != '' GROUP BY project ORDER BY MAX(ts) DESC LIMIT 30")]
+    projects = list(dict.fromkeys(projects + list(data["projects"])))
+    cwd_project = config.project_root(os.getcwd())
+    if cwd_project and (Path(cwd_project) / ".git").exists() and cwd_project not in projects:
+        projects.append(cwd_project)
+    return {
+        "version": __version__,
+        "config": data,
+        "presets": {p: {"name": v["name"], "blurb": v["blurb"], **{k: v[k] for k in config.KNOBS}}
+                    for p, v in config.PRESETS.items()},
+        "preset_savings": preset_savings(),
+        "knobs": {k: list(v) for k, v in config.KNOB_INFO.items()},
+        "knob_order": config.KNOBS,
+        "languages": {k: v["label"] for k, v in langs.PROFILES.items()},
+        "projects": [{"path": p, "detected": langs.detect(p) if os.path.isdir(p) else [],
+                      "override": data["projects"].get(p),
+                      "repo_file": config.repo_settings(p) if os.path.isdir(p) else {}} for p in projects],
+        "setup": installer.status(),
+        "home": str(store.home()),
+    }
+
+
+def stats(params: dict) -> dict:
+    days = float(params.get("days", ["30"])[0])
+    project = params.get("project", [""])[0]
+    since = time.time() - days * 86400
+    where, args = "ts > ?", [since]
+    if project:
+        where += " AND project = ?"
+        args.append(project)
+    with store.connect() as db:
+        tot = db.execute(f"SELECT COUNT(*), COALESCE(SUM(raw_tokens),0), COALESCE(SUM(kept_tokens),0) FROM events "
+                         f"WHERE {where}", args).fetchone()
+        feats = db.execute(f"SELECT feature, COUNT(*), SUM(raw_tokens), SUM(kept_tokens) FROM events WHERE {where} "
+                           f"GROUP BY feature ORDER BY SUM(raw_tokens)-SUM(kept_tokens) DESC", args).fetchall()
+        turns = db.execute(f"SELECT session, idx, ts, project, raw_tokens, kept_tokens, context_tokens, features "
+                           f"FROM turns WHERE {where} ORDER BY ts DESC LIMIT 60", args).fetchall()
+        top = db.execute(f"SELECT detail, COUNT(*), SUM(raw_tokens), SUM(kept_tokens) FROM events WHERE {where} "
+                         f"AND feature='bash' GROUP BY detail ORDER BY SUM(raw_tokens)-SUM(kept_tokens) DESC LIMIT 10",
+                         args).fetchall()
+        sessions = db.execute(f"SELECT COUNT(DISTINCT session) FROM events WHERE {where}", args).fetchone()[0]
+    return {
+        "events": tot[0], "raw": tot[1], "kept": tot[2], "saved": tot[1] - tot[2], "sessions": sessions,
+        "features": [{"feature": f[0], "count": f[1], "raw": f[2], "kept": f[3]} for f in feats],
+        "turns": [{"session": t[0], "idx": t[1], "ts": t[2], "project": t[3], "raw": t[4], "kept": t[5],
+                   "context": t[6], "features": json.loads(t[7] or "{}")} for t in reversed(turns)],
+        "top": [{"cmd": t[0], "runs": t[1], "raw": t[2], "kept": t[3]} for t in top],
+        "live": store.read_live(),
+    }
+
+
+def graph_state(project: str) -> dict:
+    if not project or not os.path.isdir(project):
+        return {"exists": False}
+    if not graph.exists(project):
+        return {"exists": False, "project": project}
+    v = graph.viz(project, 70)
+    g = graph.Graph(project)
+    dead, public = graph.unused(project)
+    v.update(exists=True, project=project, cycles=len(graph.import_cycles(g)),
+             unused={"dead": len(dead), "public": len(public)},
+             hubs=[{"name": n, "refs": c, "files": len(g.ref_files[n])} for n, c in g.ref_count.most_common(300)
+                   if n in g.by_name and len(n) > 2][:10],
+             core=[{"unit": u, "importers": len(g.in_units.get(u, ())), "symbols": graph._key_symbols(g, u)[:6]}
+                   for u in g.core_units()[:12]])
+    return v
+
+
+def save_config(body: dict) -> dict:
+    data = config.read_file()
+    if "preset" in body:
+        p = int(body["preset"])
+        if p not in config.PRESETS:
+            raise ValueError("preset must be 1-5")
+        data["preset"] = p
+    if "overrides" in body:
+        data["overrides"] = {k: config.coerce(k, v) for k, v in body["overrides"].items() if k in config.KNOBS}
+    if "languages" in body:
+        mode = body["languages"].get("mode", "auto")
+        sel = [s for s in body["languages"].get("selected", []) if s in langs.PROFILES]
+        data["languages"] = {"mode": "manual" if mode == "manual" else "auto", "selected": sel}
+    if "general" in body:
+        data["general"].update({k: bool(v) for k, v in body["general"].items() if k in config.GENERAL})
+    if "project" in body:
+        path, ov = body["project"].get("path", ""), body["project"].get("override")
+        if path:
+            if ov:
+                data["projects"][path] = {"preset": int(ov.get("preset", data["preset"])),
+                                          "overrides": {k: config.coerce(k, v) for k, v in
+                                                        ov.get("overrides", {}).items() if k in config.KNOBS}}
+            else:
+                data["projects"].pop(path, None)
+    config.write_file(data)
+    return {"ok": True, "config": data}
+
+
+# ---------------------------------------------------------------------------
+# HTTP
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "kompactor"
+
+    def log_message(self, *a):  # quiet
+        pass
+
+    def _host_ok(self) -> bool:
+        host = (self.headers.get("Host") or "").split(":")[0]
+        return host in ("127.0.0.1", "localhost")
+
+    def _send(self, code: int, body, ctype="application/json"):
+        data = body if isinstance(body, bytes) else json.dumps(body).encode()
+        self.send_response(code)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(data)))
+        self.send_header("Cache-Control", "no-store")
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.end_headers()
+        self.wfile.write(data)
+
+    def do_GET(self):
+        if not self._host_ok():
+            return self._send(403, {"error": "bad host"})
+        u = urlparse(self.path)
+        try:
+            if u.path in ("/", "/index.html"):
+                html = UI_FILE.read_text().replace("__KOMPACTOR_TOKEN__", TOKEN)
+                return self._send(200, html.encode(), "text/html; charset=utf-8")
+            if u.path == "/api/ping":
+                return self._send(200, {"kompactor": __version__})
+            if u.path == "/api/state":
+                return self._send(200, state())
+            if u.path == "/api/stats":
+                return self._send(200, stats(parse_qs(u.query)))
+            if u.path == "/api/graph":
+                return self._send(200, graph_state(parse_qs(u.query).get("project", [""])[0]))
+            if u.path in ("/usage", "/usage.html", "/guide"):
+                self.send_response(302)
+                self.send_header("Location", "/static/usage.html")
+                self.send_header("Content-Length", "0")
+                self.end_headers()
+                return None
+            if u.path.startswith("/static/"):
+                f = (STATIC / u.path[len("/static/"):]).resolve()
+                if STATIC.resolve() in f.parents and f.is_file():
+                    ctype = mimetypes.guess_type(f.name)[0] or "application/octet-stream"
+                    if f.suffix == ".woff2":
+                        ctype = "font/woff2"
+                    return self._send(200, f.read_bytes(), ctype)
+                return self._send(404, {"error": "not found"})
+            return self._send(404, {"error": "not found"})
+        except Exception as e:  # pragma: no cover - surfaced in the UI
+            return self._send(500, {"error": str(e)})
+
+    def do_POST(self):
+        if not self._host_ok() or self.headers.get("X-Kompactor-Token") != TOKEN:
+            return self._send(403, {"error": "forbidden"})
+        try:
+            body = json.loads(self.rfile.read(int(self.headers.get("Content-Length") or 0)) or b"{}")
+            u = urlparse(self.path).path
+            if u == "/api/config":
+                return self._send(200, save_config(body))
+            if u == "/api/preview":
+                knobs = {k: config.coerce(k, v) for k, v in body.get("knobs", {}).items() if k in config.KNOBS}
+                return self._send(200, {"samples": preview(knobs, body.get("languages") or [])})
+            if u == "/api/setup":
+                action = body.get("action")
+                target = installer.install(statusline=bool(body.get("statusline", True)),
+                                           uninstall=action == "uninstall")
+                return self._send(200, {"ok": True, "file": str(target), "setup": installer.status()})
+            if u == "/api/selftest":
+                return self._send(200, {"results": installer.selftest()})
+            if u.startswith("/api/graph/"):
+                project = body.get("project", "")
+                if not project or not os.path.isdir(project):
+                    raise ValueError("unknown project")
+                action = u.rsplit("/", 1)[1]
+                if action == "build":
+                    graph.build(project)
+                    return self._send(200, graph_state(project))
+                text = {"query": lambda: graph.query(project, body.get("q", ""), 1800),
+                        "report": lambda: graph.report(project, 2500),
+                        "unused": lambda: graph.unused_text(project, 2500),
+                        "debt": lambda: graph.debt_text(project, 2500),
+                        "impact": lambda: graph.impact_text(project, body.get("q", ""), 1800),
+                        "explain": lambda: graph.explain_text(project, body.get("q", ""), 1800)}.get(action)
+                if not text:
+                    return self._send(404, {"error": "not found"})
+                return self._send(200, {"text": text()})
+            if u == "/api/estimate":
+                s = estimate.run(limit=int(body.get("limit") or 0) or None, style_pct=0)
+                return self._send(200, {"sessions": s["sessions"], "calls": s["calls"],
+                                        "tool_tokens": s["tool_tokens"], "saved_tool": s["saved_tool"],
+                                        "billed": s["billed"], "saved_billed": s["saved_billed"],
+                                        "cost": s["cost"], "saved_cost": s["saved_cost"],
+                                        "by_feature": dict(s["by_feature"])})
+            return self._send(404, {"error": "not found"})
+        except (ValueError, KeyError, RuntimeError) as e:
+            return self._send(400, {"error": str(e)})
+
+
+def _free_port(preferred: int) -> int:
+    for port in [preferred] + list(range(preferred + 1, preferred + 20)):
+        with socket.socket() as s:
+            try:
+                s.bind(("127.0.0.1", port))
+                return port
+            except OSError:
+                continue
+    return 0
+
+
+def serve(port: int = 7420, open_browser: bool = True, print_url: bool = True) -> None:
+    port = _free_port(port)
+    httpd = ThreadingHTTPServer(("127.0.0.1", port), Handler)
+    url = f"http://127.0.0.1:{httpd.server_address[1]}/"
+    if print_url:
+        print(f"Kompactor dashboard: {url}  (Ctrl+C to stop)", flush=True)
+    if open_browser:
+        threading.Timer(0.3, lambda: webbrowser.open(url)).start()
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        httpd.server_close()

kompactor/shellwrap.py

@@ -0,0 +1,149 @@
+"""Shell prefix: compact test, build and lint output even when the command fails.
+
+Claude Code only lets hooks rewrite the output of commands that succeed. When a
+command exits non-zero it skips PostToolUse, fires PostToolUseFailure (which can
+add context but not replace anything) and cuts the output to its first and last
+few thousand characters, which usually drops the failures at the end of a test
+run. Claude Code's CLAUDE_CODE_SHELL_PREFIX setting runs every Bash command as
+`<prefix> '<shell command>'`. Kompactor's prefix (~/.kompactor/bin/kompactor-shell)
+sends finite, noisy commands here: they run to completion, the output is
+compacted, and the exit code is passed through unchanged. Permission rules
+still see Claude's original command, because the prefix applies only when the
+command runs.
+
+Everything else, and any problem inside Kompactor before the command starts,
+runs the command untouched.
+"""
+
+import os
+import shlex
+import signal
+import subprocess
+import sys
+from collections import deque
+
+from . import config, filters, installer, store, tokens
+
+HEAD_BYTES = 16 << 20  # keep at most 16 MB from the start and 8 MB from the end of the output
+TAIL_BYTES = 8 << 20
+SHOWN_LIMIT = 30000  # Claude Code saves longer successful outputs to a file and shows a 2 KB preview
+PREVIEW_CHARS = 2048
+ERROR_LIMIT = 10000  # failed commands: Claude Code keeps about this many characters
+
+
+def user_command(full: str) -> str:
+    """Claude's own command inside the string Claude Code hands the prefix:
+    `source <snapshot> ... && eval '<command>' < /dev/null && pwd -P >| <cwd file>`."""
+    i = full.find(" eval ")
+    if i < 0:
+        return ""
+    try:
+        lex = shlex.shlex(full[i + 6:], posix=True)
+        lex.whitespace_split = True
+        return lex.get_token() or ""
+    except ValueError:
+        return ""
+
+
+def decide(full: str):
+    """(command, config) when the command should run through Kompactor, else (None, None)."""
+    if os.environ.get("KOMPACTOR_RAW"):
+        return None, None
+    cmd = user_command(full)
+    if not cmd or cmd.lstrip().startswith("KOMPACTOR_RAW=1") or not filters.wrappable(cmd):
+        return None, None
+    cfg = config.load(os.getcwd())
+    if not cfg.get("bash") or not cfg.get("bash_wrap"):
+        return None, None
+    words = " ".join(filters.argv0(cmd))
+    if any(words.startswith(c.strip()) for c in cfg.get("never_compact", []) if c.strip()):
+        return None, None
+    return cmd, cfg
+
+
+def shown_tokens(text: str, code: int) -> int:
+    """Roughly what Claude would have read without Kompactor (the honest baseline for the ledger)."""
+    if code != 0:
+        if len(text) > ERROR_LIMIT:
+            return tokens.count(text[:ERROR_LIMIT // 2]) + tokens.count(text[-ERROR_LIMIT // 2:])
+        return tokens.count(text)
+    if len(text) > int(os.environ.get("BASH_MAX_OUTPUT_LENGTH") or SHOWN_LIMIT):
+        return tokens.count(text[:PREVIEW_CHARS]) + 60
+    return tokens.count(text)
+
+
+def compact(cmd: str, raw: str, code: int, cfg: dict, stopped: bool = False) -> str:
+    raw_tokens = tokens.count(raw)
+    if raw_tokens < cfg["bash_min_tokens"]:
+        return raw
+    sid = store.stash(cmd, raw)
+    new = filters.compress(cmd, raw, code, stash_id=sid, opts=cfg)
+    kept = tokens.count(new)
+    if kept > raw_tokens * 0.9 and len(raw) <= (ERROR_LIMIT if code else SHOWN_LIMIT):
+        return raw  # barely compressible, and Claude Code would show all of it anyway
+    note = "; the command was stopped before it finished" if stopped else ""
+    new = new.rstrip("\n") + f"\n[kompactor: {raw_tokens}›{kept} tokens{note}; full output: {installer.cli_name()} show {sid}]\n"
+    store.record("bash", shown_tokens(raw, code), kept, cmd, os.environ.get("CLAUDE_CODE_SESSION_ID", ""),
+                 project=cfg["project"])
+    return new
+
+
+def run(shell: str, full: str, cmd: str, cfg: dict) -> int:
+    proc = subprocess.Popen([shell, "-c", full], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    stopped = []
+
+    def forward(sig, _frame):  # a timeout or Esc in Claude Code: stop the command, still report what it printed
+        stopped.append(sig)
+        try:
+            proc.send_signal(sig)
+        except OSError:
+            pass
+
+    for sig in (signal.SIGTERM, signal.SIGINT, signal.SIGHUP):
+        signal.signal(sig, forward)
+    head, tail, tail_size, dropped = bytearray(), deque(), 0, 0
+    try:
+        while True:
+            chunk = proc.stdout.read1(65536)
+            if not chunk:
+                break
+            room = HEAD_BYTES - len(head)
+            if room > 0:
+                head += chunk[:room]
+                chunk = chunk[room:]
+            if chunk:
+                tail.append(chunk)
+                tail_size += len(chunk)
+                while tail_size - len(tail[0]) >= TAIL_BYTES:
+                    tail_size -= len(tail[0])
+                    dropped += len(tail.popleft())
+    except OSError:
+        pass
+    code = proc.wait()
+    if code < 0:
+        code = 128 - code
+    raw = head.decode("utf-8", "replace")
+    if dropped:
+        raw += f"\n… [kompactor: {dropped} bytes from the middle were not kept] …\n"
+    raw += b"".join(tail).decode("utf-8", "replace")
+    try:
+        text = compact(cmd, raw, code, cfg, bool(stopped))
+    except Exception:  # never lose the output to a Kompactor bug
+        text = raw
+    try:
+        sys.stdout.write(text)
+        sys.stdout.flush()
+    except OSError:
+        pass
+    return code
+
+
+def main(argv) -> int:
+    shell, full = argv[0], argv[1]
+    try:
+        cmd, cfg = decide(full)
+    except Exception:
+        cmd = cfg = None
+    if not cmd:
+        os.execvp(shell, [shell, "-c", full])
+    return run(shell, full, cmd, cfg)