@prom.codes/saver 0.1.0

package/README.md

@@ -0,0 +1,32 @@
+# @prom.codes/saver
+
+**prom.codes Saver** — cut token cost without cutting quality. A tiny, pure-JS
+MCP installer (stdio): one `setup` tool writes an *efficient-output* rule block
+into your agent's runtime configs so it spends fewer tokens on its own prose —
+preamble, play-by-play narration, pasted tool output — while keeping code,
+caveats and destructive sequences **verbatim**.
+
+It is the third prom.codes tool, alongside **prom.codes Context** (code retrieval)
+and **prom.codes Memory** (agent memory).
+
+## Quick start
+
+```jsonc
+// Claude Desktop / Cursor MCP config
+{
+  "mcpServers": {
+    "saver": {
+      "command": "npx",
+      "args": ["-y", "@prom.codes/saver@latest"],
+      "env": { "PROMETHEUS_WORKSPACE_ROOT": "/absolute/path/to/your/repo" }
+    }
+  }
+}
+```
+
+Then ask your agent to run `setup` once per workspace. Levels: `lite` (filler
+only), `balanced` (default — lean, not terse), `aggressive` (telegraphic, opt-in,
+never for code/destructive work). No API key, no database, no native modules —
+`npx` works turnkey everywhere. Requires Node ≥ 20.10.
+
+Docs: https://prom.codes/docs

