smcreader 0.0.0-stage → 0.1.2

package/lib/reader-store.js

@@ -0,0 +1,316 @@
+/**
+ * ReaderStore — document storage for the reader MCP (pull model of context).
+ *
+ * Keeps large texts OUTSIDE the main agent's context: the raw content is spilled
+ * to disk ($READER_DIR/ctx_<8hex>.txt + .meta.json); the Map holds only
+ * metadata + the id of the haiku dialog session. Document text is never kept
+ * in process memory — peek() reads from disk.
+ *
+ * No LLM and no SDK — 100% unit-testable. The Haiku transport lives in reader-model.js.
+ *
+ * CROSS-PROCESS: the directory is shared by several processes (the hook command
+ * writes, the MCP server reads). Disk is the source of truth: list, the MAX_OPEN
+ * limit and eviction count documents by .meta.json files in the directory, not by
+ * this process's Map; last-access time is the files' mtime (touch() sets it on every
+ * get), so LRU and sweeping see accesses from any process. The Map holds only what
+ * does not go to disk: the haiku dialog id, the question counter, the ask queue.
+ *
+ * Document owner: a single store may serve several sessions, and without ownership
+ * a large output in one session would evict another session's documents, and
+ * list/close would be shared. meta.owner (session id) is set at open: the MAX_OPEN
+ * limit and eviction apply per owner, list({owner}) returns only that owner's
+ * documents, close(id, {owner}) refuses to close someone else's. Reading by id
+ * (get/peek/ask) is not restricted: only whoever was given the id knows it (e.g. a
+ * handoff successor). No owner passed — legacy behavior (a store used by a single
+ * agent has nothing to share).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const OPEN_MAX = 5 * 1024 * 1024;   // >5MB — refused: grep the raw file directly
+const ASK_MAX = 700 * 1024;         // >700KB — open works, but ask is unavailable (haiku window)
+const MAX_OPEN = 10;                // max open readers
+const MAX_ASKS = 20;                // max questions per reader
+const SWEEP_AGE_MS = 48 * 60 * 60 * 1000; // on-disk TTL of raw files
+const PREVIEW_HEAD = 20;
+const PREVIEW_TAIL = 10;
+const PREVIEW_CHAR_CAP = 1500;
+const PEEK_MAX_LINES = 400;
+
+function createReaderStore({ dir, now = Date.now, log = console.log } = {}) {
+  if (!dir) throw new Error('createReaderStore requires {dir}');
+  fs.mkdirSync(dir, { recursive: true });
+
+  /** @type {Map<string, object>} id -> entry */
+  const entries = new Map();
+
+  // Access counter — the LRU order. A counter rather than now(): an open and an
+  // access within the same millisecond would get the same stamp, and the victim
+  // would be chosen arbitrarily. useSeq grows strictly monotonically, so "never
+  // accessed" naturally degenerates into "by open time".
+  let useSeq = 0;
+  function touch(entry) {
+    entry.useSeq = ++useSeq;
+    entry.lastUsedAt = now();
+    // Make the access visible to other processes and to sweeping: mtime of both files = access time.
+    const t = entry.lastUsedAt / 1000;
+    for (const p of [txtPath(entry.id), metaPath(entry.id)]) {
+      try { fs.utimesSync(p, t, t); } catch (_) { /* file already gone — get will handle it */ }
+    }
+    return entry;
+  }
+
+  const ID_RE = /^ctx_[0-9a-f]{8}$/;
+  const validId = (id) => typeof id === 'string' && ID_RE.test(id);
+  const txtPath = (id) => path.join(dir, `${id}.txt`);
+  const metaPath = (id) => path.join(dir, `${id}.meta.json`);
+
+  /**
+   * All open documents in the DIRECTORY (not only this process's). Own entries come from
+   * the Map with their asks/useSeq; foreign ones (opened by another process) come from
+   * disk: lastUsedAt = meta mtime, useSeq 0. Corrupt meta or missing raw file — no document.
+   */
+  function allOpen() {
+    let names;
+    try { names = fs.readdirSync(dir); } catch (_) { return []; }
+    const out = [];
+    for (const name of names) {
+      const m = /^(ctx_[0-9a-f]{8})\.meta\.json$/.exec(name);
+      if (!m) continue;
+      const id = m[1];
+      const hit = entries.get(id);
+      if (hit && !hit.closed) {
+        if (fs.existsSync(txtPath(id))) out.push(hit); else entries.delete(id);
+        continue;
+      }
+      try {
+        const meta = JSON.parse(fs.readFileSync(metaPath(id), 'utf8'));
+        if (!fs.existsSync(txtPath(id))) continue;
+        out.push({ id, meta, asks: 0, useSeq: 0, lastUsedAt: fs.statSync(metaPath(id)).mtimeMs, closed: false });
+      } catch (_) { /* corrupt meta / race with close */ }
+    }
+    return out;
+  }
+
+  /** a has been idle longer than b: earlier last access; within the same millisecond — by counter. */
+  const lastUse = (e) => e.lastUsedAt || e.meta.createdAt || 0;
+  const older = (a, b) => (lastUse(a) !== lastUse(b) ? lastUse(a) < lastUse(b) : a.useSeq <= b.useSeq);
+
+  /** Delete ctx files older than SWEEP_AGE_MS (called on store creation and in open). */
+  function sweep() {
+    let removed = 0;
+    let names;
+    try { names = fs.readdirSync(dir); } catch (_) { return 0; }
+    for (const name of names) {
+      if (!/^ctx_[0-9a-f]{8}\.(txt|meta\.json)$/.test(name)) continue;
+      const p = path.join(dir, name);
+      try {
+        if (now() - fs.statSync(p).mtimeMs > SWEEP_AGE_MS) {
+          fs.unlinkSync(p);
+          removed++;
+          entries.delete(name.replace(/\.(txt|meta\.json)$/, ''));
+        }
+      } catch (_) { /* race with close — harmless */ }
+    }
+    return removed;
+  }
+
+  function makePreview(text) {
+    const lines = text.split('\n');
+    const numbered = (arr, offset) => arr.map((l, i) => `${offset + i + 1}\t${l}`);
+    let parts;
+    if (lines.length <= PREVIEW_HEAD + PREVIEW_TAIL) {
+      parts = numbered(lines, 0);
+    } else {
+      parts = [
+        ...numbered(lines.slice(0, PREVIEW_HEAD), 0),
+        `... (${lines.length - PREVIEW_HEAD - PREVIEW_TAIL} lines omitted) ...`,
+        ...numbered(lines.slice(-PREVIEW_TAIL), lines.length - PREVIEW_TAIL),
+      ];
+    }
+    let preview = parts.join('\n');
+    if (preview.length > PREVIEW_CHAR_CAP) preview = preview.slice(0, PREVIEW_CHAR_CAP) + '…';
+    return preview;
+  }
+
+  /**
+   * Open a document. source: {path} XOR {text}; briefing is required.
+   * @returns {{id, size, lines, preview, tooLargeForAsk}}
+   */
+  function open(source, briefing, extraMeta = {}) {
+    const hasPath = typeof source?.path === 'string';
+    const hasText = typeof source?.text === 'string';
+    if (hasPath === hasText) throw new Error('provide exactly one of {path} or {text}');
+    if (!briefing || typeof briefing !== 'string') throw new Error('briefing is required');
+
+    sweep();
+    // Overflow is NOT a refusal. Refusing here would cost more than evicting: the
+    // interception hook swallows the exception fail-open, so the whole large output
+    // would go into the context window — context hygiene would silently switch off
+    // at the 11th document and never come back (the store outlives a turn). Evict
+    // the least recently used one, and LOUDLY: the victim id goes both to the log and
+    // to the returned field so the caller can show it to the agent. Silent eviction
+    // would be the same problem.
+    // while, not if: other processes (the hook command) also write documents into the
+    // directory, and a single eviction could leave the store over the limit forever.
+    // The normal path is exactly one iteration.
+    let evicted = null;
+    const owner = extraMeta.owner ?? null;
+    let open_ = allOpen().filter((e) => (e.meta.owner ?? null) === owner);
+    while (open_.length >= MAX_OPEN) {
+      const victim = open_.reduce((a, b) => (older(a, b) ? a : b));
+      const idleMs = Math.max(0, now() - (victim.lastUsedAt || victim.meta.createdAt));
+      close(victim.id);                  // same path as a manual close: raw file off disk, entry out of the map
+      evicted = victim.id;
+      try {
+        log(`[reader-store] evicted ${victim.id} (LRU, ${MAX_OPEN}/${MAX_OPEN} open${owner ? ` for ${owner}` : ''}, idle ${Math.round(idleMs / 1000)}s, asks ${victim.asks})`);
+      } catch (_) { /* logging must not break open */ }
+      open_ = open_.filter((e) => e !== victim);
+    }
+
+    let text;
+    if (hasPath) {
+      const st = fs.statSync(source.path); // ENOENT/EACCES propagate as is
+      if (st.isDirectory()) throw new Error(`${source.path} is a directory`);
+      if (st.size > OPEN_MAX) throw new Error(`file is ${st.size} bytes (limit ${OPEN_MAX}). Grep it directly or open an excerpt as {text}`);
+      text = fs.readFileSync(source.path, 'utf8');
+    } else {
+      if (Buffer.byteLength(source.text, 'utf8') > OPEN_MAX) throw new Error(`text is too large (limit ${OPEN_MAX} bytes)`);
+      text = source.text;
+    }
+
+    const id = 'ctx_' + crypto.randomBytes(4).toString('hex');
+    const size = Buffer.byteLength(text, 'utf8');
+    const meta = {
+      id,
+      size,
+      lines: text.split('\n').length,
+      createdAt: now(),
+      briefing,
+      source: hasPath ? { path: source.path } : { text: 'inline' },
+      tooLargeForAsk: size > ASK_MAX,
+      ...extraMeta, // e.g. tool_name, tool_input, owner
+    };
+    fs.writeFileSync(txtPath(id), text); // raw bytes as is; line numbering happens at ask/peek
+    fs.writeFileSync(metaPath(id), JSON.stringify(meta, null, 2));
+
+    const entry = { id, rawPath: txtPath(id), meta, haikuSid: null, asks: 0, lock: Promise.resolve(), closed: false };
+    touch(entry);
+    entries.set(id, entry);
+    // evicted is an added field, not a replacement: existing callers take id/size/lines/
+    // preview/tooLargeForAsk and notice nothing (null when nothing had to be evicted).
+    return { id, size, lines: meta.lines, preview: makePreview(text), tooLargeForAsk: meta.tooLargeForAsk, evicted };
+  }
+
+  /**
+   * Find an entry; on a miss — lazy reload from disk (a restart loses only the haiku dialog).
+   * Any access counts as use: ask, peek and readRaw all go through get, so the LRU stamp
+   * is set here, in one place.
+   */
+  function get(id) {
+    if (!validId(id)) return null;
+    const hit = entries.get(id);
+    if (hit && !hit.closed) {
+      if (fs.existsSync(txtPath(id))) return touch(hit);
+      entries.delete(id); // closed by another process (or swept) — don't trust the in-memory entry
+      return null;
+    }
+    try {
+      const meta = JSON.parse(fs.readFileSync(metaPath(id), 'utf8'));
+      if (!fs.existsSync(txtPath(id))) return null;
+      const entry = {
+        id, rawPath: txtPath(id), meta,
+        haikuSid: null, asks: 0, lock: Promise.resolve(), closed: false,
+        rehydrated: true, // the first ask will report that the dialog was reset by a restart
+      };
+      touch(entry);
+      entries.set(id, entry);
+      return entry;
+    } catch (_) {
+      return null; // meta missing or corrupt — treat as nonexistent
+    }
+  }
+
+  /** Verbatim numbered slice from DISK. 1-based, inclusive; clamped to bounds. */
+  function peek(id, startLine, endLine) {
+    const entry = get(id);
+    if (!entry) throw new Error(`no reader '${id}'`);
+    const lines = fs.readFileSync(entry.rawPath, 'utf8').split('\n');
+    const start = Math.max(1, Math.min(startLine, lines.length));
+    const end = Math.max(1, Math.min(endLine, lines.length));
+    if (start > end) throw new Error(`start_line ${startLine} > end_line ${endLine}`);
+    if (end - start + 1 > PEEK_MAX_LINES) {
+      throw new Error(`span is ${end - start + 1} lines (max ${PEEK_MAX_LINES}). Narrow the range`);
+    }
+    return lines.slice(start - 1, end).map((l, i) => `${start + i}\t${l}`).join('\n');
+  }
+
+  /** Read the whole raw file (for the haiku reader on the first ask). */
+  function readRaw(id) {
+    const entry = get(id);
+    if (!entry) throw new Error(`no reader '${id}'`);
+    return fs.readFileSync(entry.rawPath, 'utf8');
+  }
+
+  function ownerOf(id) {
+    if (!validId(id)) return null;
+    const e = entries.get(id);
+    if (e) return e.meta.owner ?? null;
+    try { return JSON.parse(fs.readFileSync(metaPath(id), 'utf8')).owner ?? null; } catch (_) { return null; }
+  }
+
+  /**
+   * Close and delete the files. Idempotent. {owner} — another owner's document is not closed (throws).
+   * Documents of the session's subagents (owner `<owner>/agent:<id>`, intercept-hook.js) count as
+   * the session's own: a session and its subagents share one reader MCP server, with the session owner.
+   * The owner is read from disk — the document may have been opened by another process.
+   */
+  function close(id, { owner } = {}) {
+    // id goes into the unlink path: '../x' would delete an unrelated *.txt file outside the directory
+    if (!validId(id)) return false;
+    if (owner !== undefined) {
+      const o = ownerOf(id);
+      if (o && o !== owner && !(owner && o.startsWith(`${owner}/`))) {
+        throw new Error(`reader '${id}' belongs to another session — it is not yours to close`);
+      }
+    }
+    const entry = entries.get(id);
+    if (entry) { entry.closed = true; entries.delete(id); }
+    let existed = false;
+    for (const p of [txtPath(id), metaPath(id)]) {
+      try { fs.unlinkSync(p); existed = true; } catch (_) { /* already gone */ }
+    }
+    return existed || !!entry;
+  }
+
+  /** {owner} — only this owner's documents; no argument — all of them. */
+  function list({ owner } = {}) {
+    return allOpen()
+      .filter((e) => owner === undefined || (e.meta.owner ?? null) === owner)
+      .sort((a, b) => (a.meta.createdAt - b.meta.createdAt) || (a.useSeq - b.useSeq))
+      .map((e) => ({
+        id: e.id, size: e.meta.size, lines: e.meta.lines,
+        briefing: e.meta.briefing, asks: e.asks,
+        opened: new Date(e.meta.createdAt).toISOString(),
+        tooLargeForAsk: !!e.meta.tooLargeForAsk,
+      }));
+  }
+
+  /** Gate for ask — a pure function, tested directly. */
+  function canAsk(entry) {
+    if (entry.meta.tooLargeForAsk) {
+      return { ok: false, reason: `document is ${entry.meta.size} bytes (ask limit ${ASK_MAX}). Use reader_peek for verbatim ranges, Grep the source, or open a smaller excerpt with {text}` };
+    }
+    if (entry.asks >= MAX_ASKS) {
+      return { ok: false, reason: `ask limit reached (${MAX_ASKS}) for this reader. Close it and reopen with a fresh briefing` };
+    }
+    return { ok: true };
+  }
+
+  sweep(); // sweep on creation (server restart)
+  return { open, get, peek, readRaw, close, list, canAsk, sweep, limits: { OPEN_MAX, ASK_MAX, MAX_OPEN, MAX_ASKS, PEEK_MAX_LINES } };
+}
+
+module.exports = { createReaderStore };

