@misterhuydo/cairn-mcp 1.2.1 → 1.2.2

package/README.md

@@ -36,6 +36,28 @@ Restart Claude Code. Done.
 
 ---
 
+## Passive hooks (recommended)
+
+Install once and Cairn works automatically — no need to call `cairn_bundle` or `cairn_checkpoint` manually.
+
+**Global (all projects):**
+
+```bash
+cairn install-hooks --global
+```
+
+**Project-only:**
+
+```bash
+cairn install-hooks
+```
+
+| Hook | Trigger | Effect |
+|---|---|---|
+| `PreToolUse[Read]` | Every file read | Source files compressed ~68% before Claude sees them |
+| `Stop` | Every response | Session auto-saved to `.cairn/session.json` |
+| `UserPromptSubmit` | First message of session | Claude reminded of prior session, prompted to call `cairn_resume` |
+
 ## How it works
 
 Cairn works like git — it looks for `.cairn/` in your current working directory. Run Claude Code from your project root and Cairn automatically stores the index at `.cairn/index.db` and bundles at `.cairn/bundles/`.
@@ -158,6 +180,15 @@ Covers: XSS · XXE · SQL injection · command injection · weak crypto · hardc
 
 ---
 
+### `cairn_minify` — Minify a single file
+Minify one source file on demand. Returns compressed content with a `[cairn: N → M lines]` header. Useful when passive hooks are not installed.
+
+```
+cairn_minify({ file_path: "/abs/path/to/Service.java" })
+```
+
+---
+
 ### `cairn_checkpoint` — Save session state
 Tell Cairn what you were working on so the next session can pick up where you left off.
 
@@ -223,7 +254,16 @@ cairn_resume()
 
 ## Typical session
 
-**Fresh start:**
+**With passive hooks (recommended):**
+```
+1. cairn_maintain     → index project
+2. cairn_search       → find the symbols you need
+3. cairn_describe     → understand a module before modifying it
+4. cairn_security     → check for issues before a PR
+   (reads auto-compressed, session auto-saved — nothing else needed)
+```
+
+**Without hooks:**
 ```
 1. cairn_maintain     → index project (persists between sessions)
 2. cairn_search       → find the symbols you need
@@ -251,16 +291,14 @@ Claude: cairn_resume
            Ready to continue."
 
 ─── DURING SESSION ────────────────────────────────────────────
-Claude uses: cairn_search, cairn_bundle, cairn_code_graph, cairn_security
+Claude uses: cairn_search, cairn_code_graph, cairn_security
              as needed — all reading from .cairn/index.db in cwd
+             (file reads auto-compressed by PreToolUse hook)
 
 ─── END OF SESSION ────────────────────────────────────────────
 You:    "Ok let's stop here for today"
-Claude: cairn_checkpoint
-          message="Fixed EUR formatting in PaymentStep, multi-currency complete"
-          active_files=["src/components/checkout/PaymentStep.vue"]
-          notes=["Still need to add JPY — no decimal places", "QA needs to test AED"]
-        → "Session saved. Resume anytime with cairn_resume."
+        (Stop hook fires → .cairn/session.json auto-saved)
+        → Next session: cairn_resume picks up automatically
 ```
 
 ---

package/bin/cairn-cli.js

@@ -9,6 +9,12 @@ import { checkpoint } from '../src/tools/checkpoint.js';
 
 const MINIFY_LANGS = new Set(['java', 'typescript', 'javascript', 'vue', 'python', 'sql']);
 
