ctxdiet 0.1.0

package/dist/src/report.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printScanResult = printScanResult;
+exports.printBeforeAfter = printBeforeAfter;
+exports.toJson = toJson;
+const chalk_1 = __importDefault(require("chalk"));
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const pricing_1 = require("./pricing");
+const sources_1 = require("./sources");
+const fmt = (n) => Math.round(n).toLocaleString("en-US");
+const usd = (n) => `$${n.toFixed(2)}`;
+function dollars(tokens, o) {
+    return usd((0, pricing_1.monthlyCost)(tokens, o.sessionsPerMonth, o.model));
+}
+function gradeBadge(g) {
+    const paint = g === "A" || g === "B"
+        ? chalk_1.default.bgGreen.black
+        : g === "C"
+            ? chalk_1.default.bgYellow.black
+            : chalk_1.default.bgRed.white;
+    return paint.bold(` ${g} `);
+}
+function printScanResult(r, o) {
+    if (o.json) {
+        console.log(JSON.stringify(toJson(r), null, 2));
+        return;
+    }
+    console.log();
+    console.log(chalk_1.default.bold("ctxdiet") +
+        chalk_1.default.dim(`  ·  ${(0, sources_1.shortenPath)(o.path, o.home)}  ·  grade `) +
+        gradeBadge(r.grade));
+    if (r.detectedAgents.length === 0) {
+        console.log();
+        console.log(chalk_1.default.dim("No agent setup detected here. Supported: Claude Code, Codex/AGENTS.md, " +
+            "Cursor, Gemini CLI, Windsurf, GitHub Copilot."));
+        console.log();
+        return;
+    }
+    console.log(chalk_1.default.dim("Detected agents: ") +
+        r.detectedAgents.map((a) => chalk_1.default.cyan(a.label)).join(chalk_1.default.dim(", ")));
+    console.log();
+    const high = r.findings.filter((f) => f.confidence === "high");
+    const low = r.findings.filter((f) => f.confidence === "low");
+    const table = new cli_table3_1.default({
+        head: ["Agent", "Type", "Finding", "Tokens/session", "$/month"].map((h) => chalk_1.default.bold(h)),
+        colAligns: ["left", "left", "left", "right", "right"],
+        style: { head: [], border: [] },
+    });
+    for (const agent of r.detectedAgents) {
+        const items = high.filter((f) => f.agent === agent.label);
+        if (items.length === 0) {
+            const hasReview = low.some((f) => f.agent === agent.label);
+            table.push([
+                agent.label,
+                "—",
+                hasReview
+                    ? chalk_1.default.dim("review items below")
+                    : chalk_1.default.green("clean"),
+                chalk_1.default.dim("0"),
+                chalk_1.default.dim("$0.00"),
+            ]);
+            continue;
+        }
+        for (const f of items) {
+            table.push([
+                agent.label,
+                f.category,
+                f.title,
+                f.tokensPerSession > 0
+                    ? chalk_1.default.green(fmt(f.tokensPerSession))
+                    : chalk_1.default.dim("0"),
+                f.tokensPerSession > 0
+                    ? chalk_1.default.green(dollars(f.tokensPerSession, o))
+                    : chalk_1.default.dim("$0.00"),
+            ]);
+        }
+    }
+    console.log(table.toString());
+    console.log();
+    // Headline — the whole pitch.
+    const acrossNote = r.detectedAgents.length > 1
+        ? chalk_1.default.dim(` (summed across ${r.detectedAgents.length} agents)`)
+        : "";
+    console.log(chalk_1.default.bold("Estimated savings if fixed: ") +
+        chalk_1.default.bold.green(`~${fmt(r.headlineSavings)} tokens/session (~${dollars(r.headlineSavings, o)}/month)`) +
+        acrossNote);
+    // LOW-confidence review section — explicitly not counted above.
+    if (low.length > 0) {
+        console.log();
+        console.log(chalk_1.default.yellow.bold("Review — ctxdiet won't change these on its own"));
+        console.log(chalk_1.default.dim("They cost tokens every session; only you know if they're still in use."));
+        const reviewTable = new cli_table3_1.default({
+            head: ["Agent", "Type", "Item", "Est. tokens/session"].map((h) => chalk_1.default.dim(h)),
+            colAligns: ["left", "left", "left", "right"],
+            style: { head: [], border: [] },
+        });
+        for (const f of low) {
+            reviewTable.push([
+                f.agent,
+                f.category,
+                f.title,
+                chalk_1.default.yellow(fmt(f.tokensPerSession)),
+            ]);
+        }
+        console.log(reviewTable.toString());
+        console.log(chalk_1.default.yellow(`Optional: ~${fmt(r.lowConfidencePotential)} tokens/session ` +
+            `(~${dollars(r.lowConfidencePotential, o)}/month) if you disable what you don't need.`));
+    }
+    const modelNote = o.modelDetected ? " (from your Claude config)" : "";
+    console.log();
+    console.log(chalk_1.default.dim(`Estimate: chars/4 at ${o.model} pricing${modelNote}, ${o.sessionsPerMonth} sessions/month. ` +
+        `Run \`npx ctxdiet fix\` to apply.`));
+    console.log();
+}
+// ---------------------------------------------------------------------------
+// before/after money shot
+// ---------------------------------------------------------------------------
+function printBeforeAfter(before, after, o, lowApplied) {
+    const savedTokens = before.baselineTokens - after.baselineTokens;
+    const beforeCost = (0, pricing_1.monthlyCost)(before.baselineTokens, o.sessionsPerMonth, o.model);
+    const afterCost = (0, pricing_1.monthlyCost)(after.baselineTokens, o.sessionsPerMonth, o.model);
+    const arrow = chalk_1.default.dim("→");
+    const table = new cli_table3_1.default({
+        head: ["", "Before", "", "After", "Saved"].map((h) => chalk_1.default.bold(h)),
+        colAligns: ["left", "right", "left", "right", "right"],
+        style: { head: [], border: [] },
+    });
+    table.push([
+        "Context tokens/session",
+        fmt(before.baselineTokens),
+        arrow,
+        fmt(after.baselineTokens),
+        chalk_1.default.green(fmt(savedTokens)),
+    ]);
+    table.push([
+        "$/month",
+        usd(beforeCost),
+        arrow,
+        usd(afterCost),
+        chalk_1.default.green(usd(beforeCost - afterCost)),
+    ]);
+    table.push(["Grade", gradeBadge(before.grade), arrow, gradeBadge(after.grade), ""]);
+    console.log();
+    console.log(chalk_1.default.bold("Before vs after"));
+    console.log(table.toString());
+    if (lowApplied > 0) {
+        console.log(chalk_1.default.dim(`Includes ~${fmt(lowApplied)} tokens/session from review items you chose to disable.`));
+    }
+    console.log();
+}
+// ---------------------------------------------------------------------------
+// JSON serialization (no large blobs)
+// ---------------------------------------------------------------------------
+function toJson(r) {
+    const { options } = r;
+    return {
+        path: options.path,
+        model: options.model,
+        sessionsPerMonth: options.sessionsPerMonth,
+        method: "chars/4 heuristic — estimate only; usage history not analyzed",
+        detectedAgents: r.detectedAgents,
+        grade: r.grade,
+        baselineTokens: r.baselineTokens,
+        headlineSavingsTokens: r.headlineSavings,
+        headlineSavingsUsdPerMonth: Number((0, pricing_1.monthlyCost)(r.headlineSavings, options.sessionsPerMonth, options.model).toFixed(2)),
+        lowConfidencePotentialTokens: r.lowConfidencePotential,
+        findings: r.findings.map((f) => ({
+            agent: f.agent,
+            category: f.category,
+            title: f.title,
+            detail: f.detail,
+            tokensPerSession: f.tokensPerSession,
+            confidence: f.confidence,
+            fixable: f.fixable,
+            manualReview: f.manualReview ?? false,
+        })),
+    };
+}

