ctxdiet 0.1.0

package/dist/src/sources.js

@@ -0,0 +1,347 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IGNORE_PATTERNS = exports.HEAVY_FILES = exports.HEAVY_DIRS = void 0;
+exports.isFile = isFile;
+exports.isDir = isDir;
+exports.exists = exists;
+exports.readFileSafe = readFileSafe;
+exports.shortenPath = shortenPath;
+exports.displayPath = displayPath;
+exports.uniq = uniq;
+exports.detectModel = detectModel;
+exports.walkFiles = walkFiles;
+exports.parseIgnore = parseIgnore;
+exports.ignoreCovers = ignoreCovers;
+exports.estimatePathTokens = estimatePathTokens;
+exports.readMcpServers = readMcpServers;
+exports.scanDefinitions = scanDefinitions;
+exports.archivePathFor = archivePathFor;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("./constants");
+const tokens_1 = require("./tokens");
+// ---------------------------------------------------------------------------
+// fs helpers
+// ---------------------------------------------------------------------------
+function isFile(p) {
+    try {
+        return node_fs_1.default.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function isDir(p) {
+    try {
+        return node_fs_1.default.statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function exists(p) {
+    try {
+        node_fs_1.default.statSync(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readFileSafe(p) {
+    try {
+        return node_fs_1.default.readFileSync(p, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function shortenPath(p, home) {
+    return p.startsWith(home) ? p.replace(home, "~") : p;
+}
+/** Readable path: project-relative inside the scan dir, ~ inside home, else absolute. */
+function displayPath(p, projectPath, home) {
+    if (p === projectPath)
+        return ".";
+    if (p.startsWith(projectPath + node_path_1.default.sep)) {
+        return "./" + node_path_1.default.relative(projectPath, p);
+    }
+    if (p.startsWith(home))
+        return p.replace(home, "~");
+    return p;
+}
+function uniq(items) {
+    return [...new Set(items)];
+}
+/** Best-effort read of the user's configured Claude model, for the cost estimate. */
+function detectModel(home) {
+    for (const file of [
+        node_path_1.default.join(home, ".claude", "settings.json"),
+        node_path_1.default.join(home, ".claude.json"),
+    ]) {
+        if (!isFile(file))
+            continue;
+        let json;
+        try {
+            json = JSON.parse(readFileSafe(file));
+        }
+        catch {
+            continue;
+        }
+        const raw = json?.model;
+        const value = typeof raw === "string" ? raw.toLowerCase() : "";
+        if (value.includes("opus"))
+            return "opus";
+        if (value.includes("haiku"))
+            return "haiku";
+        if (value.includes("sonnet"))
+            return "sonnet";
+    }
+    return null;
+}
+/** Recursively list files under `dir` whose name ends with one of `exts`. */
+function walkFiles(dir, exts) {
+    if (!isDir(dir))
+        return [];
+    const out = [];
+    const stack = [dir];
+    while (stack.length && out.length < constants_1.HEAVY_WALK_MAX_FILES) {
+        const cur = stack.pop();
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(cur, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = node_path_1.default.join(cur, e.name);
+            if (e.isDirectory()) {
+                stack.push(full);
+            }
+            else if (e.isFile() && exts.some((x) => e.name.endsWith(x))) {
+                out.push(full);
+            }
+        }
+    }
+    return out.sort();
+}
+// ---------------------------------------------------------------------------
+// heavy paths + ignore files
+// ---------------------------------------------------------------------------
+exports.HEAVY_DIRS = [
+    // JS / web
+    "node_modules", "dist", "build", "out", "coverage", "vendor",
+    ".next", ".nuxt", ".svelte-kit", ".output", ".angular", ".turbo",
+    ".parcel-cache", ".cache",
+    // python
+    ".venv", "venv", "__pycache__", ".pytest_cache", ".mypy_cache", ".ruff_cache",
+    // rust / java / go / ios / infra
+    "target", ".gradle", "Pods", ".terraform",
+    // editor / misc
+    ".idea", "tmp", "logs",
+];
+exports.HEAVY_FILES = [
+    "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb", "deno.lock",
+    "composer.lock", "Cargo.lock", "poetry.lock", "Pipfile.lock", "Gemfile.lock",
+    "go.sum",
+];
+exports.DEFAULT_IGNORE_PATTERNS = [
+    "node_modules/", "dist/", "build/", "out/", "coverage/", "vendor/",
+    ".next/", ".nuxt/", ".svelte-kit/", ".output/", ".turbo/", ".parcel-cache/", ".cache/",
+    ".venv/", "venv/", "__pycache__/", ".pytest_cache/", ".mypy_cache/", ".ruff_cache/",
+    "target/", ".gradle/", "Pods/", ".terraform/", ".idea/", "tmp/", "logs/",
+    "*.lock", "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "go.sum",
+    "*.min.js", "*.min.css", "*.map", "*.log",
+    ".env", ".env.*", ".DS_Store", ".git/",
+];
+function parseIgnore(content) {
+    return content
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && !l.startsWith("#"));
+}
+function ignoreCovers(patterns, name) {
+    const norm = patterns.map((p) => p.replace(/^\.\//, "").replace(/\/$/, ""));
+    return norm.includes(name) || norm.includes("/" + name);
+}
+function walkBytes(dir) {
+    let bytes = 0;
+    let files = 0;
+    const stack = [dir];
+    while (stack.length) {
+        const cur = stack.pop();
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(cur, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = node_path_1.default.join(cur, e.name);
+            if (e.isDirectory()) {
+                stack.push(full);
+            }
+            else if (e.isFile()) {
+                try {
+                    bytes += node_fs_1.default.statSync(full).size;
+                }
+                catch {
+                    /* ignore unreadable file */
+                }
+                files++;
+            }
+            if (files >= constants_1.HEAVY_WALK_MAX_FILES || bytes >= constants_1.HEAVY_WALK_MAX_BYTES) {
+                return bytes;
+            }
+        }
+    }
+    return bytes;
+}
+/** Capped, bounded token estimate for a heavy dir or file that could be read. */
+function estimatePathTokens(p) {
+    let bytes = 0;
+    if (isDir(p)) {
+        bytes = walkBytes(p);
+    }
+    else {
+        try {
+            bytes = node_fs_1.default.statSync(p).size;
+        }
+        catch {
+            bytes = 0;
+        }
+    }
+    return Math.min((0, tokens_1.estimateTokensFromBytes)(bytes), constants_1.HEAVY_PATH_TOKEN_CAP);
+}
+// ---------------------------------------------------------------------------
+// MCP servers (any JSON config exposing `mcpServers`)
+// ---------------------------------------------------------------------------
+function readMcpServers(file) {
+    if (!isFile(file))
+        return [];
+    let json;
+    try {
+        json = JSON.parse(readFileSafe(file));
+    }
+    catch {
+        return []; // malformed JSON — skip rather than guess
+    }
+    const servers = json?.mcpServers;
+    if (servers && typeof servers === "object") {
+        return Object.keys(servers);
+    }
+    return [];
+}
+// ---------------------------------------------------------------------------
+// Claude-specific definition inventory (agents / skills / commands)
+// ---------------------------------------------------------------------------
+const JUNK_RE = /(\.bak|\.orig|\.tmp|\.swp|~)$/i;
+const JUNK_NAMES = new Set([".DS_Store", "Thumbs.db"]);
+function dirTokens(dir) {
+    return (0, tokens_1.estimateTokensFromBytes)(walkBytes(dir));
+}
+function scanDefinitions(o) {
+    const dead = [];
+    const real = [];
+    const roots = [
+        ["agents", node_path_1.default.join(o.home, ".claude", "agents")],
+        ["commands", node_path_1.default.join(o.home, ".claude", "commands")],
+        ["skills", node_path_1.default.join(o.home, ".claude", "skills")],
+    ];
+    for (const [kind, root] of roots) {
+        if (!isDir(root))
+            continue;
+        if (kind === "skills") {
+            scanSkillRoot(root, dead, real);
+        }
+        else {
+            scanFlatRoot(root, dead, real);
+        }
+    }
+    return { dead, real };
+}
+/** agents/ and commands/ hold .md definition files (possibly nested). */
+function scanFlatRoot(root, dead, real) {
+    const stack = [root];
+    while (stack.length) {
+        const cur = stack.pop();
+        let entries;
+        try {
+            entries = node_fs_1.default.readdirSync(cur, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const full = node_path_1.default.join(cur, e.name);
+            if (e.isDirectory()) {
+                stack.push(full);
+                continue;
+            }
+            if (!e.isFile())
+                continue;
+            classifyFile(full, e.name, dead, real);
+        }
+    }
+}
+/** skills/ holds one folder per skill, each requiring a SKILL.md. */
+function scanSkillRoot(root, dead, real) {
+    let entries;
+    try {
+        entries = node_fs_1.default.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        const full = node_path_1.default.join(root, e.name);
+        if (e.isFile()) {
+            classifyFile(full, e.name, dead, real);
+            continue;
+        }
+        if (!e.isDirectory())
+            continue;
+        const skillMd = node_path_1.default.join(full, "SKILL.md");
+        if (!isFile(skillMd)) {
+            dead.push({
+                path: full,
+                reason: "skill folder missing SKILL.md (cannot load)",
+                tokens: dirTokens(full),
+            });
+            continue;
+        }
+        real.push({
+            path: full,
+            reason: "skill",
+            tokens: (0, tokens_1.estimateTokens)(readFileSafe(skillMd)),
+        });
+    }
+}
+function classifyFile(full, name, dead, real) {
+    if (JUNK_NAMES.has(name) || JUNK_RE.test(name)) {
+        dead.push({
+            path: full,
+            reason: "backup/temp artifact",
+            tokens: (0, tokens_1.estimateTokens)(readFileSafe(full)),
+        });
+        return;
+    }
+    const content = readFileSafe(full);
+    if (content.trim() === "") {
+        dead.push({ path: full, reason: "empty definition file", tokens: 0 });
+        return;
+    }
+    if (name.toLowerCase().endsWith(".md")) {
+        real.push({ path: full, reason: "definition", tokens: (0, tokens_1.estimateTokens)(content) });
+    }
+}
+function archivePathFor(p, home) {
+    const base = node_path_1.default.join(home, ".claude");
+    const rel = p.startsWith(base) ? node_path_1.default.relative(base, p) : node_path_1.default.basename(p);
+    return node_path_1.default.join(home, ".claude", ".ctxdiet-archive", rel);
+}

package/dist/src/tokens.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTokens = estimateTokens;
+exports.estimateTokensFromBytes = estimateTokensFromBytes;
+const constants_1 = require("./constants");
+/**
+ * Estimate tokens with the documented chars/4 heuristic. This is an estimate,
+ * not a real tokenizer — see README.
+ */
+function estimateTokens(text) {
+    return Math.ceil(text.length / constants_1.CHARS_PER_TOKEN);
+}
+/** Same heuristic from a byte count (bytes ≈ chars for the text we read). */
+function estimateTokensFromBytes(bytes) {
+    return Math.ceil(bytes / constants_1.CHARS_PER_TOKEN);
+}

package/dist/src/trim.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimMarkdown = trimMarkdown;
+/**
+ * Conservative CLAUDE.md/AGENTS.md trimmer. Only removes *provably* redundant
+ * content so a trim is always safe and reversible (callers also keep a .bak):
+ *   - trailing whitespace on every line
+ *   - runs of blank lines collapsed to a single blank line
+ *   - exact-duplicate headers (only the first kept)
+ *   - exact-duplicate substantial prose lines (>=20 chars, not lists/structural)
+ * Anything inside fenced code blocks is left untouched.
+ */
+function trimMarkdown(input) {
+    const lines = input.split("\n");
+    const out = [];
+    const seenLines = new Set();
+    const seenHeaders = new Set();
+    let inFence = false;
+    let blankRun = 0;
+    for (const raw of lines) {
+        const line = raw.replace(/[ \t]+$/g, "");
+        const isFenceToggle = /^\s*```/.test(line);
+        if (isFenceToggle) {
+            inFence = !inFence;
+            blankRun = 0;
+            out.push(line);
+            continue;
+        }
+        if (inFence) {
+            out.push(line);
+            continue;
+        }
+        if (line.trim() === "") {
+            blankRun++;
+            if (blankRun > 1)
+                continue; // collapse blank runs to one
+            out.push("");
+            continue;
+        }
+        blankRun = 0;
+        const trimmed = line.trim();
+        // Dedupe identical headers (keep first occurrence).
+        if (/^#{1,6}\s+\S/.test(trimmed)) {
+            const key = trimmed.toLowerCase();
+            if (seenHeaders.has(key))
+                continue;
+            seenHeaders.add(key);
+            out.push(line);
+            continue;
+        }
+        // Dedupe exact-duplicate substantial lines (prose or list items) — a
+        // repeated line of real length is almost always an accidental paste. Skip
+        // pure structural markers (rules, bare table borders) where repetition is
+        // meaningful, and keep it reversible via the .bak the caller writes.
+        const isStructural = /^[-=|>#`]+$/.test(trimmed);
+        if (!isStructural && trimmed.length >= 20) {
+            if (seenLines.has(trimmed))
+                continue;
+            seenLines.add(trimmed);
+        }
+        out.push(line);
+    }
+    // Drop leading/trailing blank lines, guarantee a single trailing newline.
+    while (out.length && out[0] === "")
+        out.shift();
+    while (out.length && out[out.length - 1] === "")
+        out.pop();
+    return out.length ? out.join("\n") + "\n" : "";
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "ctxdiet",
+  "version": "0.1.0",
+  "description": "Detect, fix, and measure AI coding-agent context-token waste across Claude Code, Codex, Cursor, Gemini, Windsurf & Copilot. Other tools report waste — ctxdiet fixes it.",
+  "keywords": [
+    "claude",
+    "claude-code",
+    "codex",
+    "cursor",
+    "gemini",
+    "copilot",
+    "windsurf",
+    "agents",
+    "agents-md",
+    "mcp",
+    "tokens",
+    "context",
+    "cli",
+    "ai"
+  ],
+  "license": "MIT",
+  "author": "Merlijn de Groot <merlijndegroot498@gmail.com>",
+  "homepage": "https://github.com/Merlijnos/ctxdiet#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Merlijnos/ctxdiet.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Merlijnos/ctxdiet/issues"
+  },
+  "funding": "https://github.com/sponsors/Merlijnos",
+  "type": "commonjs",
+  "bin": {
+    "ctxdiet": "dist/src/index.js",
+    "slimclaude": "dist/src/index.js"
+  },
+  "files": [
+    "dist/src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "test": "tsc && node --test dist/test/*.test.js",
+    "prepublishOnly": "npm test",
+    "start": "node dist/src/index.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "diff": "^5.2.0"
+  },
+  "devDependencies": {
+    "@types/diff": "^5.2.3",
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  }
+}