supercompact 1.0.0

package/dist/store.js

@@ -0,0 +1,261 @@
+// Where Claude Code keeps its sessions, and how to add one it will accept.
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { Transcript, decode, encode, isRecord } from './transcript.js';
+/** SUPERCOMPACT_ROOT points every read and write somewhere else, which is how
+ * the checks run without going near real sessions. */
+export function root() {
+    const override = process.env.SUPERCOMPACT_ROOT;
+    if (override !== undefined && override !== '')
+        return override;
+    return join(homedir(), '.claude', 'projects');
+}
+/** Claude Code turns a working directory into a folder name by replacing both
+ * slashes and dots with dashes, so /Users/a/.config lands at -Users-a--config. */
+export function directoryFor(cwd) {
+    return join(root(), cwd.replace(/\//g, '-').replace(/\./g, '-'));
+}
+export function allSessionFiles() {
+    const out = [];
+    let projects;
+    try {
+        projects = readdirSync(root());
+    }
+    catch {
+        return out;
+    }
+    for (const project of projects) {
+        const dir = join(root(), project);
+        let files;
+        try {
+            if (!statSync(dir).isDirectory())
+                continue;
+            files = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const file of files)
+            if (file.endsWith('.jsonl'))
+                out.push(join(dir, file));
+    }
+    return out;
+}
+export function sessionFilesFor(cwd) {
+    return sessionFilesIn(directoryFor(cwd));
+}
+export function sessionFilesIn(dir) {
+    try {
+        return readdirSync(dir)
+            .filter((file) => file.endsWith('.jsonl'))
+            .map((file) => join(dir, file));
+    }
+    catch {
+        return [];
+    }
+}
+export function modified(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+export function sizeOf(path) {
+    try {
+        return statSync(path).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Finds a session by the first characters of its id. */
+export function find(handle) {
+    const needle = handle.toLowerCase();
+    const matches = allSessionFiles().filter((path) => basename(path).toLowerCase().startsWith(needle));
+    if (matches.length === 0)
+        throw new Error(`no session matching "${handle}"`);
+    if (matches.length > 1) {
+        const ids = matches.map((path) => basename(path).slice(0, 8));
+        throw new Error(`"${handle}" matches ${matches.length} sessions: ${ids.join(', ')}`);
+    }
+    return matches[0];
+}
+/** The session running in this directory.
+ *
+ * Claude Code names the running session in the environment. Without that the
+ * newest file wins, which is wrong whenever a background job in the same
+ * project is writing more recently than the session that called us. */
+export function current(cwd) {
+    const named = process.env.CLAUDE_CODE_SESSION_ID;
+    if (named !== undefined && named !== '') {
+        try {
+            return find(named);
+        }
+        catch {
+            // fall through to the newest file
+        }
+    }
+    let newest = '';
+    let newestAt = 0;
+    for (const path of sessionFilesFor(cwd)) {
+        const at = modified(path);
+        if (newest !== '' && at <= newestAt)
+            continue;
+        try {
+            if (new Transcript(path).counts().users === 0)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        newest = path;
+        newestAt = at;
+    }
+    if (newest === '')
+        throw new Error(`no Claude Code sessions found for ${cwd}`);
+    return newest;
+}
+/** Puts a new session where Claude Code will find it and tells the index it
+ * exists, so it shows up in the resume picker. */
+export function write(options) {
+    const dir = directoryFor(options.cwd);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, options.sessionId + '.jsonl');
+    replace(path, options.jsonl);
+    upsertIndex(dir, options);
+    return path;
+}
+/** Writes through a temporary file in the same directory and then moves it into
+ * place. A half-written session file is a lost session.
+ *
+ * A session holds private conversation, so it is written owner-only, which is
+ * what Claude Code does. Replacing a file keeps whatever mode it already had. */
+export function replace(path, contents) {
+    const temp = join(dirname(path), `.supercompact-${randomUUID()}.tmp`);
+    let mode = 0o600;
+    try {
+        mode = statSync(path).mode & 0o777;
+    }
+    catch {
+        // a new file gets the owner-only default
+    }
+    try {
+        writeFileSync(temp, contents, { mode });
+        renameSync(temp, path);
+    }
+    catch (error) {
+        try {
+            unlinkSync(temp);
+        }
+        catch {
+            // nothing to clean up
+        }
+        throw new Error(`cannot write ${path}: ${String(error)}`);
+    }
+}
+function indexPath(dir) {
+    return join(dir, 'sessions-index.json');
+}
+function readIndex(dir) {
+    try {
+        const parsed = JSON.parse(readFileSync(indexPath(dir), 'utf8'));
+        if (isRecord(parsed)) {
+            const entries = Array.isArray(parsed.entries) ? parsed.entries.filter(isRecord) : [];
+            return { index: parsed, entries };
+        }
+    }
+    catch {
+        // a missing or unreadable index is written fresh
+    }
+    return { index: { version: 1 }, entries: [] };
+}
+function saveIndex(dir, index, entries) {
+    index.entries = entries;
+    try {
+        writeFileSync(indexPath(dir), JSON.stringify(index, null, 2), { mode: 0o600 });
+    }
+    catch {
+        // the index is a convenience, not the session
+    }
+}
+function upsertIndex(dir, options) {
+    const { index, entries } = readIndex(dir);
+    index.originalPath ??= options.cwd;
+    const now = new Date().toISOString().replace(/(\.\d{3})\d*Z$/, '$1Z');
+    const entry = {
+        sessionId: options.sessionId,
+        fullPath: join(dir, options.sessionId + '.jsonl'),
+        fileMtime: Date.now(),
+        summary: options.title,
+        messageCount: options.messages,
+        created: now,
+        modified: now,
+        gitBranch: options.gitBranch,
+        projectPath: options.cwd,
+        isSidechain: false,
+    };
+    if (options.firstPrompt !== '')
+        entry.firstPrompt = options.firstPrompt;
+    saveIndex(dir, index, [...entries.filter((existing) => existing.sessionId !== options.sessionId), entry]);
+}
+export function titleOf(sessionId, dir) {
+    const { entries } = readIndex(dir);
+    for (const entry of entries) {
+        if (entry.sessionId !== sessionId)
+            continue;
+        if (typeof entry.summary === 'string')
+            return entry.summary;
+    }
+    return '';
+}
+/** Changes what a session is called, in the index and in the file.
+ *
+ * A session Claude Code has not indexed yet gets an entry rather than being
+ * skipped, so the new name shows up in the resume picker either way. */
+export function rename(sessionId, dir, title) {
+    const { index, entries } = readIndex(dir);
+    const now = new Date().toISOString().replace(/(\.\d{3})\d*Z$/, '$1Z');
+    const existing = entries.find((entry) => entry.sessionId === sessionId);
+    if (existing) {
+        existing.summary = title;
+        existing.modified = now;
+    }
+    else {
+        entries.push({
+            sessionId,
+            fullPath: join(dir, sessionId + '.jsonl'),
+            fileMtime: Date.now(),
+            summary: title,
+            created: now,
+            modified: now,
+            isSidechain: false,
+        });
+    }
+    saveIndex(dir, index, entries);
+    const path = join(dir, sessionId + '.jsonl');
+    if (!existsSync(path))
+        return;
+    const record = {
+        type: 'custom-title',
+        sessionId,
+        customTitle: title,
+        timestamp: now,
+    };
+    const lines = readFileSync(path, 'utf8').replace(/\n+$/, '').split('\n');
+    const at = lines.findIndex((line) => decode(line)?.type === 'custom-title');
+    if (at >= 0)
+        lines[at] = encode(record);
+    else
+        lines.unshift(encode(record));
+    replace(path, lines.join('\n') + '\n');
+}
+export function stamp() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return (`${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}` +
+        `_${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`);
+}

package/dist/transcript.js

@@ -0,0 +1,182 @@
+// A Claude Code session is a JSONL file. Every line is one record: a message,
+// or one of the bookkeeping records Claude Code keeps alongside them. Almost
+// all of the bytes are tool traffic.
+import { closeSync, openSync, readFileSync, readSync, statSync } from 'node:fs';
+import { basename, dirname } from 'node:path';
+/** One line, kept as both raw text and parsed form.
+ *
+ * The raw text matters. A line that is copied rather than rewritten has to go
+ * back to disk exactly as it came, and re-encoding a parsed object does not
+ * promise that. */
+export class Entry {
+    index;
+    raw;
+    data;
+    constructor(index, raw, data) {
+        this.index = index;
+        this.raw = raw;
+        this.data = data;
+    }
+    get type() {
+        return typeof this.data.type === 'string' ? this.data.type : '';
+    }
+    get uuid() {
+        return typeof this.data.uuid === 'string' ? this.data.uuid : '';
+    }
+    get message() {
+        const message = this.data.message;
+        return isRecord(message) ? message : undefined;
+    }
+    get content() {
+        return this.message?.content;
+    }
+    /** The content blocks of a message, empty when the content is a plain string. */
+    get blocks() {
+        const content = this.content;
+        return Array.isArray(content) ? content.filter(isRecord) : [];
+    }
+    flag(name) {
+        return this.data[name] === true;
+    }
+    get isSidechain() {
+        return this.flag('isSidechain');
+    }
+    get isCompactSummary() {
+        return this.flag('isCompactSummary');
+    }
+    get isTranscriptOnly() {
+        return this.flag('isVisibleInTranscriptOnly');
+    }
+    get isApiError() {
+        return this.flag('isApiErrorMessage');
+    }
+}
+export class Transcript {
+    path;
+    id;
+    entries;
+    bytes;
+    constructor(path) {
+        this.path = path;
+        this.id = basename(path).replace(/\.jsonl$/, '');
+        this.bytes = statSync(path).size;
+        this.entries = parse(readFileSync(path, 'utf8'));
+    }
+    /** Where this session lives, which is also where a copy of it has to go for
+     * `claude --resume` to find it. */
+    get directory() {
+        return dirname(this.path);
+    }
+    /** The working directory the session was recorded in. `claude --resume` only
+     * finds a session when it runs from there. */
+    get cwd() {
+        for (const entry of this.entries) {
+            const cwd = entry.data.cwd;
+            if (typeof cwd === 'string' && cwd !== '')
+                return cwd;
+        }
+        return '';
+    }
+    get gitBranch() {
+        for (const entry of this.entries) {
+            const branch = entry.data.gitBranch;
+            if (typeof branch === 'string' && branch !== '')
+                return branch;
+        }
+        return '';
+    }
+    /** The first thing the person actually typed, used for naming. */
+    get firstPrompt() {
+        for (const entry of this.entries) {
+            if (entry.type !== 'user')
+                continue;
+            if (entry.isSidechain || entry.isCompactSummary || entry.isTranscriptOnly)
+                continue;
+            const text = promptText(entry.content);
+            if (text === undefined)
+                continue;
+            const clean = stripNoise(text);
+            if (clean !== '')
+                return clean;
+        }
+        return '';
+    }
+    counts() {
+        let users = 0;
+        let assistants = 0;
+        let calls = 0;
+        for (const entry of this.entries) {
+            if (entry.type === 'user') {
+                if (promptText(entry.content) !== undefined)
+                    users++;
+            }
+            else if (entry.type === 'assistant') {
+                assistants++;
+                for (const block of entry.blocks)
+                    if (block.type === 'tool_use')
+                        calls++;
+            }
+        }
+        return { users, assistants, calls };
+    }
+}
+function parse(text) {
+    const entries = [];
+    let index = 0;
+    for (const line of text.split('\n')) {
+        if (line.trim() === '')
+            continue;
+        let data = {};
+        try {
+            const parsed = JSON.parse(line);
+            // A line that will not parse is still a line. It keeps its place so the
+            // ones around it keep theirs.
+            if (isRecord(parsed))
+                data = parsed;
+        }
+        catch {
+            // leave it empty
+        }
+        entries.push(new Entry(index++, line, data));
+    }
+    return entries;
+}
+/** The opening entries of a session, without reading the rest of the file.
+ *
+ * These files run to tens of megabytes, and a caller that only wants the first
+ * few requests should not pay for all of it. A line the slice cuts in half is
+ * dropped, because half a line is not a record. */
+export function head(path, bytes) {
+    const file = openSync(path, 'r');
+    let text;
+    try {
+        const buffer = Buffer.alloc(bytes);
+        const read = readSync(file, buffer, 0, bytes, 0);
+        text = buffer.subarray(0, read).toString('utf8');
+        if (read === bytes) {
+            const lastBreak = text.lastIndexOf('\n');
+            text = lastBreak === -1 ? '' : text.slice(0, lastBreak);
+        }
+    }
+    finally {
+        closeSync(file);
+    }
+    return parse(text);
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function decode(line) {
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function encode(record) {
+    return JSON.stringify(record);
+}
+// Imported after the class so the module reads top down.
+import { promptText, stripNoise } from './dialogue.js';

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "supercompact",
+  "version": "1.0.0",
+  "description": "Cut up to 95% of tokens from Claude Code sessions without losing conversation history",
+  "keywords": [
+    "claude-code",
+    "claude",
+    "context",
+    "compact",
+    "tokens",
+    "transcript",
+    "session",
+    "anthropic",
+    "coding-agent",
+    "token-reduction"
+  ],
+  "license": "MIT",
+  "author": "Adam Albastov",
+  "repository": { "type": "git", "url": "git+https://github.com/SignedAdam/supercompact.git" },
+  "homepage": "https://github.com/SignedAdam/supercompact",
+  "type": "module",
+  "bin": { "supercompact": "dist/cli.js" },
+  "files": ["dist"],
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "check": "npm run build && ./scripts/check.sh"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "typescript": "^5.7.2"
+  }
+}