package/dist/src/scan.js

@@ -0,0 +1,211 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scan = scan;
+const node_path_1 = __importDefault(require("node:path"));
+const agents_1 = require("./agents");
+const constants_1 = require("./constants");
+const src = __importStar(require("./sources"));
+const tokens_1 = require("./tokens");
+const trim_1 = require("./trim");
+/** Heavy dirs/files present in the project, sized once and reused per agent. */
+function presentHeavyPaths(o) {
+    const out = [];
+    for (const name of [...src.HEAVY_DIRS, ...src.HEAVY_FILES]) {
+        const full = node_path_1.default.join(o.path, name);
+        if (!src.isFile(full) && !src.isDir(full))
+            continue;
+        out.push({ name, tokens: src.estimatePathTokens(full) });
+    }
+    return out;
+}
+/**
+ * Pure scan: detects active agents, reads their persistent context, returns
+ * findings + metrics. No printing, no writes — safe to call before/after a fix.
+ */
+function scan(o) {
+    const findings = [];
+    let baselineTokens = 0;
+    const agents = (0, agents_1.detectAgents)(o);
+    const heavy = presentHeavyPaths(o);
+    for (const agent of agents) {
+        baselineTokens += scanAgent(agent, o, heavy, findings);
+    }
+    const headlineSavings = findings
+        .filter((f) => f.confidence === "high")
+        .reduce((s, f) => s + f.tokensPerSession, 0);
+    const lowConfidencePotential = findings
+        .filter((f) => f.confidence === "low")
+        .reduce((s, f) => s + f.tokensPerSession, 0);
+    return {
+        options: o,
+        detectedAgents: agents.map((a) => ({ id: a.id, label: a.label })),
+        findings,
+        baselineTokens,
+        headlineSavings,
+        lowConfidencePotential,
+        grade: (0, constants_1.grade)(headlineSavings),
+    };
+}
+/** Scan a single agent; returns its baseline-token contribution. */
+function scanAgent(agent, o, heavy, findings) {
+    let baseline = 0;
+    // --- Memory / instruction files (HIGH-confidence, auto-trimmable) ---
+    for (const file of agent.memoryFiles(o)) {
+        if (!src.isFile(file))
+            continue;
+        const original = src.readFileSafe(file);
+        const origTokens = (0, tokens_1.estimateTokens)(original);
+        baseline += origTokens;
+        const trimmed = (0, trim_1.trimMarkdown)(original);
+        const saved = origTokens - (0, tokens_1.estimateTokens)(trimmed);
+        const label = src.displayPath(file, o.path, o.home);
+        if (saved > 0) {
+            findings.push({
+                agent: agent.label,
+                category: "Memory",
+                title: `${label}: ${saved.toLocaleString()} redundant tokens`,
+                detail: "duplicate lines, blank runs, trailing whitespace",
+                tokensPerSession: saved,
+                confidence: "high",
+                fixable: true,
+                action: { type: "trim", path: file },
+            });
+        }
+        else if (origTokens > constants_1.LARGE_CLAUDEMD_TOKENS) {
+            findings.push({
+                agent: agent.label,
+                category: "Memory",
+                title: `${label}: large (${origTokens.toLocaleString()} tokens)`,
+                detail: "no auto-trimmable redundancy — shorten manually",
+                tokensPerSession: 0,
+                confidence: "high",
+                fixable: false,
+                manualReview: true,
+            });
+        }
+    }
+    // --- Ignore file (HIGH-confidence, auto-fixable) ---
+    if (agent.ignoreFile && heavy.length > 0) {
+        const ignorePath = node_path_1.default.join(o.path, agent.ignoreFile);
+        const ignoreExists = src.isFile(ignorePath);
+        const content = ignoreExists ? src.readFileSafe(ignorePath) : null;
+        const patterns = content ? src.parseIgnore(content) : [];
+        const uncovered = heavy.filter((h) => !src.ignoreCovers(patterns, h.name));
+        const heavyTokens = uncovered.reduce((s, h) => s + h.tokens, 0);
+        if (uncovered.length > 0) {
+            baseline += heavyTokens;
+            const names = uncovered.map((h) => h.name);
+            const missingDefaults = src.DEFAULT_IGNORE_PATTERNS.filter((p) => !patterns.includes(p));
+            findings.push({
+                agent: agent.label,
+                category: "Ignore",
+                title: content === null
+                    ? `${agent.ignoreFile} missing — ${uncovered.length} heavy path(s) unignored`
+                    : `${agent.ignoreFile} weak — ${uncovered.length} heavy path(s) unignored`,
+                detail: names.join(", "),
+                tokensPerSession: heavyTokens,
+                confidence: "high",
+                fixable: true,
+                action: content === null
+                    ? {
+                        type: "ignore-create",
+                        path: ignorePath,
+                        content: src.DEFAULT_IGNORE_PATTERNS.join("\n") + "\n",
+                    }
+                    : { type: "ignore-augment", path: ignorePath, added: missingDefaults },
+            });
+        }
+    }
+    // --- MCP servers (LOW-confidence, review only) ---
+    for (const file of agent.mcpFiles(o)) {
+        for (const server of src.readMcpServers(file)) {
+            baseline += constants_1.MCP_SERVER_TOKEN_EST;
+            findings.push({
+                agent: agent.label,
+                category: "MCP",
+                title: `${server} (${src.displayPath(file, o.path, o.home)})`,
+                detail: "usage not confirmed — disable only if you know you don't use it",
+                tokensPerSession: constants_1.MCP_SERVER_TOKEN_EST,
+                confidence: "low",
+                fixable: true,
+                manualReview: true,
+                action: { type: "mcp-disable", path: file, server },
+            });
+        }
+    }
+    // --- Definition inventory (Claude-style ~/.claude only) ---
+    if (agent.ownsDefinitions) {
+        const inv = src.scanDefinitions(o);
+        for (const dead of inv.dead) {
+            baseline += dead.tokens;
+            findings.push({
+                agent: agent.label,
+                category: "Definitions",
+                title: `${src.displayPath(dead.path, o.path, o.home)} — ${dead.reason}`,
+                tokensPerSession: dead.tokens,
+                confidence: "high",
+                fixable: true,
+                action: {
+                    type: "archive",
+                    path: dead.path,
+                    archiveTo: src.archivePathFor(dead.path, o.home),
+                },
+            });
+        }
+        for (const real of inv.real) {
+            baseline += real.tokens;
+            findings.push({
+                agent: agent.label,
+                category: "Definitions",
+                title: src.displayPath(real.path, o.path, o.home),
+                detail: "usage not confirmed — remove only if you recognize it as unused",
+                tokensPerSession: real.tokens,
+                confidence: "low",
+                fixable: true,
+                manualReview: true,
+                action: {
+                    type: "archive",
+                    path: real.path,
+                    archiveTo: src.archivePathFor(real.path, o.home),
+                },
+            });
+        }
+    }
+    return baseline;
+}