package/dist/bin.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+// dist/bin.js
+import { resolve } from "node:path";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// dist/server.js
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// dist/tools.js
+import { z } from "zod";
+
+// dist/setup.js
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var SAVER_LEVELS = ["lite", "balanced", "aggressive"];
+var DEFAULT_LEVEL = "balanced";
+var SAVER_RUNTIMES = [
+  "claude-code",
+  "cursor",
+  "augment",
+  "agents"
+];
+var BLOCK_START = "<!-- prom-saver:start -->";
+var BLOCK_END = "<!-- prom-saver:end -->";
+var NEVER_COMPRESS = `**Never compress (all levels):**
+- Code, diffs, commit messages, CLI commands, API names, file paths and exact error strings \u2014 verbatim.
+- Load-bearing caveats, trade-offs, warnings and negations ("not", "only", "unless", "before"). If it changes correctness or safety, keep it.
+- Destructive, irreversible or multi-step sequences \u2014 spell those out in full.`;
+var LEVEL_BODY = {
+  lite: `Trim only ceremony and filler from your own prose: skip greetings, apologies, restating the question, and "I will now\u2026" preamble. Otherwise write normally.`,
+  balanced: `Lead with the answer or the action. Skip preamble and the play-by-play narration of routine tool calls \u2014 act, then give a short result. Summarize long tool/command output instead of pasting it verbatim; quote only the lines that matter. Close a task with one concise summary, not running commentary. Keep substance over brevity \u2014 when in doubt, say the necessary thing. This is "lean", not "terse".`,
+  aggressive: `Telegraphic prose: drop articles and filler, minimal hedging, the shortest wording that stays unambiguous; summarize all tool output to the essential lines. Opt-in \u2014 more savings, more risk: the carve-outs below are hard limits, and you MUST fall back to "balanced" for any code-generation or destructive/irreversible work.`
+};
+function ruleBlockFor(level) {
+  return `## prom.codes Saver \u2014 efficient output (level: ${level})
+
+Cut token cost WITHOUT cutting quality. This shapes ONLY your own assistant prose \u2014 it never changes code, commands, tool inputs, or what you actually do.
+
+${LEVEL_BODY[level]}
+
+${NEVER_COMPRESS}
+
+The user asked for fewer wasted tokens, not a worse answer: preserve correctness, safety and completeness first, save tokens second.`;
+}
+function withMarkers(block) {
+  return `${BLOCK_START}
+${block}
+${BLOCK_END}`;
+}
+var CURSOR_FRONTMATTER = `---
+description: prom.codes Saver \u2014 efficient-output protocol
+alwaysApply: true
+---
+
+`;
+var TARGETS = {
+  "claude-code": { relPath: "CLAUDE.md", mode: "block", detect: "CLAUDE.md" },
+  cursor: {
+    relPath: join(".cursor", "rules", "prom-saver.mdc"),
+    mode: "file",
+    fileContent: (b) => CURSOR_FRONTMATTER + withMarkers(b) + "\n",
+    detect: ".cursor"
+  },
+  augment: {
+    relPath: join(".augment", "rules", "prom-saver.md"),
+    mode: "file",
+    fileContent: (b) => withMarkers(b) + "\n",
+    detect: ".augment"
+  },
+  agents: { relPath: "AGENTS.md", mode: "block", detect: "AGENTS.md" }
+};
+function detectRuntimes(workspaceRoot) {
+  const found = SAVER_RUNTIMES.filter((rt) => existsSync(join(workspaceRoot, TARGETS[rt].detect)));
+  return found.length > 0 ? found : ["agents"];
+}
+function upsertBlock(existing, block) {
+  const marked = withMarkers(block);
+  const start = existing.indexOf(BLOCK_START);
+  const end = existing.indexOf(BLOCK_END);
+  if (start !== -1 && end !== -1 && end > start) {
+    return existing.slice(0, start) + marked + existing.slice(end + BLOCK_END.length);
+  }
+  const sep = existing.length === 0 || existing.endsWith("\n\n") ? "" : existing.endsWith("\n") ? "\n" : "\n\n";
+  return existing + sep + marked + "\n";
+}
+async function installRuntime(workspaceRoot, runtime, level) {
+  const target = TARGETS[runtime];
+  const block = ruleBlockFor(level);
+  const absPath = join(workspaceRoot, target.relPath);
+  const exists = existsSync(absPath);
+  const before = exists ? await readFile(absPath, "utf-8") : "";
+  const after = target.mode === "file" ? target.fileContent(block) : upsertBlock(before, block);
+  if (exists && before === after) {
+    return { runtime, path: absPath, action: "unchanged" };
+  }
+  await mkdir(dirname(absPath), { recursive: true });
+  await writeFile(absPath, after, "utf-8");
+  return { runtime, path: absPath, action: exists ? "updated" : "created" };
+}
+
+// dist/tools.js
+function textResult(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+}
+var levelEnum = z.enum(SAVER_LEVELS);
+var runtimeEnum = z.enum(SAVER_RUNTIMES);
+var setupInput = {
+  level: levelEnum.optional(),
+  runtimes: z.array(runtimeEnum).min(1).optional()
+};
+function registerTools(server, deps) {
+  const { workspaceRoot } = deps;
+  server.registerTool("setup", {
+    title: "Install the prom.codes Saver efficient-output rules",
+    description: "Idempotently install the prom.codes Saver efficient-output rule block into this workspace's agent runtime configs (CLAUDE.md / .cursor/rules / .augment/rules / AGENTS.md). The rules cut token cost by trimming the agent's own prose (preamble, narration, pasted tool output) while keeping code, caveats and destructive sequences verbatim. `level`: `lite` (filler only) | `balanced` (default \u2014 lean, not terse) | `aggressive` (telegraphic, opt-in, never for code/destructive). Without `runtimes` it auto-detects which are present (fallback: agents). Re-running updates the block in place. Run this once per workspace.",
+    inputSchema: setupInput
+  }, async (args) => {
+    const level = args.level ?? DEFAULT_LEVEL;
+    const runtimes = args.runtimes ?? detectRuntimes(workspaceRoot);
+    const results = [];
+    for (const runtime of runtimes) {
+      results.push(await installRuntime(workspaceRoot, runtime, level));
+    }
+    return textResult({ workspaceRoot, level, results });
+  });
+}
+
+// dist/server.js
+var SERVER_IDENTITY = {
+  name: "prom-codes-saver",
+  version: "0.1.0",
+  title: "prom.codes Saver"
+};
+var SERVER_INSTRUCTIONS = "prom.codes Saver cuts token cost by trimming the agent's own prose \u2014 preamble, play-by-play narration and pasted tool output \u2014 while keeping code, caveats and destructive sequences verbatim. Run `setup` once per workspace to install the efficient-output protocol into the runtime rule files. Default level is `balanced` (lean, not terse): lead with the answer, summarize long output, one end-of-task summary. Never sacrifice correctness, safety or completeness to save tokens.";
+function createServer(deps, options = {}) {
+  const identity = { ...SERVER_IDENTITY, ...options.identity ?? {} };
+  const capabilities = options.capabilities ?? { tools: {} };
+  const server = new McpServer(identity, {
+    capabilities,
+    instructions: SERVER_INSTRUCTIONS
+  });
+  registerTools(server, deps);
+  return server;
+}
+
+// dist/bin.js
+async function main() {
+  const workspaceRoot = resolve(process.env.PROMETHEUS_WORKSPACE_ROOT ?? process.cwd());
+  process.stderr.write(`prom-codes-saver: workspace=${workspaceRoot}
+`);
+  const server = createServer({ workspaceRoot });
+  const transport = new StdioServerTransport();
+  const shutdown = async (signal) => {
+    process.stderr.write(`prom-codes-saver: received ${signal}, shutting down
+`);
+    try {
+      await server.close();
+    } finally {
+      process.exit(0);
+    }
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  await server.connect(transport);
+}
+main().catch((err) => {
+  const message = err instanceof Error ? err.message : String(err);
+  process.stderr.write(`prom-codes-saver: fatal: ${message}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@prom.codes/saver",
+  "version": "0.1.0",
+  "description": "prom.codes Saver — cut token cost without cutting quality, as an MCP installer.",
+  "type": "module",
+  "bin": {
+    "prom-codes-saver": "dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20.10"
+  },
+  "license": "UNLICENSED",
+  "homepage": "https://prom.codes",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "tokens",
+    "cost",
+    "efficiency",
+    "ai-agents"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  }
+}