package/lib/reader-tools.js

@@ -0,0 +1,145 @@
+/**
+ * reader-tools — transport-agnostic reader tools: reader_open/ask/peek/close/list
+ * as plain {name, description, schema, handler}.
+ *
+ * schema is a zod "raw shape" (an object of fields), understood the same way by both adapters:
+ * stdio MCP (@modelcontextprotocol/sdk, lib/stdio-mcp.js) and the in-process Agent SDK MCP
+ * (createSdkMcpServer, lib/reader-mcp.js). handler(args) → {content:[{type:'text',text}]}.
+ * Errors are not thrown: the agent gets "Error: …" as text, like any tool output.
+ */
+
+'use strict';
+
+const { z } = require('zod');
+const readerModel = require('./reader-model');
+
+/** Tool names in Claude Code when the server is named "reader" — for allowedTools. */
+const READER_TOOL_NAMES = [
+  'mcp__reader__reader_open',
+  'mcp__reader__reader_ask',
+  'mcp__reader__reader_peek',
+  'mcp__reader__reader_close',
+  'mcp__reader__reader_list',
+];
+
+const readerText = (text) => ({ content: [{ type: 'text', text }] });
+const readerErr = (e) => readerText(`Error: ${e.message}`);
+
+/**
+ * reader_open description. The extra "also NOT for this" clause is a parameter: it depends
+ * on the agent's environment (some have a separate transcript reader, some don't).
+ */
+const openDescription = (alsoNotFor) =>
+  'Open a document in a persistent haiku-powered reader WITHOUT loading it into your context. ' +
+  'Use for: large files (logs, long sources, datasets), long command outputs (pass as {text}), ' +
+  'anything you will question repeatedly. Do NOT use for small files you are about to Edit ' +
+  `(use Read — you need exact bytes)${alsoNotFor ? ` or ${alsoNotFor}` : ''}. ` +
+  'Returns id + stats + head/tail preview; then interrogate with reader_ask, verify exact values with reader_peek.';
+
+const evictedNote = (store, r) => {
+  // The wording is SHARED with the interception pointer (intercept-hook.js): the agent
+  // should not have to care which path opened the document.
+  const cap = store.limits && store.limits.MAX_OPEN;
+  return r.evicted
+    ? `\n(evicted ${r.evicted}${cap ? ` — ${cap}/${cap} open` : ' — reader limit reached'}; close with mcp__reader__reader_close)`
+    : '';
+};
+
+/**
+ * @param {object} opts
+ * @param {object} opts.store            ReaderStore (lib/reader-store.js)
+ * @param {object} [opts.haiku]          question transport {ask} (injected in tests)
+ * @param {string} [opts.openAlsoNotFor] tail of the "Do NOT use for …" clause in reader_open
+ * @param {string} [opts.owner]          document owner (session id); unset — all documents are visible
+ * @param {'prose'|'lines'} [opts.askFormat] default reader_ask format
+ * @returns {Array<{name, description, schema, handler}>}
+ */
+function createReaderTools({ store, haiku = readerModel, openAlsoNotFor = '', owner, askFormat = 'prose' } = {}) {
+  if (!store) throw new Error('createReaderTools requires {store}');
+  const own = owner !== undefined ? { owner } : {};
+  return [
+    {
+      name: 'reader_open',
+      description: openDescription(openAlsoNotFor),
+      schema: {
+        path: z.string().optional().describe('Absolute file path. Exactly one of path|text.'),
+        text: z.string().optional().describe('Inline text to open (e.g. a big command output you want kept out of your context).'),
+        briefing: z.string().describe('Why you are opening this and what matters — the reader prioritizes by it. Name what to watch for (errors? a function? specific numbers?).'),
+      },
+      handler: async (args) => {
+        try {
+          const r = store.open(args.path !== undefined ? { path: args.path } : { text: args.text }, args.briefing, own);
+          const warn = r.tooLargeForAsk ? '\nNOTE: too large for reader_ask — use reader_peek/Grep.' : '';
+          return readerText(`Opened ${r.id} (${r.lines} lines, ${r.size} bytes).${warn}${evictedNote(store, r)}\nPreview:\n${r.preview}`);
+        } catch (e) { return readerErr(e); }
+      },
+    },
+    {
+      name: 'reader_ask',
+      description: askFormat === 'lines'
+        ? 'Ask the haiku reader a question about an open document. The reader remembers the dialog: follow-up questions are cheap. '
+          + 'Default answer (format "lines"): a short direct answer + the document lines that answer it, VERBATIM from disk (exact bytes — fit for Edit), ~6–9 s. '
+          + 'Several questions to one document at once run in parallel. Errors/anomalies you did not ask about are NOT listed in lines — ask for them explicitly '
+          + '("what looks suspicious here?") or use format "prose" — a connected explanation with line citations and a NOTICED section (slower).'
+        : 'Ask the haiku reader a question about an open document. Answers cite line numbers and ALWAYS end with a NOTICED section (errors/anomalies/secrets you did not ask about — read it). The reader remembers the dialog: follow-up questions are cheap. Confirm critical exact values via reader_peek.',
+      schema: {
+        id: z.string().describe('Reader id from reader_open (ctx_...).'),
+        question: z.string().describe('One specific question per ask.'),
+        // The format parameter exists only where lines is the default: the prose description and schema stay unchanged.
+        ...(askFormat === 'lines' ? { format: z.enum(['lines', 'prose']).optional().describe('Answer format (default "lines"): "lines" — relevant document lines verbatim + short note; "prose" — explanation with citations.') } : {}),
+      },
+      handler: async (args) => {
+        try {
+          const entry = store.get(args.id);
+          if (!entry) return readerText(`Error: no reader '${args.id}'. reader_list shows open readers.`);
+          return readerText(await haiku.ask(store, entry, args.question, undefined, { format: args.format || askFormat }));
+        } catch (e) { return readerErr(e); }
+      },
+    },
+    {
+      name: 'reader_peek',
+      description: 'Verbatim numbered slice of an open document — no LLM, exact bytes from disk. Use to ground-check a reader_ask claim or pull an exact value/snippet. Max 400 lines per call.',
+      // start/end are aliases, not a typo: agents write "reader_peek(id, start, end)", and
+      // numeric strings ("9", not 9) are no reason to reject the call, hence coerce.
+      schema: {
+        id: z.string(),
+        start_line: z.coerce.number().int().min(1).optional().describe('First line, 1-based. Required (alias: start).'),
+        end_line: z.coerce.number().int().min(1).optional().describe('Last line, inclusive. Required (alias: end).'),
+        start: z.coerce.number().int().min(1).optional().describe('Alias of start_line.'),
+        end: z.coerce.number().int().min(1).optional().describe('Alias of end_line.'),
+      },
+      handler: async (args) => {
+        const startLine = args.start_line ?? args.start;
+        const endLine = args.end_line ?? args.end;
+        if (startLine === undefined || endLine === undefined) {
+          return readerText('Error: reader_peek needs start_line and end_line (1-based, inclusive), e.g. {id, start_line: 1, end_line: 50}.');
+        }
+        try { return readerText(store.peek(args.id, startLine, endLine)); } catch (e) { return readerErr(e); }
+      },
+    },
+    {
+      name: 'reader_close',
+      description: 'Close a reader and delete its spilled raw file. Call when done — max 10 readers may be open.',
+      schema: { id: z.string() },
+      handler: async (args) => {
+        try {
+          const existed = store.close(args.id, own);
+          return readerText(existed ? `Closed ${args.id}.` : `${args.id} was not open (already closed?).`);
+        } catch (e) { return readerErr(e); }
+      },
+    },
+    {
+      name: 'reader_list',
+      description: 'List open readers (id, size, briefing, ask count). Use when unsure what is open or before opening near the limit of 10.',
+      schema: {},
+      handler: async () => {
+        try {
+          const l = store.list(own);
+          return readerText(l.length ? JSON.stringify(l, null, 2) : 'No open readers.');
+        } catch (e) { return readerErr(e); }
+      },
+    },
+  ];
+}
+
+module.exports = { createReaderTools, READER_TOOL_NAMES, openDescription };