+// Ensure any unexpected crash in a hook subcommand passes through rather than blocking
+process.on('uncaughtException', (e) => {
+  process.stderr.write(`cairn: ${e.message}\n`);
+  process.exit(0);
+});
+
 const subcommand = process.argv[2];
 
 if (subcommand === 'minify') {
@@ -56,6 +62,27 @@ if (subcommand === 'minify') {
   checkpoint(null, { message, active_files: [], notes: [] });
   process.exit(0);
 
+} else if (subcommand === 'resume-hint') {
+  const cairnDir = path.join(process.cwd(), '.cairn');
+  const sessionPath = path.join(cairnDir, 'session.json');
+
+  if (!fs.existsSync(sessionPath)) process.exit(0);
+
+  // Rate-limit: show at most once every 30 minutes to avoid spamming mid-session
+  const lockPath = path.join(cairnDir, '.hint-lock');
+  const LOCK_TTL_MS = 30 * 60 * 1000;
+  if (fs.existsSync(lockPath)) {
+    const age = Date.now() - fs.statSync(lockPath).mtimeMs;
+    if (age < LOCK_TTL_MS) process.exit(0);
+  }
+
+  const session = JSON.parse(fs.readFileSync(sessionPath, 'utf8'));
+  const when = new Date(session.checkpoint_at).toLocaleString();
+  process.stdout.write(`[cairn] Prior session: "${session.message}" (${when}). Call cairn_resume to restore prior context.\n`);
+
+  fs.writeFileSync(lockPath, new Date().toISOString(), 'utf8');
+  process.exit(0);
+
 } else if (subcommand === 'install-hooks') {
   const isGlobal = process.argv.includes('--global');
   const settingsDir = isGlobal
@@ -74,7 +101,7 @@ if (subcommand === 'minify') {
 
   settings.hooks = settings.hooks || {};
 
-  // Add PreToolUse hook for Read
+  // PreToolUse[Read] → cairn minify
   const preHooks = settings.hooks.PreToolUse || [];
   const hasMinify = preHooks.some(h =>
     h.matcher === 'Read' && h.hooks?.some(hh => hh.command === 'cairn minify')
@@ -84,7 +111,7 @@ if (subcommand === 'minify') {
     settings.hooks.PreToolUse = preHooks;
   }
 
-  // Add Stop hook for auto-checkpoint
+  // Stop → cairn checkpoint --auto
   const stopHooks = settings.hooks.Stop || [];
   const hasCheckpoint = stopHooks.some(h =>
     h.hooks?.some(hh => hh.command === 'cairn checkpoint --auto')
@@ -94,6 +121,16 @@ if (subcommand === 'minify') {
     settings.hooks.Stop = stopHooks;
   }
 
+  // UserPromptSubmit → cairn resume-hint
+  const submitHooks = settings.hooks.UserPromptSubmit || [];
+  const hasResumeHint = submitHooks.some(h =>
+    h.hooks?.some(hh => hh.command === 'cairn resume-hint')
+  );
+  if (!hasResumeHint) {
+    submitHooks.push({ hooks: [{ type: 'command', command: 'cairn resume-hint' }] });
+    settings.hooks.UserPromptSubmit = submitHooks;
+  }
+
   fs.mkdirSync(settingsDir, { recursive: true });
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
 
@@ -101,11 +138,12 @@ if (subcommand === 'minify') {
   console.log(`Cairn hooks installed in ${scope}`);
   console.log('');
   console.log('Active hooks:');
-  console.log('  PreToolUse[Read] → cairn minify            (compress source files)');
-  console.log('  Stop             → cairn checkpoint --auto  (auto-save session)');
+  console.log('  PreToolUse[Read]    → cairn minify            (compress source files)');
+  console.log('  Stop                → cairn checkpoint --auto  (auto-save session)');
+  console.log('  UserPromptSubmit    → cairn resume-hint        (remind Claude of prior session)');
   process.exit(0);
 
 } else {
-  console.error('Usage: cairn <minify|checkpoint --auto|install-hooks>');
+  console.error('Usage: cairn <minify|checkpoint --auto|resume-hint|install-hooks [--global]>');
   process.exit(1);
 }

package/bin/cairn.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import { spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';

package/index.js

@@ -1,165 +1,178 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-
-import { openDB }       from './src/graph/db.js';
-import { maintain }     from './src/tools/maintain.js';
-import { search }       from './src/tools/search.js';
-import { describe }     from './src/tools/describe.js';
-import { codeGraph }    from './src/tools/codeGraph.js';
-import { security }     from './src/tools/security.js';
-import { bundle }       from './src/tools/bundle.js';
-import { checkpoint }   from './src/tools/checkpoint.js';
-import { resume }       from './src/tools/resume.js';
-
-const db = openDB();
-
-const server = new Server(
-  { name: 'cairn', version: '1.0.0' },
-  { capabilities: { tools: {} } }
-);
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: 'cairn_maintain',
-      description: 'Index the current project into Cairn\'s polyglot knowledge graph. Supports Java, TypeScript, JavaScript, Vue, Python, SQL, config, and Markdown. Indexes from the current working directory. Run at session start or after major changes.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          languages: {
-            type: 'array', items: { type: 'string' },
-            description: 'Optional: limit to specific languages e.g. ["java","typescript"]',
-          },
-        },
-      },
-    },
-    {
-      name: 'cairn_search',
-      description: 'Search the codebase by concept across all languages. Returns ranked symbols with scores.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          query:    { type: 'string' },
-          limit:    { type: 'number', default: 10 },
-          language: { type: 'string', description: 'Optional: filter by language' },
-          kind:     { type: 'string', description: 'Optional: class/function/component/table/...' },
-        },
-        required: ['query'],
-      },
-    },
-    {
-      name: 'cairn_describe',
-      description: 'Describe what a directory/module does: symbols, responsibilities, upstream/downstream deps.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          path: { type: 'string', description: 'Directory or file path to describe' },
-        },
-        required: ['path'],
-      },
-    },
-    {
-      name: 'cairn_code_graph',
-      description: 'Analyze module dependencies and instability metrics across all languages. Use before refactoring.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          module: { type: 'string', description: 'Optional: scope to a specific module/package' },
-          mode:   { type: 'string', enum: ['instability', 'health', 'cycles'] },
-        },
-        required: ['mode'],
-      },
-    },
-    {
-      name: 'cairn_security',
-      description: 'Scan for security vulnerabilities across all languages (XSS, XXE, SQLi, weak crypto, hardcoded secrets, etc.)',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          paths:    { type: 'array', items: { type: 'string' }, description: 'Optional: scope to specific paths' },
-          severity: { type: 'string', enum: ['HIGH', 'MEDIUM', 'LOW', 'ALL'], default: 'HIGH' },
-          language: { type: 'string', description: 'Optional: scope to a specific language' },
-        },
-      },
-    },
-    {
-      name: 'cairn_bundle',
-      description: `Produce a minified single-file snapshot of source code for Claude to read.
-Strips comments, empty lines, and optionally styles. Returns the bundle file path and compression stats.
-Use AFTER cairn_search to get a readable version of the files Claude needs to work with.
-Typical workflow: cairn_search → find files → cairn_bundle those paths → Claude reads bundle.`,
-      inputSchema: {
-        type: 'object',
-        properties: {
-          bundle_name: {
-            type: 'string', default: 'default',
-            description: 'Name for the bundle file (saved to .cairn/bundles/<name>.txt)',
-          },
-          filter_paths: {
-            type: 'array', items: { type: 'string' },
-            description: 'Optional: only include files under these relative paths',
-          },
-          filter_language: {
-            type: 'string',
-            description: 'Optional: only bundle this language (java/typescript/vue/python/...)',
-          },
-          no_comments:    { type: 'boolean', default: true,  description: 'Strip code comments' },
-          no_empty_lines: { type: 'boolean', default: true,  description: 'Remove empty lines' },
-          no_style:       { type: 'boolean', default: false, description: 'Skip <style> blocks in Vue files' },
-          aggressive:     { type: 'boolean', default: false, description: 'Aggressive whitespace/punctuation minification' },
-          only_changed:   { type: 'boolean', default: false, description: 'Incremental: only re-bundle files changed since last run' },
-          max_size_kb:    { type: 'number',  default: 800,   description: 'Safety cap in KB to avoid context window overflow' },
-        },
-      },
-    },
-    {
-      name: 'cairn_checkpoint',
-      description: 'Save current session state to .cairn/session.json so it can be restored next session with cairn_resume.',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          message: {
-            type: 'string',
-            description: 'What you were working on — will be shown on resume',
-          },
-          active_files: {
-            type: 'array', items: { type: 'string' },
-            description: 'Optional: absolute paths to files actively being worked on',
-          },
-          notes: {
-            type: 'array', items: { type: 'string' },
-            description: 'Optional: things Claude should remember next session',
-          },
-        },
-        required: ['message'],
-      },
-    },
-    {
-      name: 'cairn_resume',
-      description: 'Restore the last saved session state. Detects which files changed since the checkpoint and incrementally re-indexes only those files. Call at the start of a session instead of cairn_maintain when resuming work.',
-      inputSchema: {
-        type: 'object',
-        properties: {},
-      },
-    },
-  ],
-}));
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
-  switch (name) {
-    case 'cairn_maintain':    return await maintain(db, args);
-    case 'cairn_search':      return search(db, args);
-    case 'cairn_describe':    return describe(db, args);
-    case 'cairn_code_graph':  return codeGraph(db, args);
-    case 'cairn_security':    return security(db, args);
-    case 'cairn_bundle':      return await bundle(db, args);
-    case 'cairn_checkpoint':  return checkpoint(db, args);
-    case 'cairn_resume':      return await resume(db);
-    default: throw new Error(`Unknown tool: ${name}`);
-  }
-});
-
-const transport = new StdioServerTransport();
-await server.connect(transport);
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+import { openDB }       from './src/graph/db.js';
+import { maintain }     from './src/tools/maintain.js';
+import { search }       from './src/tools/search.js';
+import { describe }     from './src/tools/describe.js';
+import { codeGraph }    from './src/tools/codeGraph.js';
+import { security }     from './src/tools/security.js';
+import { bundle }       from './src/tools/bundle.js';
+import { checkpoint }   from './src/tools/checkpoint.js';
+import { resume }       from './src/tools/resume.js';
+import { minify }       from './src/tools/minify.js';
+
+const db = openDB();
+
+const server = new Server(
+  { name: 'cairn', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'cairn_maintain',
+      description: 'Index the current project into Cairn\'s polyglot knowledge graph. Supports Java, TypeScript, JavaScript, Vue, Python, SQL, config, and Markdown. Indexes from the current working directory. Run at session start or after major changes.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          languages: {
+            type: 'array', items: { type: 'string' },
+            description: 'Optional: limit to specific languages e.g. ["java","typescript"]',
+          },
+        },
+      },
+    },
+    {
+      name: 'cairn_search',
+      description: 'Search the codebase by concept across all languages. Returns ranked symbols with scores.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query:    { type: 'string' },
+          limit:    { type: 'number', default: 10 },
+          language: { type: 'string', description: 'Optional: filter by language' },
+          kind:     { type: 'string', description: 'Optional: class/function/component/table/...' },
+        },
+        required: ['query'],
+      },
+    },
+    {
+      name: 'cairn_describe',
+      description: 'Describe what a directory/module does: symbols, responsibilities, upstream/downstream deps.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          path: { type: 'string', description: 'Directory or file path to describe' },
+        },
+        required: ['path'],
+      },
+    },
+    {
+      name: 'cairn_code_graph',
+      description: 'Analyze module dependencies and instability metrics across all languages. Use before refactoring.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          module: { type: 'string', description: 'Optional: scope to a specific module/package' },
+          mode:   { type: 'string', enum: ['instability', 'health', 'cycles'] },
+        },
+        required: ['mode'],
+      },
+    },
+    {
+      name: 'cairn_security',
+      description: 'Scan for security vulnerabilities across all languages (XSS, XXE, SQLi, weak crypto, hardcoded secrets, etc.)',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          paths:    { type: 'array', items: { type: 'string' }, description: 'Optional: scope to specific paths' },
+          severity: { type: 'string', enum: ['HIGH', 'MEDIUM', 'LOW', 'ALL'], default: 'HIGH' },
+          language: { type: 'string', description: 'Optional: scope to a specific language' },
+        },
+      },
+    },
+    {
+      name: 'cairn_bundle',
+      description: `Produce a minified single-file snapshot of source code for Claude to read.
+Strips comments, empty lines, and optionally styles. Returns the bundle file path and compression stats.
+Use AFTER cairn_search to get a readable version of the files Claude needs to work with.
+Typical workflow: cairn_search → find files → cairn_bundle those paths → Claude reads bundle.`,
+      inputSchema: {
+        type: 'object',
+        properties: {
+          bundle_name: {
+            type: 'string', default: 'default',
+            description: 'Name for the bundle file (saved to .cairn/bundles/<name>.txt)',
+          },
+          filter_paths: {
+            type: 'array', items: { type: 'string' },
+            description: 'Optional: only include files under these relative paths',
+          },
+          filter_language: {
+            type: 'string',
+            description: 'Optional: only bundle this language (java/typescript/vue/python/...)',
+          },
+          no_comments:    { type: 'boolean', default: true,  description: 'Strip code comments' },
+          no_empty_lines: { type: 'boolean', default: true,  description: 'Remove empty lines' },
+          no_style:       { type: 'boolean', default: false, description: 'Skip <style> blocks in Vue files' },
+          aggressive:     { type: 'boolean', default: false, description: 'Aggressive whitespace/punctuation minification' },
+          only_changed:   { type: 'boolean', default: false, description: 'Incremental: only re-bundle files changed since last run' },
+          max_size_kb:    { type: 'number',  default: 800,   description: 'Safety cap in KB to avoid context window overflow' },
+        },
+      },
+    },
+    {
+      name: 'cairn_checkpoint',
+      description: 'Save current session state to .cairn/session.json so it can be restored next session with cairn_resume.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          message: {
+            type: 'string',
+            description: 'What you were working on — will be shown on resume',
+          },
+          active_files: {
+            type: 'array', items: { type: 'string' },
+            description: 'Optional: absolute paths to files actively being worked on',
+          },
+          notes: {
+            type: 'array', items: { type: 'string' },
+            description: 'Optional: things Claude should remember next session',
+          },
+        },
+        required: ['message'],
+      },
+    },
+    {
+      name: 'cairn_resume',
+      description: 'Restore the last saved session state. Detects which files changed since the checkpoint and incrementally re-indexes only those files. Call at the start of a session instead of cairn_maintain when resuming work.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    },
+    {
+      name: 'cairn_minify',
+      description: 'Minify a single source file and return compressed content. Strips comments and empty lines. Useful when passive hooks are not installed. Supports java, typescript, javascript, vue, python, sql.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          file_path: { type: 'string', description: 'Absolute path to the file to minify' },
+        },
+        required: ['file_path'],
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  switch (name) {
+    case 'cairn_maintain':    return await maintain(db, args);
+    case 'cairn_search':      return search(db, args);
+    case 'cairn_describe':    return describe(db, args);
+    case 'cairn_code_graph':  return codeGraph(db, args);
+    case 'cairn_security':    return security(db, args);
+    case 'cairn_bundle':      return await bundle(db, args);
+    case 'cairn_checkpoint':  return checkpoint(db, args);
+    case 'cairn_resume':      return await resume(db);
+    case 'cairn_minify':      return minify(db, args);
+    default: throw new Error(`Unknown tool: ${name}`);
+  }
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -1,44 +1,44 @@
-{
-  "name": "@misterhuydo/cairn-mcp",
-  "version": "1.2.1",
-  "description": "MCP server that gives Claude Code persistent memory across sessions. Index your codebase once, search symbols, bundle source, scan for vulnerabilities, and checkpoint/resume work — across Java, TypeScript, Vue, Python, SQL and more.",
-  "type": "module",
-  "main": "index.js",
-  "bin": {
-    "cairn-mcp": "bin/cairn-mcp.js",
-    "cairn": "bin/cairn.js"
-  },
-  "scripts": {
-    "start": "node --experimental-sqlite index.js"
-  },
-  "engines": {
-    "node": ">=22.15.0"
-  },
-  "keywords": [
-    "mcp",
-    "claude",
-    "claude-code",
-    "knowledge-graph",
-    "codebase-search",
-    "polyglot",
-    "java",
-    "typescript",
-    "vue",
-    "python",
-    "sqlite",
-    "developer-tools"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/misterhuydo/Cairn.git"
-  },
-  "homepage": "https://github.com/misterhuydo/Cairn#readme",
-  "bugs": {
-    "url": "https://github.com/misterhuydo/Cairn/issues"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "fast-glob": "^3.3.0"
-  }
-}
+{
+  "name": "@misterhuydo/cairn-mcp",
+  "version": "1.2.2",
+  "description": "MCP server that gives Claude Code persistent memory across sessions. Index your codebase once, search symbols, bundle source, scan for vulnerabilities, and checkpoint/resume work — across Java, TypeScript, Vue, Python, SQL and more.",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "cairn-mcp": "bin/cairn-mcp.js",
+    "cairn": "bin/cairn.js"
+  },
+  "scripts": {
+    "start": "node --experimental-sqlite index.js"
+  },
+  "engines": {
+    "node": ">=22.15.0"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "claude-code",
+    "knowledge-graph",
+    "codebase-search",
+    "polyglot",
+    "java",
+    "typescript",
+    "vue",
+    "python",
+    "sqlite",
+    "developer-tools"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/misterhuydo/Cairn.git"
+  },
+  "homepage": "https://github.com/misterhuydo/Cairn#readme",
+  "bugs": {
+    "url": "https://github.com/misterhuydo/Cairn/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "fast-glob": "^3.3.0"
+  }
+}

