claudectx 1.0.0

package/dist/index.mjs

@@ -0,0 +1,3008 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/analyzer/tokenizer.ts
+import { get_encoding } from "js-tiktoken";
+function getEncoder() {
+  if (!encoder) {
+    encoder = get_encoding("cl100k_base");
+  }
+  return encoder;
+}
+function countTokens(text) {
+  if (!text || text.length === 0) return 0;
+  try {
+    return getEncoder().encode(text).length;
+  } catch {
+    return Math.ceil(text.length / 4);
+  }
+}
+var encoder;
+var init_tokenizer = __esm({
+  "src/analyzer/tokenizer.ts"() {
+    "use strict";
+    init_esm_shims();
+    encoder = null;
+  }
+});
+
+// src/shared/models.ts
+function resolveModel(input) {
+  const lower = input.toLowerCase();
+  if (lower in MODEL_ALIASES) return MODEL_ALIASES[lower];
+  if (lower in MODEL_PRICING) return lower;
+  return DEFAULT_MODEL;
+}
+function calculateCost(tokens, model) {
+  if (tokens === 0) return 0;
+  return tokens / 1e6 * MODEL_PRICING[model].inputPerMillion;
+}
+var MODEL_PRICING, DEFAULT_MODEL, MODEL_ALIASES;
+var init_models = __esm({
+  "src/shared/models.ts"() {
+    "use strict";
+    init_esm_shims();
+    MODEL_PRICING = {
+      "claude-haiku-4-5": {
+        inputPerMillion: 1,
+        outputPerMillion: 5,
+        cacheReadPerMillion: 0.1,
+        cacheWritePerMillion: 1.25,
+        contextWindow: 2e5
+      },
+      "claude-sonnet-4-6": {
+        inputPerMillion: 3,
+        outputPerMillion: 15,
+        cacheReadPerMillion: 0.3,
+        cacheWritePerMillion: 3.75,
+        contextWindow: 1e6
+      },
+      "claude-opus-4-6": {
+        inputPerMillion: 5,
+        outputPerMillion: 25,
+        cacheReadPerMillion: 0.5,
+        cacheWritePerMillion: 6.25,
+        contextWindow: 1e6
+      }
+    };
+    DEFAULT_MODEL = "claude-sonnet-4-6";
+    MODEL_ALIASES = {
+      haiku: "claude-haiku-4-5",
+      sonnet: "claude-sonnet-4-6",
+      opus: "claude-opus-4-6",
+      "claude-haiku": "claude-haiku-4-5",
+      "claude-sonnet": "claude-sonnet-4-6",
+      "claude-opus": "claude-opus-4-6"
+    };
+  }
+});
+
+// src/watcher/session-store.ts
+var session_store_exports = {};
+__export(session_store_exports, {
+  aggregateStats: () => aggregateStats,
+  appendFileRead: () => appendFileRead,
+  clearStore: () => clearStore,
+  getReadsFilePath: () => getReadsFilePath,
+  getStoreDir: () => getStoreDir,
+  readAllEvents: () => readAllEvents
+});
+import * as fs8 from "fs";
+import * as os2 from "os";
+import * as path9 from "path";
+function getStoreDirPath() {
+  return path9.join(os2.homedir(), ".claudectx");
+}
+function getReadsFilePath_() {
+  return path9.join(getStoreDirPath(), "reads.jsonl");
+}
+function ensureStoreDir() {
+  const dir = getStoreDirPath();
+  if (!fs8.existsSync(dir)) {
+    fs8.mkdirSync(dir, { recursive: true });
+  }
+}
+function appendFileRead(filePath, sessionId) {
+  ensureStoreDir();
+  const event = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    filePath,
+    sessionId
+  };
+  fs8.appendFileSync(getReadsFilePath_(), JSON.stringify(event) + "\n", "utf-8");
+}
+function readAllEvents() {
+  const readsFile = getReadsFilePath_();
+  if (!fs8.existsSync(readsFile)) return [];
+  const lines = fs8.readFileSync(readsFile, "utf-8").trim().split("\n").filter(Boolean);
+  return lines.map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((e) => e !== null);
+}
+function aggregateStats(events) {
+  const map = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const existing = map.get(e.filePath);
+    if (existing) {
+      existing.readCount++;
+      existing.lastSeen = e.timestamp;
+    } else {
+      map.set(e.filePath, {
+        filePath: e.filePath,
+        readCount: 1,
+        firstSeen: e.timestamp,
+        lastSeen: e.timestamp
+      });
+    }
+  }
+  return [...map.values()].sort((a, b) => b.readCount - a.readCount);
+}
+function clearStore() {
+  const readsFile = getReadsFilePath_();
+  if (fs8.existsSync(readsFile)) {
+    fs8.writeFileSync(readsFile, "", "utf-8");
+  }
+}
+function getReadsFilePath() {
+  return getReadsFilePath_();
+}
+function getStoreDir() {
+  return getStoreDirPath();
+}
+var init_session_store = __esm({
+  "src/watcher/session-store.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/watcher/session-reader.ts
+import * as fs9 from "fs";
+import * as os3 from "os";
+import * as path10 from "path";
+function listSessionFiles() {
+  if (!fs9.existsSync(CLAUDE_PROJECTS_DIR)) return [];
+  const results = [];
+  try {
+    const projectDirs = fs9.readdirSync(CLAUDE_PROJECTS_DIR);
+    for (const projectDir of projectDirs) {
+      const projectPath = path10.join(CLAUDE_PROJECTS_DIR, projectDir);
+      try {
+        const stat = fs9.statSync(projectPath);
+        if (!stat.isDirectory()) continue;
+        const files = fs9.readdirSync(projectPath).filter((f) => f.endsWith(".jsonl"));
+        for (const file of files) {
+          const filePath = path10.join(projectPath, file);
+          try {
+            const fstat = fs9.statSync(filePath);
+            results.push({
+              filePath,
+              mtimeMs: fstat.mtimeMs,
+              sessionId: path10.basename(file, ".jsonl"),
+              projectDir
+            });
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+  } catch {
+    return [];
+  }
+  return results.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+function findSessionFile(sessionId) {
+  const files = listSessionFiles();
+  if (files.length === 0) return null;
+  if (sessionId) {
+    const match = files.find((f) => f.sessionId === sessionId);
+    return match?.filePath ?? null;
+  }
+  return files[0]?.filePath ?? null;
+}
+function readSessionUsage(sessionFilePath) {
+  const result = {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    requestCount: 0
+  };
+  if (!fs9.existsSync(sessionFilePath)) return result;
+  let content;
+  try {
+    content = fs9.readFileSync(sessionFilePath, "utf-8");
+  } catch {
+    return result;
+  }
+  const lines = content.trim().split("\n").filter(Boolean);
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      const usage = entry.usage ?? entry.message?.usage;
+      if (!usage) continue;
+      const isAssistant = entry.type === "assistant" || entry.message?.role === "assistant";
+      if (isAssistant) {
+        result.inputTokens += usage.input_tokens ?? 0;
+        result.outputTokens += usage.output_tokens ?? 0;
+        result.cacheCreationTokens += usage.cache_creation_input_tokens ?? 0;
+        result.cacheReadTokens += usage.cache_read_input_tokens ?? 0;
+        result.requestCount++;
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+var CLAUDE_PROJECTS_DIR;
+var init_session_reader = __esm({
+  "src/watcher/session-reader.ts"() {
+    "use strict";
+    init_esm_shims();
+    CLAUDE_PROJECTS_DIR = path10.join(os3.homedir(), ".claude", "projects");
+  }
+});
+
+// src/components/Dashboard.tsx
+var Dashboard_exports = {};
+__export(Dashboard_exports, {
+  Dashboard: () => Dashboard
+});
+import { useState, useEffect, useCallback } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import * as fs10 from "fs";
+import * as path11 from "path";
+import { jsx, jsxs } from "react/jsx-runtime";
+function fmtNum(n) {
+  return n.toLocaleString();
+}
+function fmtCost(tokens, model) {
+  const p = MODEL_PRICING[model];
+  const cost = tokens / 1e6 * p.inputPerMillion;
+  return `$${cost.toFixed(4)}`;
+}
+function shortPath(filePath) {
+  const parts = filePath.split(path11.sep);
+  if (parts.length <= 3) return filePath;
+  return "\u2026/" + parts.slice(-3).join("/");
+}
+function padEnd(str, len) {
+  return str.length >= len ? str.slice(0, len) : str + " ".repeat(len - str.length);
+}
+function padStart(str, len) {
+  return str.length >= len ? str.slice(0, len) : " ".repeat(len - str.length) + str;
+}
+function Spinner({ tick }) {
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  return /* @__PURE__ */ jsx(Text, { color: "cyan", children: frames[tick % frames.length] });
+}
+function SectionTitle({ children }) {
+  return /* @__PURE__ */ jsx(Box, { marginBottom: 0, children: /* @__PURE__ */ jsx(Text, { bold: true, underline: true, color: "white", children }) });
+}
+function UsagePanel({
+  usage,
+  model
+}) {
+  const totalBillable = usage.inputTokens + usage.outputTokens;
+  const cacheHitPct = usage.inputTokens > 0 ? (usage.cacheReadTokens / usage.inputTokens * 100).toFixed(1) : "0.0";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(SectionTitle, { children: "Token Usage" }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Input:            " }),
+      /* @__PURE__ */ jsx(Text, { color: "yellow", children: fmtNum(usage.inputTokens) }),
+      usage.cacheReadTokens > 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  (${fmtNum(usage.cacheReadTokens)} from cache, ${cacheHitPct}% hit)` })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Output:           " }),
+      /* @__PURE__ */ jsx(Text, { color: "green", children: fmtNum(usage.outputTokens) })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Cache writes:     " }),
+      /* @__PURE__ */ jsx(Text, { color: "cyan", children: fmtNum(usage.cacheCreationTokens) })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Requests:         " }),
+      /* @__PURE__ */ jsx(Text, { children: usage.requestCount })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  Estimated cost:   " }),
+      /* @__PURE__ */ jsx(Text, { color: "magenta", children: fmtCost(totalBillable, model) })
+    ] })
+  ] });
+}
+function FileTable({ stats }) {
+  const COL_NUM = 4;
+  const COL_READS = 6;
+  const COL_FILE = 55;
+  if (stats.length === 0) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(SectionTitle, { children: "Files Read" }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "  No file reads tracked yet.\n  Install hooks first: ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "claudectx optimize --hooks" })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(SectionTitle, { children: `Files Read  (${stats.length} unique)` }),
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: padStart("#", COL_NUM) + "  " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: padEnd("File", COL_FILE) + "  " }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: padStart("Reads", COL_READS) })
+    ] }),
+    stats.slice(0, 18).map((s, i) => /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: padStart(String(i + 1), COL_NUM) + "  " }),
+      /* @__PURE__ */ jsx(Text, { children: padEnd(shortPath(s.filePath), COL_FILE) + "  " }),
+      /* @__PURE__ */ jsx(Text, { color: s.readCount >= 3 ? "yellow" : "white", children: padStart(String(s.readCount), COL_READS) })
+    ] }, s.filePath)),
+    stats.length > 18 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: `  \u2026 and ${stats.length - 18} more` })
+  ] });
+}
+function Dashboard({
+  model = "claude-sonnet-4-6",
+  sessionId
+}) {
+  const { exit } = useApp();
+  const [state, setState] = useState({
+    fileStats: [],
+    usage: {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 0,
+      requestCount: 0
+    },
+    sessionFile: null,
+    lastUpdated: /* @__PURE__ */ new Date(),
+    tickCount: 0
+  });
+  const refresh = useCallback(() => {
+    const events = readAllEvents();
+    const fileStats2 = aggregateStats(events);
+    const sessionFile2 = sessionId ? findSessionFile(sessionId) : findSessionFile();
+    const usage2 = sessionFile2 ? readSessionUsage(sessionFile2) : {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 0,
+      requestCount: 0
+    };
+    setState((prev) => ({
+      fileStats: fileStats2,
+      usage: usage2,
+      sessionFile: sessionFile2,
+      lastUpdated: /* @__PURE__ */ new Date(),
+      tickCount: prev.tickCount + 1
+    }));
+  }, [sessionId]);
+  useEffect(() => {
+    refresh();
+    const interval = setInterval(refresh, 2e3);
+    const readsFile = getReadsFilePath();
+    let watcher = null;
+    const tryWatch = () => {
+      if (fs10.existsSync(readsFile)) {
+        try {
+          watcher = fs10.watch(readsFile, () => refresh());
+        } catch {
+        }
+      }
+    };
+    tryWatch();
+    const watchRetry = setTimeout(tryWatch, 3e3);
+    return () => {
+      clearInterval(interval);
+      clearTimeout(watchRetry);
+      watcher?.close();
+    };
+  }, [refresh]);
+  useEffect(() => {
+    const ticker = setInterval(() => {
+      setState((prev) => ({ ...prev, tickCount: prev.tickCount + 1 }));
+    }, 100);
+    return () => clearInterval(ticker);
+  }, []);
+  useInput((input, key) => {
+    if (input === "q" || input === "Q" || key.escape) {
+      exit();
+    }
+    if (input === "r" || input === "R") {
+      refresh();
+    }
+  });
+  const { fileStats, usage, sessionFile, lastUpdated, tickCount } = state;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 0, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Spinner, { tick: tickCount }),
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: " claudectx watch" }),
+      /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "  \u2014  Live Session Monitor  \u2014  ",
+        lastUpdated.toLocaleTimeString()
+      ] }),
+      sessionFile && /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+        "  \u2014  ",
+        path11.basename(sessionFile, ".jsonl").slice(0, 8),
+        "\u2026"
+      ] }),
+      !sessionFile && /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \u2014  no session file found" })
+    ] }),
+    /* @__PURE__ */ jsx(UsagePanel, { usage, model }),
+    /* @__PURE__ */ jsx(FileTable, { stats: fileStats }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "q" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " to quit  \u2022  " }),
+      /* @__PURE__ */ jsx(Text, { bold: true, children: "r" }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " to refresh  \u2022  Polls every 2s" })
+    ] })
+  ] });
+}
+var init_Dashboard = __esm({
+  "src/components/Dashboard.tsx"() {
+    "use strict";
+    init_esm_shims();
+    init_session_store();
+    init_session_reader();
+    init_models();
+  }
+});
+
+// src/mcp/smart-reader.ts
+import * as fs12 from "fs";
+import * as path14 from "path";
+function detectLanguage(filePath) {
+  const ext = path14.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".ts":
+    case ".tsx":
+      return "typescript";
+    case ".js":
+    case ".jsx":
+    case ".mjs":
+    case ".cjs":
+      return "javascript";
+    case ".py":
+      return "python";
+    default:
+      return "other";
+  }
+}
+function findSymbol(filePath, symbolName) {
+  if (!fs12.existsSync(filePath)) return null;
+  const content = fs12.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const lang = detectLanguage(filePath);
+  const patterns = lang === "python" ? PYTHON_PATTERNS : TS_JS_PATTERNS;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    for (const { pattern, type } of patterns) {
+      const match = line.match(pattern);
+      if (!match) continue;
+      const capturedName = match[1];
+      if (!capturedName || capturedName !== symbolName) continue;
+      const startLine = i + 1;
+      const endLine = lang === "python" ? findPythonBlockEnd(lines, i) : findBraceBlockEnd(lines, i);
+      const extracted = lines.slice(i, endLine).join("\n");
+      return {
+        name: capturedName,
+        type,
+        filePath,
+        startLine,
+        endLine,
+        content: extracted,
+        tokenCount: countTokens(extracted),
+        language: lang
+      };
+    }
+  }
+  return null;
+}
+function findBraceBlockEnd(lines, startIdx) {
+  let depth = 0;
+  let foundOpenBrace = false;
+  for (let i = startIdx; i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{") {
+        depth++;
+        foundOpenBrace = true;
+      } else if (ch === "}") {
+        depth--;
+        if (foundOpenBrace && depth === 0) {
+          return i + 1;
+        }
+      }
+    }
+  }
+  return Math.min(startIdx + 60, lines.length);
+}
+function findPythonBlockEnd(lines, startIdx) {
+  const baseLine = lines[startIdx];
+  const baseIndent = baseLine.length - baseLine.trimStart().length;
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "" || line.trim().startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    if (indent <= baseIndent) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+function extractLineRange(filePath, startLine, endLine, contextLines = 0) {
+  if (!fs12.existsSync(filePath)) return null;
+  const allLines = fs12.readFileSync(filePath, "utf-8").split("\n");
+  const totalLines = allLines.length;
+  const from = Math.max(0, startLine - 1 - contextLines);
+  const to = Math.min(totalLines, endLine + contextLines);
+  const extracted = allLines.slice(from, to).join("\n");
+  return {
+    filePath,
+    startLine: from + 1,
+    endLine: to,
+    content: extracted,
+    tokenCount: countTokens(extracted),
+    totalLines
+  };
+}
+function smartRead(filePath, symbol, startLine, endLine, contextLines = 3) {
+  if (!fs12.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  if (symbol) {
+    const extracted = findSymbol(filePath, symbol);
+    if (extracted) {
+      return {
+        content: extracted.content,
+        tokenCount: extracted.tokenCount,
+        filePath,
+        startLine: extracted.startLine,
+        endLine: extracted.endLine,
+        totalLines: fs12.readFileSync(filePath, "utf-8").split("\n").length,
+        truncated: false,
+        symbolName: symbol
+      };
+    }
+  }
+  if (startLine !== void 0 && endLine !== void 0) {
+    const result = extractLineRange(filePath, startLine, endLine, contextLines);
+    if (result) {
+      return { ...result, truncated: false };
+    }
+  }
+  const fullContent = fs12.readFileSync(filePath, "utf-8");
+  const allLines = fullContent.split("\n");
+  const totalLines = allLines.length;
+  const fullTokens = countTokens(fullContent);
+  if (fullTokens <= MAX_FULL_FILE_TOKENS) {
+    return {
+      content: fullContent,
+      tokenCount: fullTokens,
+      filePath,
+      startLine: 1,
+      endLine: totalLines,
+      totalLines,
+      truncated: false
+    };
+  }
+  let accumulated = "";
+  let lastLine = 0;
+  for (let i = 0; i < allLines.length; i++) {
+    const next = accumulated + allLines[i] + "\n";
+    if (countTokens(next) > MAX_FULL_FILE_TOKENS) break;
+    accumulated = next;
+    lastLine = i + 1;
+  }
+  return {
+    content: accumulated + `
+
+// ... file truncated at ${lastLine}/${totalLines} lines (token budget).
+// Use smart_read with a symbol name or line range to read more.`,
+    tokenCount: countTokens(accumulated),
+    filePath,
+    startLine: 1,
+    endLine: lastLine,
+    totalLines,
+    truncated: true
+  };
+}
+var TS_JS_PATTERNS, PYTHON_PATTERNS, MAX_FULL_FILE_TOKENS;
+var init_smart_reader = __esm({
+  "src/mcp/smart-reader.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_tokenizer();
+    TS_JS_PATTERNS = [
+      // export async function name / export function name / function name
+      { pattern: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/, type: "function" },
+      // export default function name
+      { pattern: /^export\s+default\s+(?:async\s+)?function\s+(\w+)?/, type: "function" },
+      // const/let/var name = (params) => / async (params) =>
+      { pattern: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:[(][^)]*[)]|\w+)\s*=>/, type: "function" },
+      // const/let name = function
+      { pattern: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?function/, type: "function" },
+      // export abstract class / export class / class
+      { pattern: /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/, type: "class" },
+      // export interface / interface
+      { pattern: /^(?:export\s+)?interface\s+(\w+)/, type: "interface" },
+      // export type Name = / type Name =
+      { pattern: /^(?:export\s+)?type\s+(\w+)\s*(?:<[^>]*>)?\s*=/, type: "type" },
+      // export enum / enum
+      { pattern: /^(?:export\s+)?(?:const\s+)?enum\s+(\w+)/, type: "type" },
+      // export const NAME (capital-snake — treat as variable)
+      { pattern: /^(?:export\s+)?const\s+([A-Z_][A-Z0-9_]+)\s*=/, type: "variable" },
+      // export const name (lowercase)
+      { pattern: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::\s*\S+)?\s*=/, type: "variable" }
+    ];
+    PYTHON_PATTERNS = [
+      { pattern: /^(?:async\s+)?def\s+(\w+)\s*\(/, type: "function" },
+      { pattern: /^class\s+(\w+)(?:\s*[(:]|$)/, type: "class" },
+      { pattern: /^([A-Z_][A-Z0-9_]+)\s*=/, type: "variable" }
+    ];
+    MAX_FULL_FILE_TOKENS = 8e3;
+  }
+});
+
+// src/mcp/symbol-index.ts
+import * as fs13 from "fs";
+import * as path15 from "path";
+import { glob } from "glob";
+function extractSymbolsFromFile(filePath) {
+  const lang = detectLanguage(filePath);
+  if (lang === "other") return [];
+  let content;
+  try {
+    content = fs13.readFileSync(filePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const lines = content.split("\n");
+  const extractors = lang === "python" ? PYTHON_EXTRACTORS : TS_JS_EXTRACTORS;
+  const results = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("#")) continue;
+    for (const { pattern, type } of extractors) {
+      const match = trimmed.match(pattern);
+      if (!match?.[1]) continue;
+      const name = match[1];
+      if (seenNames.has(name)) continue;
+      seenNames.add(name);
+      results.push({
+        name,
+        type,
+        filePath,
+        lineStart: i + 1,
+        signature: lines[i].trimEnd()
+      });
+      break;
+    }
+  }
+  return results;
+}
+var TS_JS_EXTRACTORS, PYTHON_EXTRACTORS, SOURCE_GLOBS, IGNORE_DIRS, SymbolIndex, globalIndex;
+var init_symbol_index = __esm({
+  "src/mcp/symbol-index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_smart_reader();
+    TS_JS_EXTRACTORS = [
+      { pattern: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/, type: "function" },
+      { pattern: /^export\s+default\s+(?:async\s+)?function\s+(\w+)/, type: "function" },
+      { pattern: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:[(][^)]*[)]|\w+)\s*=>/, type: "function" },
+      { pattern: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?function/, type: "function" },
+      { pattern: /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/, type: "class" },
+      { pattern: /^(?:export\s+)?interface\s+(\w+)/, type: "interface" },
+      { pattern: /^(?:export\s+)?type\s+(\w+)\s*(?:<[^>]*>)?\s*=/, type: "type" },
+      { pattern: /^(?:export\s+)?(?:const\s+)?enum\s+(\w+)/, type: "type" },
+      { pattern: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*(?::\s*\S+)?\s*=/, type: "variable" }
+    ];
+    PYTHON_EXTRACTORS = [
+      { pattern: /^(?:async\s+)?def\s+(\w+)\s*\(/, type: "function" },
+      { pattern: /^class\s+(\w+)(?:\s*[(:]|$)/, type: "class" },
+      { pattern: /^([A-Z_][A-Z0-9_]+)\s*=/, type: "variable" }
+    ];
+    SOURCE_GLOBS = [
+      "**/*.ts",
+      "**/*.tsx",
+      "**/*.js",
+      "**/*.jsx",
+      "**/*.mjs",
+      "**/*.py"
+    ];
+    IGNORE_DIRS = [
+      "node_modules/**",
+      "dist/**",
+      "build/**",
+      ".git/**",
+      "__pycache__/**",
+      "*.min.js",
+      "**/*.d.ts"
+    ];
+    SymbolIndex = class {
+      entries = [];
+      builtFor = null;
+      buildInProgress = false;
+      /** Build the index for a project root. Subsequent calls are no-ops if root matches. */
+      async build(projectRoot) {
+        if (this.builtFor === projectRoot) {
+          return { fileCount: 0, symbolCount: this.entries.length };
+        }
+        if (this.buildInProgress) {
+          await new Promise((r) => setTimeout(r, 200));
+          return { fileCount: 0, symbolCount: this.entries.length };
+        }
+        this.buildInProgress = true;
+        this.entries = [];
+        let files = [];
+        try {
+          files = await glob(SOURCE_GLOBS.map((g) => path15.join(projectRoot, g)), {
+            ignore: IGNORE_DIRS.map((g) => path15.join(projectRoot, g)),
+            absolute: true
+          });
+        } catch {
+        }
+        for (const file of files) {
+          const symbols = extractSymbolsFromFile(file);
+          this.entries.push(...symbols);
+        }
+        this.builtFor = projectRoot;
+        this.buildInProgress = false;
+        return { fileCount: files.length, symbolCount: this.entries.length };
+      }
+      /** Rebuild the index (e.g. after file changes). */
+      async rebuild(projectRoot) {
+        this.builtFor = null;
+        return this.build(projectRoot);
+      }
+      /**
+       * Search for symbols matching the query.
+       *
+       * @param query - Partial or full symbol name (case-insensitive substring match)
+       * @param type  - Optional filter by symbol type
+       * @param pathFilter - Optional substring filter on the file path
+       * @param limit - Max results to return (default 20)
+       */
+      search(query, type, pathFilter, limit = 20) {
+        const q = query.toLowerCase();
+        return this.entries.filter((e) => {
+          if (!e.name.toLowerCase().includes(q)) return false;
+          if (type && type !== "all" && e.type !== type) return false;
+          if (pathFilter && !e.filePath.includes(pathFilter)) return false;
+          return true;
+        }).slice(0, limit);
+      }
+      /** Total symbol count. */
+      get size() {
+        return this.entries.length;
+      }
+      /** Whether the index has been built. */
+      get isReady() {
+        return this.builtFor !== null;
+      }
+    };
+    globalIndex = new SymbolIndex();
+  }
+});
+
+// src/mcp/server.ts
+var server_exports = {};
+__export(server_exports, {
+  startMcpServer: () => startMcpServer
+});
+import * as path16 from "path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+function handleSmartRead(args) {
+  const filePath = path16.resolve(args.file);
+  const result = smartRead(
+    filePath,
+    args.symbol,
+    args.start_line,
+    args.end_line,
+    args.context_lines ?? 3
+  );
+  const header = [
+    `// File: ${result.filePath}`,
+    result.symbolName ? `// Symbol: ${result.symbolName} (lines ${result.startLine}\u2013${result.endLine})` : `// Lines: ${result.startLine}\u2013${result.endLine} of ${result.totalLines}`,
+    `// Tokens: ${result.tokenCount}${result.truncated ? " (truncated \u2014 file is large)" : ""}`,
+    ""
+  ].join("\n");
+  return header + result.content;
+}
+async function handleSearchSymbols(args) {
+  if (!globalIndex.isReady) {
+    return `Index not built yet. Call index_project first.
+Example: index_project({ "project_root": "${process.cwd()}" })`;
+  }
+  const results = globalIndex.search(
+    args.query,
+    args.type ?? "all",
+    args.path_filter,
+    args.limit ?? 20
+  );
+  if (results.length === 0) {
+    return `No symbols found matching "${args.query}".`;
+  }
+  const lines = [
+    `Found ${results.length} symbol(s) matching "${args.query}":`,
+    ""
+  ];
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    const rel = path16.relative(process.cwd(), r.filePath);
+    lines.push(`${i + 1}. [${r.type}] ${r.name}`);
+    lines.push(`   ${rel}:${r.lineStart}`);
+    lines.push(`   ${r.signature.trim()}`);
+    lines.push("");
+  }
+  lines.push(
+    `Tip: Use smart_read({ "file": "<path>", "symbol": "<name>" }) to read a specific symbol.`
+  );
+  return lines.join("\n");
+}
+async function handleIndexProject(args) {
+  const projectRoot = args.project_root ? path16.resolve(args.project_root) : process.cwd();
+  const fn = args.rebuild ? () => globalIndex.rebuild(projectRoot) : () => globalIndex.build(projectRoot);
+  const { fileCount, symbolCount } = await fn();
+  if (fileCount === 0 && globalIndex.isReady) {
+    return `Index already built: ${globalIndex.size} symbols. Pass rebuild: true to force re-index.`;
+  }
+  return `Index built for: ${projectRoot}
+Files scanned: ${fileCount}
+Symbols indexed: ${symbolCount}
+
+Use search_symbols({ "query": "<name>" }) to find symbols.`;
+}
+async function startMcpServer() {
+  const server = new Server(
+    { name: "claudectx", version: "0.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      let text;
+      switch (name) {
+        case "smart_read":
+          text = handleSmartRead(args);
+          break;
+        case "search_symbols":
+          text = await handleSearchSymbols(args);
+          break;
+        case "index_project":
+          text = await handleIndexProject(args);
+          break;
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+      return { content: [{ type: "text", text }] };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stderr.write("[claudectx mcp] Server started (stdio)\n");
+}
+var TOOLS;
+var init_server = __esm({
+  "src/mcp/server.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_smart_reader();
+    init_symbol_index();
+    TOOLS = [
+      {
+        name: "smart_read",
+        description: "Read a specific symbol (function, class, interface) or line range from a file instead of the whole file. Saves 60-90% of tokens on large files. Falls back to full file if symbol is not found (capped at 8K tokens).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            file: {
+              type: "string",
+              description: "Absolute or relative path to the file to read."
+            },
+            symbol: {
+              type: "string",
+              description: "Name of the function, class, interface, or type to extract. If provided, only that symbol block is returned."
+            },
+            start_line: {
+              type: "number",
+              description: "Start line (1-based, inclusive). Use with end_line."
+            },
+            end_line: {
+              type: "number",
+              description: "End line (1-based, inclusive). Use with start_line."
+            },
+            context_lines: {
+              type: "number",
+              description: "Extra lines of context above/below line range (default 3)."
+            }
+          },
+          required: ["file"]
+        }
+      },
+      {
+        name: "search_symbols",
+        description: "Search for functions, classes, variables, and interfaces by name across the indexed codebase. Returns file paths and line numbers. Run index_project first to populate the index.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Symbol name to search for (substring match, case-insensitive)."
+            },
+            type: {
+              type: "string",
+              enum: ["function", "class", "interface", "type", "variable", "all"],
+              description: "Filter by symbol type (default: all)."
+            },
+            path_filter: {
+              type: "string",
+              description: "Only include results from files whose path contains this string."
+            },
+            limit: {
+              type: "number",
+              description: "Maximum number of results (default 20)."
+            }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "index_project",
+        description: "Build or rebuild the symbol index for a project directory. Required before using search_symbols. Takes a few seconds for large projects.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            project_root: {
+              type: "string",
+              description: "Absolute path to the project root (default: cwd)."
+            },
+            rebuild: {
+              type: "boolean",
+              description: "Force a full rebuild even if the index is already built."
+            }
+          },
+          required: []
+        }
+      }
+    ];
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+import { Command } from "commander";
+
+// src/commands/analyze.ts
+init_esm_shims();
+import path4 from "path";
+import chalk from "chalk";
+import boxen from "boxen";
+import Table from "cli-table3";
+
+// src/analyzer/index.ts
+init_esm_shims();
+
+// src/analyzer/context-parser.ts
+init_esm_shims();
+import fs from "fs";
+import path2 from "path";
+import os from "os";
+function findProjectRoot(startDir = process.cwd()) {
+  let current = startDir;
+  while (true) {
+    if (fs.existsSync(path2.join(current, "CLAUDE.md")) || fs.existsSync(path2.join(current, ".claude"))) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function extractReferences(content) {
+  const refs = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^@(.+)$/);
+    if (match) refs.push(match[1].trim());
+  }
+  return refs;
+}
+function countMcpTools(settingsPath) {
+  try {
+    const raw = fs.readFileSync(settingsPath, "utf-8");
+    const settings = JSON.parse(raw);
+    const servers = settings?.mcpServers ?? {};
+    return Object.keys(servers).length * 3;
+  } catch {
+    return 0;
+  }
+}
+function readFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function parseContext(projectPath) {
+  const result = {
+    referencedFiles: [],
+    mcpToolCount: 0,
+    projectRoot: findProjectRoot(projectPath)
+  };
+  const root = result.projectRoot ?? projectPath;
+  const projectClaudeMdPath = path2.join(root, "CLAUDE.md");
+  const projectClaudeMdContent = readFileSafe(projectClaudeMdPath);
+  if (projectClaudeMdContent !== null) {
+    result.projectClaudeMd = { filePath: projectClaudeMdPath, content: projectClaudeMdContent };
+  }
+  const userClaudeMdPath = path2.join(os.homedir(), ".claude", "CLAUDE.md");
+  const userClaudeMdContent = readFileSafe(userClaudeMdPath);
+  if (userClaudeMdContent !== null) {
+    result.userClaudeMd = { filePath: userClaudeMdPath, content: userClaudeMdContent };
+  }
+  const memoryPath = path2.join(root, ".claude", "MEMORY.md");
+  const memoryContent = readFileSafe(memoryPath);
+  if (memoryContent !== null) {
+    result.memoryMd = { filePath: memoryPath, content: memoryContent };
+  }
+  const settingsPath = path2.join(root, ".claude", "settings.json");
+  result.mcpToolCount = countMcpTools(settingsPath);
+  const allClaudeMdContent = [
+    projectClaudeMdContent,
+    userClaudeMdContent
+  ].filter(Boolean).join("\n");
+  const refs = extractReferences(allClaudeMdContent);
+  for (const ref of refs) {
+    const refPath = path2.isAbsolute(ref) ? ref : path2.join(root, ref);
+    const refContent = readFileSafe(refPath);
+    if (refContent !== null) {
+      result.referencedFiles.push({
+        filePath: refPath,
+        content: refContent,
+        referencedAs: ref
+      });
+    }
+  }
+  return result;
+}
+
+// src/analyzer/index.ts
+init_tokenizer();
+
+// src/analyzer/waste-detector.ts
+init_esm_shims();
+init_tokenizer();
+import fs2 from "fs";
+import path3 from "path";
+
+// src/shared/constants.ts
+init_esm_shims();
+var BUILTIN_OVERHEAD = {
+  /** Claude Code's own system prompt */
+  SYSTEM_PROMPT: 4200,
+  /** Built-in tool schemas (Read, Edit, Bash, Glob, Grep, etc.) */
+  TOOL_DEFINITIONS: 2100,
+  /** Approximate tokens per registered MCP tool schema */
+  MCP_PER_TOOL: 180
+};
+var WASTE_THRESHOLDS = {
+  /** CLAUDE.md token count above this triggers OVERSIZED_CLAUDEMD */
+  MAX_CLAUDEMD_TOKENS: 2e3,
+  /** MEMORY.md token count above this triggers OVERSIZED_MEMORY */
+  MAX_MEMORY_TOKENS: 3e3,
+  /** Referenced file token count above this triggers LARGE_REFERENCE_FILE */
+  MAX_REFERENCE_FILE_TOKENS: 5e3,
+  /** Number of @referenced files above this triggers TOO_MANY_REFERENCES */
+  MAX_REFERENCE_COUNT: 5
+};
+var SESSION_DEFAULTS = {
+  /** Assumed number of requests in a typical 2-hour session */
+  REQUESTS_PER_SESSION: 60
+};
+var CACHE_BUSTERS = [
+  { pattern: /\d{4}-\d{2}-\d{2}/g, label: "Date string" },
+  { pattern: /\d{2}:\d{2}:\d{2}/g, label: "Time string" },
+  { pattern: /process\.env\.\w+/g, label: "Environment variable reference" },
+  { pattern: /\$\{.*?\}/g, label: "Template literal with variable" },
+  { pattern: /Last updated:.*/gi, label: '"Last updated" timestamp' },
+  { pattern: /Version:.*\d+\.\d+/gi, label: "Version string" },
+  { pattern: /Generated by.*/gi, label: "Generator comment" }
+];
+
+// src/analyzer/waste-detector.ts
+function warn(code, severity, message, suggestion, estimatedSavings, lineNumber) {
+  return { code, severity, message, suggestion, estimatedSavings, lineNumber };
+}
+function detectClaudeMdWarnings(content, tokenCount, referenceCount) {
+  const warnings = [];
+  if (tokenCount > WASTE_THRESHOLDS.MAX_CLAUDEMD_TOKENS) {
+    const excess = tokenCount - WASTE_THRESHOLDS.MAX_CLAUDEMD_TOKENS;
+    const pct = Math.round((tokenCount / WASTE_THRESHOLDS.MAX_CLAUDEMD_TOKENS - 1) * 100);
+    warnings.push(
+      warn(
+        "OVERSIZED_CLAUDEMD",
+        "error",
+        `CLAUDE.md is ${tokenCount.toLocaleString()} tokens \u2014 ${pct}% over the ${WASTE_THRESHOLDS.MAX_CLAUDEMD_TOKENS.toLocaleString()} token recommendation`,
+        "Run `claudectx optimize --claudemd` to split into demand-loaded files",
+        excess
+      )
+    );
+  }
+  const lines = content.split("\n");
+  for (const { pattern, label } of CACHE_BUSTERS) {
+    pattern.lastIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (pattern.test(lines[i])) {
+        warnings.push(
+          warn(
+            "CACHE_BUSTING_CONTENT",
+            "warning",
+            `${label} on line ${i + 1} breaks prompt caching`,
+            "Remove or externalize dynamic content \u2014 static CLAUDE.md saves ~88% on repeated requests",
+            0,
+            i + 1
+          )
+        );
+        break;
+      }
+      pattern.lastIndex = 0;
+    }
+  }
+  if (referenceCount > WASTE_THRESHOLDS.MAX_REFERENCE_COUNT) {
+    warnings.push(
+      warn(
+        "TOO_MANY_REFERENCES",
+        "warning",
+        `CLAUDE.md has ${referenceCount} @referenced files \u2014 consider consolidating`,
+        "Group related references into fewer files to reduce overhead",
+        0
+      )
+    );
+  }
+  return warnings;
+}
+function detectMemoryWarnings(content, tokenCount) {
+  const warnings = [];
+  if (tokenCount > WASTE_THRESHOLDS.MAX_MEMORY_TOKENS) {
+    const excess = tokenCount - WASTE_THRESHOLDS.MAX_MEMORY_TOKENS;
+    warnings.push(
+      warn(
+        "OVERSIZED_MEMORY",
+        "warning",
+        `MEMORY.md is ${tokenCount.toLocaleString()} tokens \u2014 over the ${WASTE_THRESHOLDS.MAX_MEMORY_TOKENS.toLocaleString()} token recommendation`,
+        "Run `claudectx compress --prune --days 30` to prune old entries",
+        excess
+      )
+    );
+  }
+  return warnings;
+}
+function detectReferenceFileWarnings(filePath, content, tokenCount) {
+  const warnings = [];
+  if (tokenCount > WASTE_THRESHOLDS.MAX_REFERENCE_FILE_TOKENS) {
+    warnings.push(
+      warn(
+        "LARGE_REFERENCE_FILE",
+        "warning",
+        `Referenced file ${path3.basename(filePath)} is ${tokenCount.toLocaleString()} tokens`,
+        "Split large reference files or move rarely-needed sections to separate files",
+        tokenCount - WASTE_THRESHOLDS.MAX_REFERENCE_FILE_TOKENS
+      )
+    );
+  }
+  return warnings;
+}
+function detectMissingIgnoreFile(projectRoot) {
+  const ignorePath = path3.join(projectRoot, ".claudeignore");
+  if (!fs2.existsSync(ignorePath)) {
+    return warn(
+      "MISSING_IGNOREFILE",
+      "warning",
+      "No .claudeignore file found \u2014 Claude may read node_modules, .git, dist/ etc.",
+      "Run `claudectx optimize --ignorefile` to generate one",
+      0
+    );
+  }
+  return null;
+}
+function detectNoCachingConfigured(projectRoot, claudeMdContent) {
+  const settingsPath = path3.join(projectRoot, ".claude", "settings.json");
+  if (!fs2.existsSync(settingsPath) && claudeMdContent) {
+    return warn(
+      "NO_CACHING_CONFIGURED",
+      "info",
+      "Prompt caching may not be configured \u2014 static context is re-billed on every request",
+      "Run `claudectx optimize --cache` for caching recommendations",
+      0
+    );
+  }
+  return null;
+}
+function detectRedundantContent(claudeMdContent, memoryContent) {
+  if (!memoryContent) return null;
+  const claudeLines = new Set(
+    claudeMdContent.split("\n").map((l) => l.trim()).filter((l) => l.length > 20)
+  );
+  const memoryLines = memoryContent.split("\n").map((l) => l.trim()).filter((l) => l.length > 20);
+  const duplicates = memoryLines.filter((l) => claudeLines.has(l));
+  if (duplicates.length > 3) {
+    return warn(
+      "REDUNDANT_CONTENT",
+      "info",
+      `${duplicates.length} lines appear in both CLAUDE.md and MEMORY.md`,
+      "Remove duplicated content from MEMORY.md \u2014 CLAUDE.md is already injected every request",
+      countTokens(duplicates.join("\n"))
+    );
+  }
+  return null;
+}
+
+// src/analyzer/cost-calculator.ts
+init_esm_shims();
+init_models();
+function sessionCost(tokensPerRequest, model) {
+  const perRequest = calculateCost(tokensPerRequest, model);
+  return {
+    perRequest,
+    perSession: perRequest * SESSION_DEFAULTS.REQUESTS_PER_SESSION,
+    perHour: perRequest * 60
+  };
+}
+function calculatePotentialSavings(currentTokens, savableTokens, model) {
+  const savedTokens = Math.min(savableTokens, currentTokens);
+  const savedPercent = currentTokens > 0 ? Math.round(savedTokens / currentTokens * 100) : 0;
+  const savedCostPerSession = calculateCost(savedTokens, model) * SESSION_DEFAULTS.REQUESTS_PER_SESSION;
+  return { savedTokens, savedPercent, savedCostPerSession };
+}
+function formatCost(usd) {
+  if (usd < 0.01) return "$0.00";
+  return `$${usd.toFixed(2)}`;
+}
+
+// src/analyzer/index.ts
+init_models();
+var ContextAnalyzer = class {
+  constructor(model) {
+    this.model = model;
+  }
+  model;
+  async analyze(projectPath) {
+    const ctx = parseContext(projectPath);
+    const components = [];
+    const allWarnings = [];
+    components.push({
+      name: "System prompt (built-in)",
+      type: "system-prompt",
+      tokenCount: BUILTIN_OVERHEAD.SYSTEM_PROMPT,
+      estimatedCostPerRequest: calculateCost(BUILTIN_OVERHEAD.SYSTEM_PROMPT, this.model),
+      warnings: []
+    });
+    components.push({
+      name: "Tool definitions (built-in)",
+      type: "tool-definitions",
+      tokenCount: BUILTIN_OVERHEAD.TOOL_DEFINITIONS,
+      estimatedCostPerRequest: calculateCost(BUILTIN_OVERHEAD.TOOL_DEFINITIONS, this.model),
+      warnings: []
+    });
+    if (ctx.mcpToolCount > 0) {
+      const mcpTokens = ctx.mcpToolCount * BUILTIN_OVERHEAD.MCP_PER_TOOL;
+      components.push({
+        name: `MCP schemas (${ctx.mcpToolCount} tools)`,
+        type: "mcp-schemas",
+        tokenCount: mcpTokens,
+        estimatedCostPerRequest: calculateCost(mcpTokens, this.model),
+        warnings: []
+      });
+    }
+    if (ctx.projectClaudeMd) {
+      const tokenCount = countTokens(ctx.projectClaudeMd.content);
+      const refCount = ctx.referencedFiles.length;
+      const warnings = detectClaudeMdWarnings(ctx.projectClaudeMd.content, tokenCount, refCount);
+      allWarnings.push(...warnings);
+      components.push({
+        name: "CLAUDE.md (project)",
+        type: "claude-md",
+        filePath: ctx.projectClaudeMd.filePath,
+        tokenCount,
+        estimatedCostPerRequest: calculateCost(tokenCount, this.model),
+        warnings
+      });
+    }
+    if (ctx.userClaudeMd) {
+      const tokenCount = countTokens(ctx.userClaudeMd.content);
+      const warnings = detectClaudeMdWarnings(ctx.userClaudeMd.content, tokenCount, 0);
+      allWarnings.push(...warnings);
+      components.push({
+        name: "CLAUDE.md (user ~/.claude/)",
+        type: "claude-md",
+        filePath: ctx.userClaudeMd.filePath,
+        tokenCount,
+        estimatedCostPerRequest: calculateCost(tokenCount, this.model),
+        warnings
+      });
+    }
+    if (ctx.memoryMd) {
+      const tokenCount = countTokens(ctx.memoryMd.content);
+      const warnings = detectMemoryWarnings(ctx.memoryMd.content, tokenCount);
+      allWarnings.push(...warnings);
+      components.push({
+        name: "MEMORY.md",
+        type: "memory",
+        filePath: ctx.memoryMd.filePath,
+        tokenCount,
+        estimatedCostPerRequest: calculateCost(tokenCount, this.model),
+        warnings
+      });
+    }
+    for (const ref of ctx.referencedFiles) {
+      const tokenCount = countTokens(ref.content);
+      const warnings = detectReferenceFileWarnings(ref.filePath, ref.content, tokenCount);
+      allWarnings.push(...warnings);
+      components.push({
+        name: `@${ref.referencedAs}`,
+        type: "reference-file",
+        filePath: ref.filePath,
+        tokenCount,
+        estimatedCostPerRequest: calculateCost(tokenCount, this.model),
+        warnings
+      });
+    }
+    const projectRoot = ctx.projectRoot ?? projectPath;
+    const missingIgnore = detectMissingIgnoreFile(projectRoot);
+    if (missingIgnore) allWarnings.push(missingIgnore);
+    const noCache = detectNoCachingConfigured(
+      projectRoot,
+      ctx.projectClaudeMd?.content
+    );
+    if (noCache) allWarnings.push(noCache);
+    const redundant = detectRedundantContent(
+      ctx.projectClaudeMd?.content ?? "",
+      ctx.memoryMd?.content
+    );
+    if (redundant) allWarnings.push(redundant);
+    const totalTokensPerRequest = components.reduce((s, c) => s + c.tokenCount, 0);
+    const totalSavableTokens = allWarnings.reduce((s, w) => s + w.estimatedSavings, 0);
+    const costs = sessionCost(totalTokensPerRequest, this.model);
+    const savings = calculatePotentialSavings(
+      totalTokensPerRequest,
+      totalSavableTokens,
+      this.model
+    );
+    return {
+      projectPath,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      model: this.model,
+      components,
+      totalTokensPerRequest,
+      estimatedCostPerSession: costs.perSession,
+      warnings: allWarnings,
+      optimizedTokensPerRequest: totalTokensPerRequest - savings.savedTokens,
+      potentialSavingsPercent: savings.savedPercent
+    };
+  }
+};
+
+// src/commands/analyze.ts
+init_models();
+function statusIcon(component) {
+  if (component.warnings.length === 0) return chalk.green("\u2713");
+  const hasError = component.warnings.some((w) => w.severity === "error");
+  if (hasError) return chalk.red("\u2716");
+  return chalk.yellow("\u26A0");
+}
+function renderReport(report) {
+  const contextPct = (report.totalTokensPerRequest / 2e5 * 100).toFixed(1);
+  const header = [
+    chalk.bold("claudectx \u2014 Context Analysis"),
+    chalk.dim(`Project: ${report.projectPath}`),
+    "",
+    `${chalk.bold("Tokens/request:")} ${chalk.cyan(report.totalTokensPerRequest.toLocaleString())}   ${chalk.bold("Session cost:")} ${chalk.yellow(formatCost(report.estimatedCostPerSession))}`,
+    `${chalk.bold("Model:")} ${report.model}   ${chalk.bold("Context used:")} ${contextPct}% of 200K window`
+  ].join("\n");
+  process.stdout.write(
+    boxen(header, {
+      padding: 1,
+      borderStyle: "double",
+      borderColor: "cyan"
+    }) + "\n\n"
+  );
+  const table = new Table({
+    head: [
+      chalk.bold("Component"),
+      chalk.bold("Tokens"),
+      chalk.bold("Cost/req"),
+      chalk.bold("Status")
+    ],
+    colWidths: [38, 12, 12, 10],
+    style: { head: [], border: [] }
+  });
+  for (const c of report.components) {
+    table.push([
+      c.name,
+      c.tokenCount.toLocaleString(),
+      formatCost(c.estimatedCostPerRequest),
+      statusIcon(c)
+    ]);
+  }
+  table.push([
+    chalk.bold("TOTAL (per request)"),
+    chalk.bold(report.totalTokensPerRequest.toLocaleString()),
+    chalk.bold(formatCost(report.components.reduce((s, c) => s + c.estimatedCostPerRequest, 0))),
+    ""
+  ]);
+  process.stdout.write(table.toString() + "\n");
+  if (report.warnings.length === 0) {
+    process.stdout.write("\n" + chalk.green("\u2714 No optimization opportunities found. Looking good!\n"));
+  } else {
+    process.stdout.write(
+      "\n" + chalk.yellow(`\u26A0  ${report.warnings.length} optimization ${report.warnings.length === 1 ? "opportunity" : "opportunities"} found:
+
+`)
+    );
+    report.warnings.forEach((w, i) => {
+      const icon = w.severity === "error" ? chalk.red("\u2716") : w.severity === "warning" ? chalk.yellow("\u26A0") : chalk.blue("\u2139");
+      const lineInfo = w.lineNumber ? ` (line ${w.lineNumber})` : "";
+      process.stdout.write(`  ${chalk.bold(`[${i + 1}]`)} ${icon} ${w.message}${lineInfo}
+`);
+      process.stdout.write(`      ${chalk.dim("\u2192")} ${w.suggestion}
+`);
+      if (w.estimatedSavings > 0) {
+        process.stdout.write(
+          `      ${chalk.dim("\u2192")} Potential savings: ~${w.estimatedSavings.toLocaleString()} tokens/request
+`
+        );
+      }
+      process.stdout.write("\n");
+    });
+    process.stdout.write(
+      chalk.dim(
+        `  \u{1F4A1} Run ${chalk.cyan("claudectx optimize")} to fix all issues automatically.
+  \u{1F4A1} Run ${chalk.cyan("claudectx optimize --dry-run")} to preview changes first.
+`
+      ) + "\n"
+    );
+  }
+  if (report.potentialSavingsPercent > 0) {
+    process.stdout.write(
+      chalk.dim(
+        `  Potential savings: ${report.potentialSavingsPercent}% (${(report.totalTokensPerRequest - report.optimizedTokensPerRequest).toLocaleString()} tokens)
+
+`
+      )
+    );
+  }
+  process.stdout.write(
+    chalk.dim("  \u2B50 If claudectx saved you money, star the repo: https://github.com/Horilla/claudectx\n\n")
+  );
+}
+async function analyzeCommand(options) {
+  const targetPath = path4.resolve(options.path ?? process.cwd());
+  const model = resolveModel(options.model ?? "sonnet");
+  const analyzer = new ContextAnalyzer(model);
+  async function run() {
+    try {
+      const report = await analyzer.analyze(targetPath);
+      if (options.json) {
+        process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+        return;
+      }
+      renderReport(report);
+    } catch (err) {
+      process.stderr.write(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}
+`));
+      process.exit(1);
+    }
+  }
+  await run();
+  if (options.watch) {
+    const { watch: watch2 } = await import("fs");
+    process.stderr.write(chalk.dim("Watching for changes (Ctrl+C to stop)...\n"));
+    let debounce = null;
+    watch2(targetPath, { recursive: true }, (_event, filename) => {
+      if (!filename?.includes("CLAUDE") && !filename?.includes("MEMORY")) return;
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(async () => {
+        process.stdout.write("\x1Bc");
+        process.stderr.write(chalk.dim(`Re-analyzing after change to ${filename}...
+
+`));
+        await run();
+      }, 300);
+    });
+    await new Promise(() => {
+    });
+  }
+}
+
+// src/commands/optimize.ts
+init_esm_shims();
+import * as fs7 from "fs";
+import * as path8 from "path";
+import chalk3 from "chalk";
+import boxen2 from "boxen";
+import { checkbox, confirm } from "@inquirer/prompts";
+
+// src/shared/logger.ts
+init_esm_shims();
+import chalk2 from "chalk";
+var logger = {
+  info: (msg) => process.stderr.write(chalk2.blue("\u2139 ") + msg + "\n"),
+  warn: (msg) => process.stderr.write(chalk2.yellow("\u26A0 ") + msg + "\n"),
+  error: (msg) => process.stderr.write(chalk2.red("\u2716 ") + msg + "\n"),
+  success: (msg) => process.stderr.write(chalk2.green("\u2714 ") + msg + "\n"),
+  dim: (msg) => process.stderr.write(chalk2.dim(msg) + "\n")
+};
+
+// src/optimizer/ignorefile-generator.ts
+init_esm_shims();
+import * as fs3 from "fs";
+import * as path5 from "path";
+var ALWAYS_IGNORE = `# .claudeignore \u2014 generated by claudectx
+# Prevents Claude Code from accidentally reading large binary/generated files.
+# Syntax is identical to .gitignore.
+
+# Version control internals
+.git/
+
+# Dependencies
+node_modules/
+vendor/
+.venv/
+venv/
+env/
+.env/
+
+# Build output
+dist/
+build/
+out/
+.next/
+.nuxt/
+.output/
+target/
+
+# Bytecode & compiled files
+*.pyc
+*.pyo
+__pycache__/
+*.class
+*.o
+*.a
+*.so
+*.dylib
+
+# Logs & databases
+*.log
+logs/
+*.sqlite3
+*.sqlite
+*.db
+
+# OS artefacts
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Environment & secrets (never let Claude read these)
+.env
+.env.local
+.env.*.local
+*.pem
+*.key
+*.cert
+secrets.json
+
+# Coverage & test caches
+coverage/
+.coverage
+htmlcov/
+.cache/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.tox/
+
+# IDE files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Large media / binary assets
+*.jpg
+*.jpeg
+*.png
+*.gif
+*.ico
+*.mp4
+*.mp3
+*.pdf
+*.zip
+*.tar.gz
+*.woff
+*.woff2
+*.ttf
+*.eot
+`;
+var PYTHON_EXTRA = `
+# Python / Django extras
+migrations/
+staticfiles/
+media/
+.eggs/
+*.egg-info/
+pip-wheel-metadata/
+`;
+var NODE_EXTRA = `
+# Node.js lock files (large, rarely useful to Claude)
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+.yarn/
+`;
+var RUST_EXTRA = `
+# Rust
+Cargo.lock
+`;
+var GO_EXTRA = `
+# Go
+go.sum
+`;
+function detectProjectTypes(projectRoot) {
+  const types = [];
+  if (fs3.existsSync(path5.join(projectRoot, "package.json"))) types.push("node");
+  if (fs3.existsSync(path5.join(projectRoot, "manage.py")) || fs3.existsSync(path5.join(projectRoot, "requirements.txt")) || fs3.existsSync(path5.join(projectRoot, "pyproject.toml")))
+    types.push("python");
+  if (fs3.existsSync(path5.join(projectRoot, "Cargo.toml"))) types.push("rust");
+  if (fs3.existsSync(path5.join(projectRoot, "go.mod"))) types.push("go");
+  return types;
+}
+function generateIgnorefile(projectRoot) {
+  const filePath = path5.join(projectRoot, ".claudeignore");
+  const existed = fs3.existsSync(filePath);
+  const projectTypes = detectProjectTypes(projectRoot);
+  let content = ALWAYS_IGNORE;
+  if (projectTypes.includes("python")) content += PYTHON_EXTRA;
+  if (projectTypes.includes("node")) content += NODE_EXTRA;
+  if (projectTypes.includes("rust")) content += RUST_EXTRA;
+  if (projectTypes.includes("go")) content += GO_EXTRA;
+  return { filePath, content, existed, projectTypes };
+}
+function writeIgnorefile(result) {
+  if (result.existed) {
+    const existing = fs3.readFileSync(result.filePath, "utf-8");
+    fs3.writeFileSync(result.filePath, existing.trimEnd() + "\n\n" + result.content, "utf-8");
+  } else {
+    fs3.writeFileSync(result.filePath, result.content, "utf-8");
+  }
+}
+
+// src/optimizer/claudemd-splitter.ts
+init_esm_shims();
+init_tokenizer();
+import * as fs4 from "fs";
+import * as path6 from "path";
+var SPLIT_MIN_TOKENS = 300;
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function parseSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentLines = [];
+  let currentTitle = "";
+  let isPreamble = true;
+  const flush = () => {
+    if (currentLines.length === 0 && !isPreamble) return;
+    const text = currentLines.join("\n");
+    sections.push({
+      title: currentTitle,
+      content: text,
+      tokens: countTokens(text),
+      isPreamble
+    });
+  };
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      flush();
+      currentTitle = line.slice(3).trim();
+      currentLines = [line];
+      isPreamble = false;
+    } else {
+      currentLines.push(line);
+    }
+  }
+  flush();
+  return sections;
+}
+function planSplit(claudeMdPath, sectionsToExtract) {
+  const content = fs4.readFileSync(claudeMdPath, "utf-8");
+  const sections = parseSections(content);
+  const claudeDir = path6.join(path6.dirname(claudeMdPath), ".claude");
+  const extractedFiles = [];
+  let newContent = "";
+  let tokensSaved = 0;
+  const usedSlugs = /* @__PURE__ */ new Map();
+  for (const section of sections) {
+    if (!section.isPreamble && sectionsToExtract.includes(section.title)) {
+      let slug = slugify(section.title);
+      const count = usedSlugs.get(slug) ?? 0;
+      if (count > 0) slug = `${slug}-${count}`;
+      usedSlugs.set(slug, count + 1);
+      const filename = `${slug}.md`;
+      const relRefPath = `.claude/${filename}`;
+      const filePath = path6.join(claudeDir, filename);
+      const refBlock = `## ${section.title}
+
+@${relRefPath}
+`;
+      newContent += refBlock + "\n";
+      extractedFiles.push({
+        filePath,
+        content: section.content,
+        sectionTitle: section.title,
+        refPath: relRefPath
+      });
+      tokensSaved += section.tokens - countTokens(refBlock);
+    } else {
+      newContent += section.content.trimEnd() + "\n\n";
+    }
+  }
+  return {
+    claudeMdPath,
+    newClaudeMd: newContent.trimEnd() + "\n",
+    extractedFiles,
+    tokensSaved: Math.max(0, tokensSaved)
+  };
+}
+function applySplit(result) {
+  if (result.extractedFiles.length === 0) return;
+  const claudeDir = path6.dirname(result.extractedFiles[0].filePath);
+  if (!fs4.existsSync(claudeDir)) {
+    fs4.mkdirSync(claudeDir, { recursive: true });
+  }
+  for (const file of result.extractedFiles) {
+    fs4.writeFileSync(file.filePath, file.content, "utf-8");
+  }
+  fs4.writeFileSync(result.claudeMdPath, result.newClaudeMd, "utf-8");
+}
+
+// src/optimizer/cache-applier.ts
+init_esm_shims();
+import * as fs5 from "fs";
+function findCacheBusters(content) {
+  const fixes = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const buster of CACHE_BUSTERS) {
+      const re = new RegExp(buster.pattern.source, "i");
+      if (re.test(line)) {
+        fixes.push({
+          label: buster.label,
+          lineNumber: i + 1,
+          originalLine: line,
+          // Comment-out the line so content is still vaguely visible in the file
+          fixedLine: `<!-- claudectx removed cache-busting content (${buster.label}): ${line.trim()} -->`
+        });
+        break;
+      }
+    }
+  }
+  return fixes;
+}
+function applyCacheFixes(content, fixes) {
+  const lines = content.split("\n");
+  for (const fix of fixes) {
+    lines[fix.lineNumber - 1] = fix.fixedLine;
+  }
+  return lines.join("\n");
+}
+function planCacheFixes(claudeMdPath) {
+  const content = fs5.readFileSync(claudeMdPath, "utf-8");
+  const fixes = findCacheBusters(content);
+  return { fixes, newContent: applyCacheFixes(content, fixes) };
+}
+function applyAndWriteCacheFixes(claudeMdPath, result) {
+  fs5.writeFileSync(claudeMdPath, result.newContent, "utf-8");
+}
+
+// src/optimizer/hooks-installer.ts
+init_esm_shims();
+import * as fs6 from "fs";
+import * as path7 from "path";
+var CLAUDECTX_HOOKS = {
+  PostToolUse: [
+    {
+      // Pipe the hook JSON payload to `claudectx watch --log-stdin`.
+      // Claude Code passes { tool_name, tool_input, tool_response, session_id }
+      // via stdin when the PostToolUse hook fires.
+      matcher: "Read",
+      hooks: [
+        {
+          type: "command",
+          command: "claudectx watch --log-stdin"
+        }
+      ]
+    }
+  ]
+};
+function planHooksInstall(projectRoot) {
+  const claudeDir = path7.join(projectRoot, ".claude");
+  const settingsPath = path7.join(claudeDir, "settings.local.json");
+  const existed = fs6.existsSync(settingsPath);
+  let existing = {};
+  if (existed) {
+    try {
+      existing = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
+    } catch {
+      existing = {};
+    }
+  }
+  const existingHooks = existing.hooks ?? {};
+  const existingPostToolUse = existingHooks.PostToolUse ?? [];
+  const alreadyInstalled = existingPostToolUse.some(
+    (h) => typeof h === "object" && h !== null && h.matcher === "Read" && JSON.stringify(h).includes("claudectx")
+  );
+  const mergedPostToolUse = alreadyInstalled ? existingPostToolUse : [...existingPostToolUse, ...CLAUDECTX_HOOKS.PostToolUse];
+  const mergedSettings = {
+    ...existing,
+    hooks: {
+      ...existingHooks,
+      PostToolUse: mergedPostToolUse
+    }
+  };
+  return { settingsPath, existed, mergedSettings };
+}
+function applyHooksInstall(result) {
+  const dir = path7.dirname(result.settingsPath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
+  }
+  fs6.writeFileSync(result.settingsPath, JSON.stringify(result.mergedSettings, null, 2) + "\n", "utf-8");
+}
+function isAlreadyInstalled(projectRoot) {
+  const settingsPath = path7.join(projectRoot, ".claude", "settings.local.json");
+  if (!fs6.existsSync(settingsPath)) return false;
+  try {
+    const settings = JSON.parse(fs6.readFileSync(settingsPath, "utf-8"));
+    const postToolUse = settings?.hooks?.PostToolUse ?? [];
+    return postToolUse.some((h) => h.matcher === "Read");
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/optimize.ts
+async function optimizeCommand(options) {
+  const projectPath = options.path ? path8.resolve(options.path) : findProjectRoot() ?? process.cwd();
+  const dryRun = options.dryRun ?? false;
+  const autoApply = options.apply ?? false;
+  const specificMode = options.claudemd || options.ignorefile || options.cache || options.hooks;
+  console.log(
+    boxen2(
+      chalk3.bold("claudectx \u2014 Optimize") + "\n" + chalk3.dim(`Project: ${projectPath}`) + (dryRun ? "\n" + chalk3.yellow("Dry run \u2014 no files will be changed") : ""),
+      { padding: 1, borderStyle: "round", borderColor: dryRun ? "yellow" : "cyan" }
+    )
+  );
+  logger.info("Analyzing context...");
+  const analyzer = new ContextAnalyzer("claude-sonnet-4-6");
+  const report = await analyzer.analyze(projectPath);
+  const hasWarning = (code) => report.warnings.some((w) => w.code === code);
+  const fixes = [
+    {
+      id: "ignorefile",
+      label: "Generate .claudeignore",
+      detail: "Prevents Claude from reading node_modules/, dist/, .git/, etc.",
+      available: hasWarning("MISSING_IGNOREFILE") || !!options.ignorefile
+    },
+    {
+      id: "claudemd",
+      label: `Split CLAUDE.md into @files`,
+      detail: `Extract large sections to demand-loaded files (saves tokens per request)`,
+      available: hasWarning("OVERSIZED_CLAUDEMD") || !!options.claudemd
+    },
+    {
+      id: "cache",
+      label: "Remove cache-busting content",
+      detail: "Comment-out dynamic dates/timestamps that bust the prompt cache every request",
+      available: hasWarning("CACHE_BUSTING_CONTENT") || !!options.cache
+    },
+    {
+      id: "hooks",
+      label: "Install session hooks",
+      detail: "Track per-file token spend via PostToolUse hook in .claude/settings.local.json",
+      available: !isAlreadyInstalled(projectPath) || !!options.hooks
+    }
+  ];
+  const eligible = fixes.filter((f) => f.available);
+  if (eligible.length === 0 && !specificMode) {
+    logger.success(
+      "Nothing to optimize! Run `claudectx analyze` to see the current token breakdown."
+    );
+    return;
+  }
+  let selected;
+  if (specificMode) {
+    selected = [
+      options.ignorefile && "ignorefile",
+      options.claudemd && "claudemd",
+      options.cache && "cache",
+      options.hooks && "hooks"
+    ].filter((x) => !!x);
+  } else if (autoApply || dryRun) {
+    selected = eligible.map((f) => f.id);
+  } else {
+    selected = await checkbox({
+      message: "Which optimizations would you like to apply?",
+      choices: eligible.map((f) => ({
+        name: `${chalk3.white(f.label)}  ${chalk3.dim("\u2014")}  ${chalk3.dim(f.detail)}`,
+        value: f.id,
+        checked: true
+      }))
+    });
+  }
+  if (selected.length === 0) {
+    logger.info("Nothing selected \u2014 no changes made.");
+    return;
+  }
+  for (const id of selected) {
+    switch (id) {
+      case "ignorefile":
+        await runIgnorefile(projectPath, dryRun, autoApply);
+        break;
+      case "claudemd":
+        await runClaudeMdSplit(projectPath, report, dryRun, autoApply);
+        break;
+      case "cache":
+        await runCacheOptimization(projectPath, dryRun, autoApply);
+        break;
+      case "hooks":
+        await runHooks(projectPath, dryRun, autoApply);
+        break;
+    }
+  }
+  console.log("");
+  if (dryRun) {
+    logger.warn("Dry run complete. Re-run without --dry-run to apply changes.");
+  } else {
+    logger.success("Optimization complete! Run `claudectx analyze` to verify your savings.");
+  }
+}
+async function runIgnorefile(projectRoot, dryRun, autoApply) {
+  printSectionHeader(".claudeignore");
+  const result = generateIgnorefile(projectRoot);
+  if (result.existed) {
+    logger.warn(".claudeignore already exists \u2014 new patterns will be appended.");
+  } else {
+    logger.info(`Will create: ${chalk3.cyan(result.filePath)}`);
+  }
+  logger.info(
+    `Detected project types: ${result.projectTypes.length ? result.projectTypes.join(", ") : "generic"}`
+  );
+  if (dryRun) {
+    console.log(chalk3.dim("\nPreview (first 20 lines):"));
+    console.log(
+      chalk3.dim(result.content.split("\n").slice(0, 20).join("\n") + "\n  ...")
+    );
+    return;
+  }
+  const ok = autoApply || await confirm({
+    message: result.existed ? "Append patterns to existing .claudeignore?" : "Create .claudeignore?",
+    default: true
+  });
+  if (!ok) {
+    logger.info("Skipped.");
+    return;
+  }
+  writeIgnorefile(result);
+  logger.success(`${result.existed ? "Updated" : "Created"} ${chalk3.cyan(result.filePath)}`);
+}
+async function runClaudeMdSplit(projectRoot, report, dryRun, autoApply) {
+  printSectionHeader("CLAUDE.md \u2192 @files");
+  const claudeMdPath = path8.join(projectRoot, "CLAUDE.md");
+  if (!fs7.existsSync(claudeMdPath)) {
+    logger.warn("No CLAUDE.md found \u2014 skipping.");
+    return;
+  }
+  const content = fs7.readFileSync(claudeMdPath, "utf-8");
+  const sections = parseSections(content);
+  const largeSections = sections.filter(
+    (s) => !s.isPreamble && s.tokens >= SPLIT_MIN_TOKENS
+  );
+  if (largeSections.length === 0) {
+    logger.info(`No sections exceed ${SPLIT_MIN_TOKENS} tokens \u2014 nothing to extract.`);
+    return;
+  }
+  const claudeMdWarning = report.warnings.find((w) => w.code === "OVERSIZED_CLAUDEMD");
+  if (claudeMdWarning) {
+    logger.warn(claudeMdWarning.message);
+  }
+  console.log("\n  Large sections found:");
+  for (const s of largeSections) {
+    console.log(`    ${chalk3.yellow("\u2022")} ${s.title}  ${chalk3.dim(`(${s.tokens} tokens)`)}`);
+  }
+  let sectionsToExtract;
+  if (autoApply || dryRun) {
+    sectionsToExtract = largeSections.map((s) => s.title);
+  } else {
+    sectionsToExtract = await checkbox({
+      message: "Select sections to extract into .claude/ @files:",
+      choices: largeSections.map((s) => ({
+        name: `${s.title}  ${chalk3.dim(`\u2014 ${s.tokens} tokens`)}`,
+        value: s.title,
+        checked: true
+      }))
+    });
+  }
+  if (sectionsToExtract.length === 0) {
+    logger.info("Skipped.");
+    return;
+  }
+  const splitResult = planSplit(claudeMdPath, sectionsToExtract);
+  if (dryRun) {
+    console.log(
+      chalk3.dim(
+        `
+Would extract ${splitResult.extractedFiles.length} section(s) to .claude/`
+      )
+    );
+    for (const f of splitResult.extractedFiles) {
+      console.log(chalk3.dim(`  \u2192 ${f.refPath}  (${f.sectionTitle})`));
+    }
+    console.log(chalk3.dim(`  Estimated savings: ~${splitResult.tokensSaved} tokens/request`));
+    return;
+  }
+  const ok = autoApply || await confirm({
+    message: `Extract ${sectionsToExtract.length} section(s) and update CLAUDE.md?`,
+    default: true
+  });
+  if (!ok) {
+    logger.info("Skipped.");
+    return;
+  }
+  applySplit(splitResult);
+  logger.success(
+    `Extracted ${splitResult.extractedFiles.length} section(s). Saved ~${splitResult.tokensSaved} tokens/request.`
+  );
+  for (const f of splitResult.extractedFiles) {
+    logger.info(`  Created: ${chalk3.cyan(path8.relative(projectRoot, f.filePath))}`);
+  }
+}
+async function runCacheOptimization(projectRoot, dryRun, autoApply) {
+  printSectionHeader("Prompt cache optimisation");
+  const claudeMdPath = path8.join(projectRoot, "CLAUDE.md");
+  if (!fs7.existsSync(claudeMdPath)) {
+    logger.warn("No CLAUDE.md found \u2014 skipping.");
+    return;
+  }
+  const result = planCacheFixes(claudeMdPath);
+  if (result.fixes.length === 0) {
+    logger.success("No cache-busting patterns found in CLAUDE.md.");
+    return;
+  }
+  console.log(`
+  ${result.fixes.length} cache-busting line(s) detected:
+`);
+  for (const fix of result.fixes) {
+    console.log(
+      `    ${chalk3.dim(`line ${fix.lineNumber}:`)}  ${chalk3.red(fix.originalLine.trim())}`
+    );
+    console.log(`    ${chalk3.dim("\u2192")}  ${chalk3.green(fix.fixedLine)}`);
+    console.log("");
+  }
+  if (dryRun) return;
+  const ok = autoApply || await confirm({
+    message: `Comment-out ${result.fixes.length} cache-busting line(s)?`,
+    default: true
+  });
+  if (!ok) {
+    logger.info("Skipped.");
+    return;
+  }
+  applyAndWriteCacheFixes(claudeMdPath, result);
+  logger.success(`Fixed ${result.fixes.length} cache-busting pattern(s) in CLAUDE.md.`);
+}
+async function runHooks(projectRoot, dryRun, autoApply) {
+  printSectionHeader("Session hooks");
+  const result = planHooksInstall(projectRoot);
+  logger.info(
+    `Settings file: ${chalk3.cyan(path8.relative(projectRoot, result.settingsPath))}`
+  );
+  logger.info(result.existed ? "Will merge with existing settings." : "Will create new file.");
+  console.log(chalk3.dim("\n  Hooks to install:"));
+  console.log(
+    chalk3.dim("    \u2022 PostToolUse \u2192 Read: track per-file token spend for `claudectx watch`")
+  );
+  if (dryRun) return;
+  const ok = autoApply || await confirm({ message: "Install claudectx session hooks?", default: true });
+  if (!ok) {
+    logger.info("Skipped.");
+    return;
+  }
+  applyHooksInstall(result);
+  logger.success(
+    `Hooks installed \u2192 ${chalk3.cyan(path8.relative(projectRoot, result.settingsPath))}`
+  );
+}
+function printSectionHeader(title) {
+  console.log("");
+  console.log(chalk3.bold.cyan(`\u2500\u2500 ${title} ${"\u2500".repeat(Math.max(0, 50 - title.length))}`));
+}
+
+// src/commands/watch.ts
+init_esm_shims();
+init_session_store();
+init_models();
+import * as path12 from "path";
+async function watchCommand(options) {
+  if (options.logStdin) {
+    await handleLogStdin();
+    return;
+  }
+  if (options.clear) {
+    const { clearStore: clearStore2 } = await Promise.resolve().then(() => (init_session_store(), session_store_exports));
+    clearStore2();
+    process.stdout.write("claudectx: session store cleared.\n");
+    return;
+  }
+  if (!process.stdout.isTTY) {
+    process.stderr.write(
+      "claudectx watch: stdout is not a TTY \u2014 dashboard requires an interactive terminal.\n"
+    );
+    process.exit(1);
+  }
+  const model = options.model ? resolveModel(options.model) : "claude-sonnet-4-6";
+  const { render } = await import("ink");
+  const React2 = (await import("react")).default;
+  const { Dashboard: Dashboard2 } = await Promise.resolve().then(() => (init_Dashboard(), Dashboard_exports));
+  render(
+    React2.createElement(Dashboard2, {
+      model,
+      sessionId: options.session
+    })
+  );
+}
+async function handleLogStdin() {
+  const raw = await readStdin();
+  if (!raw.trim()) return;
+  try {
+    const payload = JSON.parse(raw);
+    const filePath = payload.tool_input?.file_path;
+    if (filePath) {
+      appendFileRead(path12.resolve(filePath), payload.session_id);
+    }
+  } catch {
+  }
+}
+function readStdin() {
+  return new Promise((resolve6) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolve6(data));
+    setTimeout(() => resolve6(data), 500);
+  });
+}
+
+// src/commands/mcp.ts
+init_esm_shims();
+import * as path17 from "path";
+import chalk4 from "chalk";
+
+// src/mcp/installer.ts
+init_esm_shims();
+import * as fs11 from "fs";
+import * as path13 from "path";
+var SERVER_NAME = "claudectx";
+var SERVER_ENTRY = {
+  command: "claudectx",
+  args: ["mcp"],
+  type: "stdio"
+};
+function planInstall(projectRoot) {
+  const claudeDir = path13.join(projectRoot, ".claude");
+  const settingsPath = path13.join(claudeDir, "settings.json");
+  const existed = fs11.existsSync(settingsPath);
+  let existing = {};
+  if (existed) {
+    try {
+      existing = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+    } catch {
+      existing = {};
+    }
+  }
+  const mcpServers = existing.mcpServers ?? {};
+  const alreadyInstalled = SERVER_NAME in mcpServers;
+  const mergedSettings = {
+    ...existing,
+    mcpServers: {
+      ...mcpServers,
+      [SERVER_NAME]: SERVER_ENTRY
+    }
+  };
+  return { settingsPath, existed, alreadyInstalled, mergedSettings };
+}
+function applyInstall(result) {
+  const dir = path13.dirname(result.settingsPath);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
+  }
+  fs11.writeFileSync(
+    result.settingsPath,
+    JSON.stringify(result.mergedSettings, null, 2) + "\n",
+    "utf-8"
+  );
+}
+function isInstalled(projectRoot) {
+  const settingsPath = path13.join(projectRoot, ".claude", "settings.json");
+  if (!fs11.existsSync(settingsPath)) return false;
+  try {
+    const settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
+    return SERVER_NAME in (settings.mcpServers ?? {});
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/mcp.ts
+async function mcpCommand(options) {
+  const projectRoot = options.path ? path17.resolve(options.path) : process.cwd();
+  if (options.install) {
+    await runInstall(projectRoot);
+    return;
+  }
+  if (options.port) {
+    process.stderr.write(
+      chalk4.yellow(
+        `HTTP transport (--port) is coming in a future release.
+Starting stdio server instead.
+`
+      )
+    );
+  }
+  if (!isInstalled(projectRoot)) {
+    process.stderr.write(
+      chalk4.dim(
+        `Tip: run "claudectx mcp --install" to add this server to .claude/settings.json
+`
+      )
+    );
+  }
+  const { startMcpServer: startMcpServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+  await startMcpServer2();
+}
+async function runInstall(projectRoot) {
+  const result = planInstall(projectRoot);
+  if (result.alreadyInstalled) {
+    logger.success(
+      `claudectx MCP server is already registered in ${chalk4.cyan(result.settingsPath)}`
+    );
+    return;
+  }
+  logger.info(`Adding claudectx MCP server to ${chalk4.cyan(result.settingsPath)} ...`);
+  applyInstall(result);
+  logger.success("MCP server installed!");
+  console.log("");
+  console.log(chalk4.dim("  Claude Code will pick it up on next restart."));
+  console.log(chalk4.dim("  Tools available to Claude:"));
+  console.log(chalk4.dim("    \u2022 smart_read       \u2014 read a symbol instead of a whole file"));
+  console.log(chalk4.dim("    \u2022 search_symbols   \u2014 search for symbols by name"));
+  console.log(chalk4.dim("    \u2022 index_project    \u2014 build the symbol index"));
+  console.log("");
+  console.log(chalk4.dim(`  Settings file: ${result.settingsPath}`));
+}
+
+// src/commands/compress.ts
+init_esm_shims();
+init_session_reader();
+import * as path19 from "path";
+import * as fs16 from "fs";
+
+// src/compressor/session-parser.ts
+init_esm_shims();
+import * as fs14 from "fs";
+function extractText(content) {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n").trim();
+}
+function extractToolCalls(content) {
+  if (!content || typeof content === "string") return [];
+  return content.filter((b) => b.type === "tool_use" && b.name).map((b) => ({ tool: b.name, input: b.input ?? {} }));
+}
+function parseSessionFile(sessionFilePath) {
+  if (!fs14.existsSync(sessionFilePath)) return null;
+  let content;
+  try {
+    content = fs14.readFileSync(sessionFilePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const lines = content.trim().split("\n").filter(Boolean);
+  const turns = [];
+  const totalUsage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 };
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      const msg = entry.message;
+      if (!msg) continue;
+      const role = msg.role === "user" ? "user" : msg.role === "assistant" ? "assistant" : null;
+      if (!role) continue;
+      const usage = msg.usage ?? entry.usage;
+      if (usage) {
+        totalUsage.inputTokens += usage.input_tokens ?? 0;
+        totalUsage.outputTokens += usage.output_tokens ?? 0;
+        totalUsage.cacheReadTokens += usage.cache_read_input_tokens ?? 0;
+      }
+      turns.push({
+        role,
+        text: extractText(msg.content),
+        toolCalls: extractToolCalls(msg.content),
+        usage: usage ? { inputTokens: usage.input_tokens ?? 0, outputTokens: usage.output_tokens ?? 0 } : void 0
+      });
+    } catch {
+    }
+  }
+  const filesRead = /* @__PURE__ */ new Set();
+  const filesEdited = /* @__PURE__ */ new Set();
+  const filesCreated = /* @__PURE__ */ new Set();
+  const commandsRun = [];
+  for (const turn of turns) {
+    for (const tc of turn.toolCalls) {
+      const fp = tc.input.file_path ?? tc.input.path ?? tc.input.file;
+      switch (tc.tool) {
+        case "Read":
+          if (fp) filesRead.add(fp);
+          break;
+        case "Edit":
+        case "MultiEdit":
+          if (fp) filesEdited.add(fp);
+          break;
+        case "Write":
+          if (fp) filesCreated.add(fp);
+          break;
+        case "Bash": {
+          const cmd = tc.input.command;
+          if (cmd) commandsRun.push(cmd.slice(0, 120));
+          break;
+        }
+      }
+    }
+  }
+  const sessionId = sessionFilePath.replace(/^.*[\\/]/, "").replace(".jsonl", "");
+  return {
+    sessionId,
+    filePath: sessionFilePath,
+    turns,
+    totalUsage,
+    filesRead: [...filesRead],
+    filesEdited: [...filesEdited],
+    filesCreated: [...filesCreated],
+    commandsRun,
+    turnCount: turns.filter((t) => t.role === "user").length
+  };
+}
+function buildConversationText(session, maxChars = 2e4) {
+  const parts = [];
+  const relevantTurns = session.turns.slice(-20);
+  for (const turn of relevantTurns) {
+    if (!turn.text && turn.toolCalls.length === 0) continue;
+    const label = turn.role === "user" ? "USER" : "ASSISTANT";
+    const text = turn.text ? turn.text.slice(0, 800) : "";
+    const tools = turn.toolCalls.length > 0 ? `[tools: ${turn.toolCalls.map((t) => t.tool).join(", ")}]` : "";
+    parts.push(`${label}: ${text} ${tools}`.trim());
+  }
+  const body = parts.join("\n\n");
+  return body.length > maxChars ? body.slice(0, maxChars) + "\n\u2026(truncated)" : body;
+}
+
+// src/compressor/summarizer.ts
+init_esm_shims();
+
+// src/shared/config.ts
+init_esm_shims();
+import Conf from "conf";
+var conf = new Conf({
+  projectName: "claudectx",
+  defaults: {
+    defaultModel: "claude-sonnet-4-6",
+    maxMemoryTokens: 3e3,
+    maxClaudeMdTokens: 2e3,
+    watchPollIntervalMs: 2e3
+  }
+});
+function getApiKey() {
+  return process.env.ANTHROPIC_API_KEY || conf.get("anthropicApiKey");
+}
+
+// src/compressor/summarizer.ts
+init_models();
+var SUMMARY_MODEL = "claude-haiku-4-5-20251001";
+var SUMMARY_MAX_TOKENS = 300;
+var SYSTEM_PROMPT = `You are a session-compressor for Claude Code.
+Your job is to produce a concise MEMORY.md entry (max 200 words) for a coding session.
+
+Focus on:
+- What was built or fixed (specific function/file names)
+- Key decisions or patterns established
+- Any gotchas or critical context for future sessions
+
+Output ONLY the entry body \u2014 no frontmatter, no headings, no preamble.
+Use bullet points. Be terse. Prioritise facts over narrative.`;
+async function summariseWithAI(conversationText, apiKey) {
+  const key = apiKey ?? getApiKey();
+  if (!key) {
+    throw new Error("No API key available");
+  }
+  const { default: Anthropic } = await import("@anthropic-ai/sdk");
+  const client = new Anthropic({ apiKey: key });
+  const response = await client.messages.create({
+    model: SUMMARY_MODEL,
+    max_tokens: SUMMARY_MAX_TOKENS,
+    system: SYSTEM_PROMPT,
+    messages: [
+      {
+        role: "user",
+        content: `Summarise this Claude Code session:
+
+${conversationText}`
+      }
+    ]
+  });
+  const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("\n").trim() || "(no summary generated)";
+  return {
+    text,
+    method: "ai",
+    model: SUMMARY_MODEL,
+    inputTokens: response.usage.input_tokens
+  };
+}
+function summariseHeuristically(session) {
+  const lines = [];
+  const firstUser = session.turns.find((t) => t.role === "user" && t.text);
+  if (firstUser?.text) {
+    const brief = firstUser.text.split("\n")[0].slice(0, 200);
+    lines.push(`- **Task:** ${brief}`);
+  }
+  if (session.filesCreated.length > 0) {
+    lines.push(`- **Created:** ${session.filesCreated.map(shortPath2).join(", ")}`);
+  }
+  if (session.filesEdited.length > 0) {
+    const edited = session.filesEdited.slice(0, 8).map(shortPath2).join(", ");
+    lines.push(`- **Edited:** ${edited}${session.filesEdited.length > 8 ? " \u2026" : ""}`);
+  }
+  if (session.filesRead.length > 0) {
+    lines.push(`- **Read ${session.filesRead.length} file(s)**`);
+  }
+  const notable = session.commandsRun.filter((c) => !c.startsWith("echo") && !c.startsWith("cat")).slice(0, 3);
+  if (notable.length > 0) {
+    lines.push(`- **Commands:** ${notable.map((c) => `\`${c.slice(0, 60)}\``).join(", ")}`);
+  }
+  const totalIn = session.totalUsage.inputTokens;
+  const totalOut = session.totalUsage.outputTokens;
+  const cost = calcCost(totalIn, totalOut);
+  lines.push(
+    `- **Stats:** ${session.turnCount} requests, ${fmt(totalIn)}\u2193 / ${fmt(totalOut)}\u2191 tokens, ~$${cost}`
+  );
+  return {
+    text: lines.join("\n") || "- (No session content extracted)",
+    method: "heuristic"
+  };
+}
+async function summariseSession(session, conversationText, apiKey) {
+  const key = apiKey ?? getApiKey();
+  if (key) {
+    try {
+      return await summariseWithAI(conversationText, key);
+    } catch {
+    }
+  }
+  return summariseHeuristically(session);
+}
+function shortPath2(p) {
+  const parts = p.split("/");
+  return parts.slice(-2).join("/");
+}
+function fmt(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+}
+function calcCost(inputTokens, outputTokens) {
+  const p = MODEL_PRICING["claude-sonnet-4-6"];
+  const cost = inputTokens / 1e6 * p.inputPerMillion + outputTokens / 1e6 * p.outputPerMillion;
+  return cost.toFixed(3);
+}
+
+// src/compressor/memory-writer.ts
+init_esm_shims();
+import * as fs15 from "fs";
+import * as path18 from "path";
+function parseMemoryFile(filePath) {
+  if (!fs15.existsSync(filePath)) {
+    return { preamble: "", entries: [] };
+  }
+  const content = fs15.readFileSync(filePath, "utf-8");
+  const markerRegex = /<!-- claudectx-entry: (\d{4}-\d{2}-\d{2}) \| session: ([a-z0-9-]+) -->/g;
+  const indices = [];
+  let match;
+  while (true) {
+    match = markerRegex.exec(content);
+    if (!match) break;
+    indices.push(match.index);
+  }
+  if (indices.length === 0) {
+    return { preamble: content, entries: [] };
+  }
+  const preamble = content.slice(0, indices[0]);
+  const entries = [];
+  for (let i = 0; i < indices.length; i++) {
+    const start = indices[i];
+    const end = i + 1 < indices.length ? indices[i + 1] : content.length;
+    const block = content.slice(start, end).trim();
+    const headerMatch = block.match(
+      /<!-- claudectx-entry: (\d{4}-\d{2}-\d{2}) \| session: ([a-z0-9-]+) -->/
+    );
+    if (!headerMatch) continue;
+    entries.push({
+      date: headerMatch[1],
+      sessionId: headerMatch[2],
+      raw: block
+    });
+  }
+  return { preamble, entries };
+}
+function buildEntryBlock(sessionId, summaryText, date = /* @__PURE__ */ new Date()) {
+  const dateStr = date.toISOString().slice(0, 10);
+  const shortId = sessionId.slice(0, 8);
+  const heading = `### [${dateStr}] Session ${shortId}\u2026`;
+  return [
+    `<!-- claudectx-entry: ${dateStr} | session: ${sessionId} -->`,
+    heading,
+    "",
+    summaryText.trim(),
+    "",
+    "---"
+  ].join("\n");
+}
+function appendEntry(memoryFilePath, sessionId, summaryText, date = /* @__PURE__ */ new Date()) {
+  const { preamble, entries } = parseMemoryFile(memoryFilePath);
+  if (entries.some((e) => e.sessionId === sessionId)) {
+    throw new Error(`Session ${sessionId.slice(0, 8)} is already in MEMORY.md`);
+  }
+  const newBlock = buildEntryBlock(sessionId, summaryText, date);
+  const allBlocks = [...entries.map((e) => e.raw), newBlock];
+  const newContent = (preamble.trimEnd() ? preamble.trimEnd() + "\n\n" : "") + allBlocks.join("\n\n") + "\n";
+  const dir = path18.dirname(memoryFilePath);
+  if (!fs15.existsSync(dir)) {
+    fs15.mkdirSync(dir, { recursive: true });
+  }
+  fs15.writeFileSync(memoryFilePath, newContent, "utf-8");
+  return newContent;
+}
+function pruneOldEntries(memoryFilePath, days) {
+  if (!fs15.existsSync(memoryFilePath)) {
+    return { removed: 0, kept: 0, removedEntries: [] };
+  }
+  const { preamble, entries } = parseMemoryFile(memoryFilePath);
+  const cutoff = /* @__PURE__ */ new Date();
+  cutoff.setDate(cutoff.getDate() - days);
+  const cutoffStr = cutoff.toISOString().slice(0, 10);
+  const kept = entries.filter((e) => e.date >= cutoffStr);
+  const removed = entries.filter((e) => e.date < cutoffStr);
+  if (removed.length === 0) {
+    return { removed: 0, kept: kept.length, removedEntries: [] };
+  }
+  const newContent = (preamble.trimEnd() ? preamble.trimEnd() + "\n\n" : "") + kept.map((e) => e.raw).join("\n\n") + (kept.length > 0 ? "\n" : "");
+  fs15.writeFileSync(memoryFilePath, newContent, "utf-8");
+  return { removed: removed.length, kept: kept.length, removedEntries: removed };
+}
+function isAlreadyCompressed(memoryFilePath, sessionId) {
+  const { entries } = parseMemoryFile(memoryFilePath);
+  return entries.some((e) => e.sessionId === sessionId);
+}
+
+// src/commands/compress.ts
+async function compressCommand(options) {
+  const chalk5 = (await import("chalk")).default;
+  const projectRoot = options.path ? path19.resolve(options.path) : process.cwd();
+  const memoryFilePath = path19.join(projectRoot, "MEMORY.md");
+  const sessionFiles = listSessionFiles();
+  if (sessionFiles.length === 0) {
+    process.stdout.write(chalk5.red("No Claude Code sessions found.\n"));
+    process.stdout.write(chalk5.dim("Sessions are stored in ~/.claude/projects/\n"));
+    process.exitCode = 1;
+    return;
+  }
+  let targetFile;
+  if (options.session) {
+    const match = sessionFiles.find(
+      (f) => f.sessionId === options.session || f.sessionId.startsWith(options.session)
+    );
+    if (!match) {
+      process.stdout.write(chalk5.red(`Session not found: ${options.session}
+`));
+      process.stdout.write(chalk5.dim(`Available: ${sessionFiles.slice(0, 5).map((f) => f.sessionId).join(", ")}
+`));
+      process.exitCode = 1;
+      return;
+    }
+    targetFile = match.filePath;
+  } else {
+    targetFile = sessionFiles[0].filePath;
+  }
+  const sessionId = path19.basename(targetFile, ".jsonl");
+  if (isAlreadyCompressed(memoryFilePath, sessionId)) {
+    if (!options.auto) {
+      process.stdout.write(chalk5.yellow(`Session ${sessionId.slice(0, 8)}\u2026 is already in MEMORY.md \u2014 skipping.
+`));
+    }
+    return;
+  }
+  const parsed = parseSessionFile(targetFile);
+  if (!parsed) {
+    process.stdout.write(chalk5.red(`Failed to parse session file: ${targetFile}
+`));
+    process.exitCode = 1;
+    return;
+  }
+  if (!options.auto) {
+    process.stdout.write(
+      chalk5.cyan(`Compressing session ${chalk5.bold(sessionId.slice(0, 8))}\u2026 `) + chalk5.dim(`(${parsed.turnCount} turns, ${parsed.filesEdited.length} files edited)
+`)
+    );
+  }
+  const conversationText = buildConversationText(parsed);
+  const apiKey = options.apiKey ?? getApiKey();
+  let spinner = null;
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let frameIdx = 0;
+  if (!options.auto && apiKey) {
+    process.stdout.write(chalk5.dim("Summarizing with AI\u2026 "));
+    spinner = setInterval(() => {
+      process.stdout.write(`\r${chalk5.dim("Summarizing with AI\u2026 ")}${frames[frameIdx++ % frames.length]}`);
+    }, 80);
+  }
+  const result = await summariseSession(parsed, conversationText, apiKey ?? void 0);
+  if (spinner) {
+    clearInterval(spinner);
+    process.stdout.write("\r" + " ".repeat(40) + "\r");
+  }
+  appendEntry(memoryFilePath, sessionId, result.text);
+  if (!options.auto) {
+    const methodLabel = result.method === "ai" ? chalk5.green(`AI (${result.model}, ${result.inputTokens} tokens)`) : chalk5.yellow("heuristic (no API key)");
+    process.stdout.write(chalk5.green("\u2713") + ` Appended to ${chalk5.bold(memoryFilePath)} via ${methodLabel}
+`);
+    process.stdout.write("\n" + chalk5.dim("\u2500".repeat(60)) + "\n");
+    process.stdout.write(result.text + "\n");
+    process.stdout.write(chalk5.dim("\u2500".repeat(60)) + "\n");
+  }
+  if (options.prune) {
+    const days = parseInt(options.days ?? "30", 10);
+    if (!fs16.existsSync(memoryFilePath)) return;
+    const pruned = pruneOldEntries(memoryFilePath, days);
+    if (pruned.removed > 0 && !options.auto) {
+      process.stdout.write(
+        chalk5.dim(`Pruned ${pruned.removed} entr${pruned.removed === 1 ? "y" : "ies"} older than ${days} days.
+`)
+      );
+    }
+  }
+}
+
+// src/commands/report.ts
+init_esm_shims();
+
+// src/reporter/usage-aggregator.ts
+init_esm_shims();
+init_session_reader();
+init_session_store();
+init_models();
+function isoDate(d) {
+  return d.toISOString().slice(0, 10);
+}
+function calcCost2(inputTokens, outputTokens, model) {
+  const p = MODEL_PRICING[model];
+  return inputTokens / 1e6 * p.inputPerMillion + outputTokens / 1e6 * p.outputPerMillion;
+}
+async function aggregateUsage(days, model = "claude-sonnet-4-6") {
+  const now = /* @__PURE__ */ new Date();
+  const cutoff = new Date(now);
+  cutoff.setDate(cutoff.getDate() - days);
+  const cutoffMs = cutoff.getTime();
+  const sessionFiles = listSessionFiles().filter((f) => f.mtimeMs >= cutoffMs);
+  const bucketMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < days; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    const dateStr = isoDate(d);
+    bucketMap.set(dateStr, {
+      date: dateStr,
+      sessions: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      requests: 0,
+      costUsd: 0
+    });
+  }
+  let totalRequests = 0;
+  let totalInput = 0;
+  let totalOutput = 0;
+  let totalCacheRead = 0;
+  for (const sf of sessionFiles) {
+    const dateStr = isoDate(new Date(sf.mtimeMs));
+    const bucket = bucketMap.get(dateStr);
+    if (!bucket) continue;
+    const usage = readSessionUsage(sf.filePath);
+    bucket.sessions++;
+    bucket.inputTokens += usage.inputTokens;
+    bucket.outputTokens += usage.outputTokens;
+    bucket.cacheReadTokens += usage.cacheReadTokens;
+    bucket.requests += usage.requestCount;
+    bucket.costUsd += calcCost2(usage.inputTokens, usage.outputTokens, model);
+    totalInput += usage.inputTokens;
+    totalOutput += usage.outputTokens;
+    totalCacheRead += usage.cacheReadTokens;
+    totalRequests += usage.requestCount;
+  }
+  const fileEvents = readAllEvents().filter(
+    (e) => new Date(e.timestamp).getTime() >= cutoffMs
+  );
+  const fileStats = aggregateStats(fileEvents);
+  const topFiles = fileStats.slice(0, 10).map((s) => ({
+    filePath: s.filePath,
+    readCount: s.readCount
+  }));
+  const totalCost = calcCost2(totalInput, totalOutput, model);
+  const cacheHitRate = totalInput > 0 ? Math.round(totalCacheRead / totalInput * 100) : 0;
+  const byDay = [...bucketMap.values()].sort((a, b) => a.date.localeCompare(b.date));
+  const uniqueSessions = new Set(sessionFiles.map((f) => f.sessionId)).size;
+  return {
+    periodDays: days,
+    startDate: isoDate(cutoff),
+    endDate: isoDate(now),
+    totalSessions: uniqueSessions,
+    totalRequests,
+    totalInputTokens: totalInput,
+    totalOutputTokens: totalOutput,
+    totalCacheReadTokens: totalCacheRead,
+    cacheHitRate,
+    totalCostUsd: totalCost,
+    avgCostPerSession: uniqueSessions > 0 ? totalCost / uniqueSessions : 0,
+    avgTokensPerRequest: totalRequests > 0 ? Math.round(totalInput / totalRequests) : 0,
+    byDay,
+    topFiles,
+    model,
+    generatedAt: now.toISOString()
+  };
+}
+
+// src/reporter/formatter.ts
+init_esm_shims();
+function fmtNum2(n) {
+  return n.toLocaleString();
+}
+function fmtCost2(usd) {
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(2)}`;
+}
+function fmtK(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}K` : String(n);
+}
+function bar(value, max, width = 20) {
+  if (max === 0) return " ".repeat(width);
+  const filled = Math.round(value / max * width);
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function shortPath3(p) {
+  const parts = p.split("/");
+  return parts.length > 3 ? "\u2026/" + parts.slice(-3).join("/") : p;
+}
+function formatText(data) {
+  const lines = [];
+  lines.push(
+    `claudectx report \u2014 ${data.periodDays}-day summary (${data.startDate} \u2192 ${data.endDate})`
+  );
+  lines.push("\u2550".repeat(70));
+  lines.push("");
+  lines.push("TOTALS");
+  lines.push("\u2500".repeat(40));
+  lines.push(`  Sessions:              ${fmtNum2(data.totalSessions)}`);
+  lines.push(`  Requests:              ${fmtNum2(data.totalRequests)}`);
+  lines.push(`  Input tokens:          ${fmtNum2(data.totalInputTokens)}`);
+  lines.push(`  Output tokens:         ${fmtNum2(data.totalOutputTokens)}`);
+  lines.push(`  Cache reads:           ${fmtNum2(data.totalCacheReadTokens)}  (${data.cacheHitRate}% hit rate)`);
+  lines.push(`  Total cost (est.):     ${fmtCost2(data.totalCostUsd)}`);
+  lines.push(`  Avg cost/session:      ${fmtCost2(data.avgCostPerSession)}`);
+  lines.push(`  Avg tokens/request:    ${fmtNum2(data.avgTokensPerRequest)}`);
+  lines.push(`  Model:                 ${data.model}`);
+  lines.push("");
+  const activeDays = data.byDay.filter((d) => d.sessions > 0);
+  if (activeDays.length > 0) {
+    lines.push("DAILY USAGE");
+    lines.push("\u2500".repeat(40));
+    const maxTokens = Math.max(...activeDays.map((d) => d.inputTokens), 1);
+    for (const day of data.byDay) {
+      if (day.sessions === 0) continue;
+      const b = bar(day.inputTokens, maxTokens, 18);
+      lines.push(
+        `  ${day.date}  ${b}  ${fmtK(day.inputTokens)} in  ${fmtCost2(day.costUsd)}  (${day.sessions} sess)`
+      );
+    }
+    lines.push("");
+  }
+  if (data.topFiles.length > 0) {
+    lines.push("TOP FILES READ");
+    lines.push("\u2500".repeat(40));
+    const maxReads = Math.max(...data.topFiles.map((f) => f.readCount), 1);
+    for (let i = 0; i < data.topFiles.length; i++) {
+      const f = data.topFiles[i];
+      const b = bar(f.readCount, maxReads, 12);
+      lines.push(`  ${String(i + 1).padStart(2)}.  ${b}  \xD7${f.readCount}  ${shortPath3(f.filePath)}`);
+    }
+    lines.push("");
+  } else {
+    lines.push("  No file-read data. Install hooks: claudectx optimize --hooks");
+    lines.push("");
+  }
+  const tips = [];
+  if (data.cacheHitRate < 30 && data.totalRequests > 5) {
+    tips.push("Cache hit rate is low \u2014 run `claudectx optimize --cache` to fix dynamic content.");
+  }
+  if (data.avgTokensPerRequest > 1e4) {
+    tips.push("High tokens/request \u2014 run `claudectx optimize --claudemd` to split your CLAUDE.md.");
+  }
+  if (data.topFiles.length === 0) {
+    tips.push("Install hooks to track file reads: `claudectx optimize --hooks`.");
+  }
+  if (tips.length > 0) {
+    lines.push("OPTIMISATION TIPS");
+    lines.push("\u2500".repeat(40));
+    tips.forEach((t) => lines.push(`  \u26A1 ${t}`));
+    lines.push("");
+  }
+  lines.push(`Generated at: ${data.generatedAt}`);
+  return lines.join("\n");
+}
+function formatJSON(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatMarkdown(data) {
+  const lines = [];
+  lines.push(`# claudectx Report`);
+  lines.push("");
+  lines.push(`**Period:** ${data.startDate} \u2192 ${data.endDate} (${data.periodDays} days)`);
+  lines.push(`**Generated:** ${new Date(data.generatedAt).toLocaleString()}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("|--------|-------|");
+  lines.push(`| Sessions | ${fmtNum2(data.totalSessions)} |`);
+  lines.push(`| Requests | ${fmtNum2(data.totalRequests)} |`);
+  lines.push(`| Input tokens | ${fmtNum2(data.totalInputTokens)} |`);
+  lines.push(`| Output tokens | ${fmtNum2(data.totalOutputTokens)} |`);
+  lines.push(`| Cache hit rate | ${data.cacheHitRate}% |`);
+  lines.push(`| Total cost (est.) | ${fmtCost2(data.totalCostUsd)} |`);
+  lines.push(`| Avg cost/session | ${fmtCost2(data.avgCostPerSession)} |`);
+  lines.push(`| Avg tokens/request | ${fmtNum2(data.avgTokensPerRequest)} |`);
+  lines.push(`| Model | \`${data.model}\` |`);
+  lines.push("");
+  const activeDays = data.byDay.filter((d) => d.sessions > 0);
+  if (activeDays.length > 0) {
+    lines.push("## Daily Breakdown");
+    lines.push("");
+    lines.push("| Date | Sessions | Input tokens | Cost |");
+    lines.push("|------|----------|-------------|------|");
+    for (const day of activeDays) {
+      lines.push(
+        `| ${day.date} | ${day.sessions} | ${fmtK(day.inputTokens)} | ${fmtCost2(day.costUsd)} |`
+      );
+    }
+    lines.push("");
+  }
+  if (data.topFiles.length > 0) {
+    lines.push("## Top Files Read");
+    lines.push("");
+    lines.push("| # | File | Reads |");
+    lines.push("|---|------|-------|");
+    data.topFiles.forEach((f, i) => {
+      lines.push(`| ${i + 1} | \`${shortPath3(f.filePath)}\` | ${f.readCount} |`);
+    });
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function format(data, mode) {
+  switch (mode) {
+    case "json":
+      return formatJSON(data);
+    case "markdown":
+      return formatMarkdown(data);
+    default:
+      return formatText(data);
+  }
+}
+
+// src/commands/report.ts
+var MODEL_ALIASES2 = {
+  haiku: "claude-haiku-4-5-20251001",
+  sonnet: "claude-sonnet-4-6",
+  opus: "claude-opus-4-6",
+  "claude-haiku-4-5-20251001": "claude-haiku-4-5-20251001",
+  "claude-sonnet-4-6": "claude-sonnet-4-6",
+  "claude-opus-4-6": "claude-opus-4-6"
+};
+async function reportCommand(options) {
+  const days = Math.max(1, parseInt(options.days ?? "7", 10));
+  const modelAlias = options.model ?? "sonnet";
+  const model = MODEL_ALIASES2[modelAlias] ?? "claude-sonnet-4-6";
+  const mode = options.json ? "json" : options.markdown ? "markdown" : "text";
+  const data = await aggregateUsage(days, model);
+  const output = format(data, mode);
+  process.stdout.write(output + "\n");
+}
+
+// src/index.ts
+var VERSION = "1.0.0";
+var DESCRIPTION = "Reduce Claude Code token usage by up to 80%. Context analyzer, auto-optimizer, live dashboard, and smart MCP tools.";
+var program = new Command();
+program.name("claudectx").description(DESCRIPTION).version(VERSION);
+program.command("analyze").alias("a").description("Analyze token usage in the current Claude Code project").option("-p, --path <path>", "Path to project directory (default: cwd)").option("-j, --json", "Output raw JSON (for scripting)").option("-m, --model <model>", "Claude model to estimate costs for (haiku|sonnet|opus)", "sonnet").option("-w, --watch", "Re-run analysis on CLAUDE.md / MEMORY.md changes").action(async (options) => {
+  await analyzeCommand(options);
+});
+program.command("optimize").alias("o").description("Auto-fix token waste issues in CLAUDE.md, .claudeignore, and hooks").option("-p, --path <path>", "Path to project directory (default: cwd)").option("--apply", "Apply all fixes without prompting").option("--dry-run", "Preview changes without applying").option("--claudemd", "Only optimize CLAUDE.md (split into @files)").option("--ignorefile", "Only generate .claudeignore").option("--cache", "Only fix cache-busting content").option("--hooks", "Only install session hooks").option("--api-key <key>", "Anthropic API key (for AI-powered CLAUDE.md rewriting)").action(async (options) => {
+  await optimizeCommand(options);
+});
+program.command("watch").alias("w").description("Live token-usage dashboard \u2014 tracks files read and session cost in real time").option("--session <id>", "Watch a specific session ID (default: most recent)").option("-m, --model <model>", "Model for cost estimates (haiku|sonnet|opus)", "sonnet").option("--log-stdin", "Read hook JSON from stdin and log the file path (called by Claude Code hook)").option("--clear", "Clear the session file-read log and exit").action(async (options) => {
+  await watchCommand(options);
+});
+program.command("mcp").description("Start the smart MCP server \u2014 symbol-level file reading for Claude Code").option("-p, --path <path>", "Project root (default: cwd)").option("--port <port>", "HTTP transport port (stdio is default; HTTP coming soon)").option("--install", "Add server to .claude/settings.json and exit").action(async (options) => {
+  await mcpCommand(options);
+});
+program.command("compress").alias("c").description("Compress a Claude Code session into a compact MEMORY.md entry").option("-p, --path <path>", "Project directory (default: cwd)").option("--session <id>", "Compress specific session ID (default: most recent)").option("--auto", "Non-interactive mode (for hooks)").option("--prune", "Also prune old MEMORY.md entries").option("--days <n>", "Days threshold for pruning (with --prune)", "30").option("--api-key <key>", "Anthropic API key for AI-powered summarization").action(async (options) => {
+  await compressCommand(options);
+});
+program.command("report").alias("r").description("Show token usage analytics for the last N days").option("-p, --path <path>", "Project directory (default: cwd)").option("--days <n>", "Number of days to include", "7").option("--json", "Machine-readable JSON output").option("--markdown", "GitHub-flavoured Markdown output").option("-m, --model <model>", "Claude model for cost estimates (haiku|sonnet|opus)", "sonnet").action(async (options) => {
+  await reportCommand(options);
+});
+program.parse();
+//# sourceMappingURL=index.mjs.map