package/lib/stdio-mcp.js

@@ -0,0 +1,31 @@
+/**
+ * stdio-mcp — adapter of the core (lib/reader-tools.js) to stdio MCP (@modelcontextprotocol/sdk).
+ * Claude Code launches it as a separate process (bin/smcreader-mcp); the store is the same
+ * on-disk directory the hook command writes to (bin/smcreader-hook), so documents
+ * intercepted by the hook are visible here by id, in list, and count toward the limit.
+ */
+
+'use strict';
+
+const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const { createReaderTools } = require('./reader-tools');
+
+const VERSION = require('../package.json').version;
+
+/** Build an McpServer with the reader tools (without connecting a transport). */
+function buildMcpServer(toolOpts) {
+  const server = new McpServer({ name: 'reader', version: VERSION });
+  for (const t of createReaderTools(toolOpts)) {
+    server.registerTool(t.name, { description: t.description, inputSchema: t.schema }, (args) => t.handler(args || {}));
+  }
+  return server;
+}
+
+async function runStdio(toolOpts) {
+  const server = buildMcpServer(toolOpts);
+  await server.connect(new StdioServerTransport());
+  return server;
+}
+
+module.exports = { buildMcpServer, runStdio };

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "smcreader",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "SMC Reader (Save My Context Reader): pull-model reading of large tool outputs for Claude Code. A PostToolUse hook spills big outputs to disk and leaves a short pointer; an MCP server returns only the lines or answers the model asks for.",
+  "license": "MIT",
+  "author": "bulatko",
+  "homepage": "https://github.com/bulatko/SMCReader#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bulatko/SMCReader.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bulatko/SMCReader/issues"
+  },
+  "keywords": [
+    "claude-code",
+    "claude-code-plugin",
+    "mcp",
+    "model-context-protocol",
+    "context",
+    "context-window",
+    "hooks",
+    "agents",
+    "llm"
+  ],
+  "main": "lib/index.js",
+  "bin": {
+    "smcreader-hook": "bin/smcreader-hook",
+    "smcreader-mcp": "bin/smcreader-mcp",
+    "reader-hook": "bin/reader-hook",
+    "reader-mcp": "bin/reader-mcp"
+  },
+  "files": [
+    "lib/",
+    "bin/",
+    ".claude-plugin/",
+    "hooks/",
+    ".mcp.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "jest",
+    "e2e": "sh e2e/claude-code.sh",
+    "e2e:plugin": "sh e2e/plugin.sh"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": [
+      "<rootDir>/tests/**/*.test.js"
+    ]
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.293",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}