package/src/tools/minify.js

@@ -0,0 +1,40 @@
+import fs from 'fs';
+import path from 'path';
+import { LANGUAGE_MAP } from '../indexer/fileWalker.js';
+import { minifyContent } from '../bundler/minifier.js';
+import { minifyVue } from '../bundler/vueMinifier.js';
+
+const MINIFY_LANGS = new Set(['java', 'typescript', 'javascript', 'vue', 'python', 'sql']);
+
+export function minify(_db, { file_path }) {
+  if (!file_path) throw new Error('file_path is required');
+
+  const ext = path.extname(file_path).toLowerCase();
+  const lang = LANGUAGE_MAP[ext];
+
+  if (!lang || !MINIFY_LANGS.has(lang)) {
+    return {
+      content: [{
+        type: 'text',
+        text: JSON.stringify({ skipped: true, reason: `language '${lang ?? ext}' is not minified` }),
+      }],
+    };
+  }
+
+  const content = fs.readFileSync(file_path, 'utf8');
+  const originalLines = content.split('\n').length;
+
+  const minified = lang === 'vue'
+    ? minifyVue(content)
+    : minifyContent(content, lang);
+
+  const minifiedLines = minified.split('\n').length;
+  const pct = originalLines > 0 ? Math.round((1 - minifiedLines / originalLines) * 100) : 0;
+
+  return {
+    content: [{
+      type: 'text',
+      text: `[cairn: ${originalLines} → ${minifiedLines} lines (-${pct}%)]\n${minified}`,
+    }],
+  };
+}