prompt-genie 0.2.0

package/bin/install.cjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const https = require("https");
+const readline = require("readline");
+
+const HOOKS_DEST    = path.join(os.homedir(), ".prompt-genie", "hooks");
+const SETTINGS_FILE = path.join(os.homedir(), ".claude", "settings.json");
+const CONFIG_FILE   = path.join(os.homedir(), ".claude", "pg_config.json");
+const HOOKS_SRC     = path.join(__dirname, "..", "hooks");
+
+const GRAPHQL_URL = "https://ouybbvbacjd3tbbvf3jpqbiizy.appsync-api.us-east-2.amazonaws.com/graphql";
+const API_KEY     = "da2-xj6noinlgffx3ms3lgeopbhrjq";
+
+function loadJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return {}; }
+}
+
+function saveJson(file, data) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+
+function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => rl.question(question, (ans) => { rl.close(); resolve(ans.trim()); }));
+}
+
+function gqlPost(query) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ query });
+    const url = new URL(GRAPHQL_URL);
+    const req = https.request({
+      hostname: url.hostname,
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": API_KEY,
+        "Content-Length": Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => resolve(JSON.parse(data)));
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function copyHooks() {
+  fs.mkdirSync(HOOKS_DEST, { recursive: true });
+  for (const file of fs.readdirSync(HOOKS_SRC)) {
+    if (file.endsWith(".cjs")) {
+      fs.copyFileSync(path.join(HOOKS_SRC, file), path.join(HOOKS_DEST, file));
+    }
+  }
+}
+
+function wireHooks() {
+  const settings = loadJson(SETTINGS_FILE);
+  settings.hooks = settings.hooks || {};
+
+  settings.hooks.PreToolUse = [
+    {
+      matcher: "Read",
+      hooks: [{ type: "command", command: `node ${path.join(HOOKS_DEST, "pre_read.cjs")}` }],
+    },
+  ];
+  settings.hooks.PostToolUse = [
+    {
+      matcher: "Read",
+      hooks: [{ type: "command", command: `node ${path.join(HOOKS_DEST, "post_read.cjs")}` }],
+    },
+  ];
+  settings.hooks.Stop = [
+    {
+      hooks: [{ type: "command", command: `node ${path.join(HOOKS_DEST, "stop_flush.cjs")}` }],
+    },
+  ];
+
+  saveJson(SETTINGS_FILE, settings);
+}
+
+async function main() {
+  console.log("\n  Prompt Genie — Token Saver for Claude Code\n");
+
+  // Step 1: get email
+  const email = await ask("  Enter your Prompt Genie email: ");
+  if (!email || !email.includes("@")) {
+    console.error("  Invalid email. Run again with a valid address.");
+    process.exit(1);
+  }
+
+  // Step 2: send magic link
+  console.log("\n  Sending verification code to " + email + "...");
+  try {
+    const res = await gqlPost(
+      `mutation { cliAuth(action: "send_magic_link", email: ${JSON.stringify(email)}) }`
+    );
+    const result = JSON.parse(res.data?.cliAuth || "{}");
+    if (!result.success) {
+      console.error("  Failed to send code. Check your email and try again.");
+      process.exit(1);
+    }
+  } catch (err) {
+    console.error("  Network error:", err.message);
+    process.exit(1);
+  }
+
+  // Step 3: ask for code
+  console.log("  Check your email for a 6-digit code.\n");
+  const code = await ask("  Enter code: ");
+  if (!code || code.length !== 6) {
+    console.error("  Invalid code.");
+    process.exit(1);
+  }
+
+  // Step 4: verify code → get JWT
+  console.log("\n  Verifying...");
+  let token, plan;
+  try {
+    const res = await gqlPost(
+      `mutation { cliAuth(action: "verify_magic_link", email: ${JSON.stringify(email)}, code: ${JSON.stringify(code)}) }`
+    );
+    const result = JSON.parse(res.data?.cliAuth || "{}");
+    if (!result.success || !result.token) {
+      console.error("  " + (result.error || "Verification failed. Try again."));
+      process.exit(1);
+    }
+    token = result.token;
+    plan  = result.plan;
+  } catch (err) {
+    console.error("  Network error:", err.message);
+    process.exit(1);
+  }
+
+  // Step 5: install
+  console.log("  Installing hooks...");
+  copyHooks();
+
+  console.log("  Wiring Claude Code settings...");
+  wireHooks();
+
+  console.log("  Saving config...");
+  saveJson(CONFIG_FILE, { email, plan, token });
+
+  // Step 6: result message based on plan
+  const isPaid = ["PRO", "ANNUAL_PRO", "THREE_DAY_PASS", "TEAMS", "ENTERPRISE"].includes(plan);
+
+  if (isPaid) {
+    console.log(`
+  ✅ All done! Caching is active.
+
+  Restart VS Code to activate.
+  Your token savings will appear at prompt-genie.com after your first session.
+`);
+  } else {
+    console.log(`
+  ✅ Installed! You're on the Free plan.
+
+  Caching is disabled on Free — you'll see how many tokens you would have
+  saved at the end of each session.
+
+  Upgrade to Pro to activate → prompt-genie.com/pricing
+`);
+  }
+}
+
+main().catch((err) => {
+  console.error("Install failed:", err.message);
+  process.exit(1);
+});

package/hooks/post_read.cjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+
+const CACHE_FILE = path.join(process.env.HOME, ".claude/pg_read_cache.json");
+const STATS_FILE = path.join(process.env.HOME, ".claude/pg_stats.json");
+const SESSION_FILE = path.join(process.env.HOME, ".claude/pg_session.json");
+
+function loadJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return {}; }
+}
+
+function saveJson(file, data) {
+  fs.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+
+function recordMiss() {
+  const stats = loadJson(STATS_FILE);
+  stats.total_misses = (stats.total_misses || 0) + 1;
+  saveJson(STATS_FILE, stats);
+
+  const session = loadJson(SESSION_FILE);
+  session.misses = (session.misses || 0) + 1;
+  session.date = new Date().toISOString().slice(0, 10);
+  saveJson(SESSION_FILE, session);
+}
+
+let raw = "";
+process.stdin.on("data", (chunk) => (raw += chunk));
+process.stdin.on("end", () => {
+  let data;
+  try { data = JSON.parse(raw); } catch { process.exit(0); }
+
+  if (data.tool_name !== "Read") process.exit(0);
+
+  const filePath = data.tool_input?.file_path;
+  let content = data.tool_response ?? "";
+
+  if (typeof content === "object") {
+    const blocks = content.content;
+    content = Array.isArray(blocks)
+      ? blocks.map((b) => b.text ?? "").join("")
+      : JSON.stringify(content);
+  }
+
+  if (!filePath || !content || !fs.existsSync(filePath)) process.exit(0);
+
+  let mtime;
+  try { mtime = fs.statSync(filePath).mtimeMs; } catch { process.exit(0); }
+
+  const cache = loadJson(CACHE_FILE);
+  cache[filePath] = { mtime, content };
+  saveJson(CACHE_FILE, cache);
+  recordMiss();
+
+  process.exit(0);
+});

package/hooks/pre_read.cjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+
+const CACHE_FILE   = path.join(process.env.HOME, ".claude/pg_read_cache.json");
+const STATS_FILE   = path.join(process.env.HOME, ".claude/pg_stats.json");
+const SESSION_FILE = path.join(process.env.HOME, ".claude/pg_session.json");
+const CONFIG_FILE  = path.join(process.env.HOME, ".claude/pg_config.json");
+
+const PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArjBMJfK6K8JnPvZR3kuS
+d80nO2gvF2AULghE6WNtD1N0+k2GPShpGBiV/6WugrP840i8MRL+fyBid7DQw6Tj
+eqZ7lj8wHTKglNZCRgOvmV+Q9LOpUfDCV+znUlEJLlbZy73X2CNPN6D2kfKPL7yT
+Yo9HJG2j2n0BQhrQELbSct1q4hNMwcie2X5S9mR+lwcxRFEsvLuVe33hH0Rk6CSz
+BP0MCcqwkHCs8a5bdm2U5KveIv1pMUwwl8HKki3rjYbv7scdXPgERs27tRbpLdYj
+2+MhWaGHrt21pfASIKPwFiZaMhOV49hT3CC3rRY4zgtExFfYIx8qHt4LDM3rSheM
+dwIDAQAB
+-----END PUBLIC KEY-----`;
+
+function loadJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return {}; }
+}
+
+function saveJson(file, data) {
+  fs.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+
+function estimateTokens(text) {
+  return Math.max(1, Math.floor(text.length / 4));
+}
+
+// Returns decoded payload or null if invalid/expired
+function verifyJWT(token) {
+  try {
+    const [header, payload, signature] = token.split(".");
+    if (!header || !payload || !signature) return null;
+
+    const verify = crypto.createVerify("RSA-SHA256");
+    verify.update(`${header}.${payload}`);
+    const valid = verify.verify(PUBLIC_KEY, signature, "base64url");
+    if (!valid) return null;
+
+    const decoded = JSON.parse(Buffer.from(payload, "base64url").toString());
+    if (decoded.exp < Math.floor(Date.now() / 1000)) return null; // expired
+    return decoded;
+  } catch {
+    return null;
+  }
+}
+
+function isPaidPlan(plan) {
+  return ["PRO", "ANNUAL_PRO", "THREE_DAY_PASS", "TEAMS", "ENTERPRISE"].includes(plan);
+}
+
+function recordHit(filePath, tokensSaved) {
+  const stats = loadJson(STATS_FILE);
+  stats.total_hits = (stats.total_hits || 0) + 1;
+  stats.total_tokens_saved = (stats.total_tokens_saved || 0) + tokensSaved;
+  stats.files = stats.files || {};
+  stats.files[filePath] = stats.files[filePath] || { hits: 0, tokens_saved: 0 };
+  stats.files[filePath].hits += 1;
+  stats.files[filePath].tokens_saved += tokensSaved;
+  saveJson(STATS_FILE, stats);
+
+  const session = loadJson(SESSION_FILE);
+  session.hits = (session.hits || 0) + 1;
+  session.tokensSaved = (session.tokensSaved || 0) + tokensSaved;
+  session.date = new Date().toISOString().slice(0, 10);
+  saveJson(SESSION_FILE, session);
+}
+
+let raw = "";
+process.stdin.on("data", (chunk) => (raw += chunk));
+process.stdin.on("end", () => {
+  let data;
+  try { data = JSON.parse(raw); } catch { process.exit(0); }
+
+  if (data.tool_name !== "Read") process.exit(0);
+
+  // Check JWT — gate cache on paid plan
+  const config = loadJson(CONFIG_FILE);
+  const token = config.token;
+  if (!token) process.exit(0);
+
+  const jwt = verifyJWT(token);
+  if (!jwt || !isPaidPlan(jwt.plan)) process.exit(0);
+
+  const filePath = data.tool_input?.file_path;
+  if (!filePath || !fs.existsSync(filePath)) process.exit(0);
+
+  let mtime;
+  try { mtime = fs.statSync(filePath).mtimeMs; } catch { process.exit(0); }
+
+  const cache = loadJson(CACHE_FILE);
+  const entry = cache[filePath];
+
+  if (entry && entry.mtime === mtime) {
+    const tokensSaved = estimateTokens(entry.content);
+    recordHit(filePath, tokensSaved);
+    process.stdout.write(entry.content);
+    process.exit(2);
+  }
+
+  process.exit(0);
+});

package/hooks/setup.cjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+
+const CONFIG_FILE = path.join(process.env.HOME, ".claude/pg_config.json");
+
+const email = process.argv[2];
+if (!email || !email.includes("@")) {
+  console.log("Usage: node hooks/setup.cjs your@email.com");
+  process.exit(1);
+}
+
+fs.writeFileSync(CONFIG_FILE, JSON.stringify({ email }, null, 2));
+console.log(`Prompt Genie configured for ${email}`);
+console.log("Token savings will now sync to your dashboard after each session.");

package/hooks/stats.cjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+
+const STATS_FILE = path.join(process.env.HOME, ".claude/pg_stats.json");
+
+if (!fs.existsSync(STATS_FILE)) {
+  console.log("No data yet — stats are recorded after your first Claude Code session.");
+  process.exit(0);
+}
+
+const stats = JSON.parse(fs.readFileSync(STATS_FILE, "utf8"));
+const hits = stats.total_hits || 0;
+const misses = stats.total_misses || 0;
+const total = hits + misses;
+const tokensSaved = stats.total_tokens_saved || 0;
+const hitRate = total ? ((hits / total) * 100).toFixed(1) : "0.0";
+const costSaved = ((tokensSaved / 1_000_000) * 3).toFixed(4);
+
+console.log("============================================");
+console.log("  Prompt Genie — Read Cache Stats");
+console.log("============================================");
+console.log(`  Cache hits   : ${hits.toLocaleString()}`);
+console.log(`  Cache misses : ${misses.toLocaleString()}`);
+console.log(`  Hit rate     : ${hitRate}%`);
+console.log(`  Tokens saved : ~${tokensSaved.toLocaleString()}`);
+console.log(`  Cost saved   : ~$${costSaved}  (at $3/M input tokens)`);
+console.log("============================================");
+
+const files = stats.files || {};
+const sorted = Object.entries(files).sort((a, b) => b[1].tokens_saved - a[1].tokens_saved);
+if (sorted.length) {
+  console.log("\n  Top files by tokens saved:");
+  sorted.slice(0, 10).forEach(([p, d]) => {
+    console.log(`    ${String(d.tokens_saved).padStart(6)} tokens  (${d.hits} hits)  ${path.basename(p)}`);
+  });
+}

package/hooks/stop_flush.cjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const crypto = require("crypto");
+
+const SESSION_FILE = path.join(process.env.HOME, ".claude/pg_session.json");
+const CONFIG_FILE  = path.join(process.env.HOME, ".claude/pg_config.json");
+
+const GRAPHQL_URL = "https://ouybbvbacjd3tbbvf3jpqbiizy.appsync-api.us-east-2.amazonaws.com/graphql";
+const API_KEY     = "da2-xj6noinlgffx3ms3lgeopbhrjq";
+
+const PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArjBMJfK6K8JnPvZR3kuS
+d80nO2gvF2AULghE6WNtD1N0+k2GPShpGBiV/6WugrP840i8MRL+fyBid7DQw6Tj
+eqZ7lj8wHTKglNZCRgOvmV+Q9LOpUfDCV+znUlEJLlbZy73X2CNPN6D2kfKPL7yT
+Yo9HJG2j2n0BQhrQELbSct1q4hNMwcie2X5S9mR+lwcxRFEsvLuVe33hH0Rk6CSz
+BP0MCcqwkHCs8a5bdm2U5KveIv1pMUwwl8HKki3rjYbv7scdXPgERs27tRbpLdYj
+2+MhWaGHrt21pfASIKPwFiZaMhOV49hT3CC3rRY4zgtExFfYIx8qHt4LDM3rSheM
+dwIDAQAB
+-----END PUBLIC KEY-----`;
+
+function loadJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch { return {}; }
+}
+
+function isPaidPlan(plan) {
+  return ["PRO", "ANNUAL_PRO", "THREE_DAY_PASS", "TEAMS", "ENTERPRISE"].includes(plan);
+}
+
+// Returns decoded payload or null if invalid/expired
+function verifyJWT(token) {
+  try {
+    const [header, payload, signature] = token.split(".");
+    if (!header || !payload || !signature) return null;
+
+    const verify = crypto.createVerify("RSA-SHA256");
+    verify.update(`${header}.${payload}`);
+    const valid = verify.verify(PUBLIC_KEY, signature, "base64url");
+    if (!valid) return null;
+
+    return JSON.parse(Buffer.from(payload, "base64url").toString());
+  } catch {
+    return null;
+  }
+}
+
+function decodeJWT(token) {
+  try {
+    const [, payload] = token.split(".");
+    return JSON.parse(Buffer.from(payload, "base64url").toString());
+  } catch { return null; }
+}
+
+function gqlPost(query, variables) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ query, variables });
+    const url = new URL(GRAPHQL_URL);
+    const req = https.request({
+      hostname: url.hostname,
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": API_KEY,
+        "Content-Length": Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => resolve(JSON.parse(data)));
+    });
+    req.on("error", reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+async function refreshToken(oldToken) {
+  try {
+    const res = await gqlPost(
+      `mutation { cliAuth(action: "refresh_token", token: ${JSON.stringify(oldToken)}) }`,
+      {}
+    );
+    const result = JSON.parse(res.data?.cliAuth || "{}");
+    if (result.token) {
+      const config = loadJson(CONFIG_FILE);
+      config.token = result.token;
+      config.plan = result.plan;
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+      return result;
+    }
+  } catch { /* silent */ }
+  return null;
+}
+
+async function main() {
+  const session = loadJson(SESSION_FILE);
+  const config = loadJson(CONFIG_FILE);
+
+  const hits = session.hits || 0;
+  const misses = session.misses || 0;
+  const tokensSaved = session.tokensSaved || 0;
+
+  if (hits === 0 && misses === 0) process.exit(0);
+
+  const token = config.token;
+  if (!token) process.exit(0);
+
+  // Verify or refresh JWT
+  let jwt = verifyJWT(token);
+  let plan = jwt?.plan;
+
+  if (!jwt) {
+    // Token invalid or expired — try refresh
+    const refreshed = await refreshToken(token);
+    if (refreshed) {
+      plan = refreshed.plan;
+      jwt = decodeJWT(refreshed.token);
+    } else {
+      process.exit(0);
+    }
+  }
+
+  // FREE plan — show FOMO, don't write stats
+  if (!isPaidPlan(plan)) {
+    const savings = tokensSaved.toLocaleString();
+    process.stderr.write(
+      `\n💡 Prompt Genie: You would have saved ~${savings} tokens this session.\n` +
+      `   Upgrade to Pro to activate caching → prompt-genie.com\n\n`
+    );
+    fs.writeFileSync(SESSION_FILE, JSON.stringify({}));
+    process.exit(0);
+  }
+
+  // PRO/TEAMS — write stats
+  try {
+    const decoded = jwt || decodeJWT(token);
+    await gqlPost(
+      `mutation CreateSmartContextSessionStats($input: CreateSmartContextSessionStatsInput!) {
+        createSmartContextSessionStats(input: $input) { id }
+      }`,
+      {
+        input: {
+          email: decoded.email,
+          sessionDate: session.date || new Date().toISOString().slice(0, 10),
+          hits,
+          misses,
+          tokensSaved,
+          source: "CLAUDE_CODE",
+          createdAt: new Date().toISOString(),
+        },
+      }
+    );
+    fs.writeFileSync(SESSION_FILE, JSON.stringify({}));
+  } catch { /* silent */ }
+
+  process.exit(0);
+}
+
+main();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "prompt-genie",
+  "version": "0.2.0",
+  "description": "Save tokens in Claude Code by caching file reads",
+  "bin": {
+    "prompt-genie": "./bin/install.cjs"
+  },
+  "files": [
+    "bin",
+    "hooks"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "tokens",
+    "ai",
+    "prompt"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=16"
+  }
+}