@ulrichc1/sparn 1.0.0 → 1.1.0

package/dist/cli/index.js

@@ -12,9 +12,13 @@ var __export = (target, all) => {
 // node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
 var init_esm_shims = __esm({
   "node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
   }
 });
 
@@ -349,7 +353,17 @@ var init_config = __esm({
         sounds: false,
         verbose: false
       },
-      autoConsolidate: null
+      autoConsolidate: null,
+      realtime: {
+        tokenBudget: 5e4,
+        autoOptimizeThreshold: 8e4,
+        watchPatterns: ["**/*.jsonl"],
+        pidFile: ".sparn/daemon.pid",
+        logFile: ".sparn/daemon.log",
+        debounceMs: 5e3,
+        incremental: true,
+        windowSize: 500
+      }
     };
   }
 });
@@ -372,7 +386,7 @@ function getVersion() {
   } catch {
     const __filename2 = fileURLToPath2(import.meta.url);
     const __dirname2 = dirname(__filename2);
-    const pkg = JSON.parse(readFileSync(join(__dirname2, "../../../package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync(join(__dirname2, "../../package.json"), "utf-8"));
     return pkg.version;
   }
 }
@@ -1456,8 +1470,494 @@ var init_config2 = __esm({
         validate: (v) => v === null || typeof v === "number" && v > 0,
         errorMessage: "autoConsolidate must be a positive number (hours) or null",
         parse: (v) => v === "null" ? null : Number.parseFloat(v)
+      },
+      "realtime.tokenBudget": {
+        path: ["realtime", "tokenBudget"],
+        validate: (v) => typeof v === "number" && v > 0,
+        errorMessage: "tokenBudget must be a positive number",
+        parse: (v) => Number.parseInt(v, 10)
+      },
+      "realtime.autoOptimizeThreshold": {
+        path: ["realtime", "autoOptimizeThreshold"],
+        validate: (v) => typeof v === "number" && v > 0,
+        errorMessage: "autoOptimizeThreshold must be a positive number",
+        parse: (v) => Number.parseInt(v, 10)
+      },
+      "realtime.watchPatterns": {
+        path: ["realtime", "watchPatterns"],
+        validate: (v) => Array.isArray(v) && v.every((p) => typeof p === "string"),
+        errorMessage: "watchPatterns must be an array of strings",
+        parse: (v) => v.split(",").map((p) => p.trim())
+      },
+      "realtime.pidFile": {
+        path: ["realtime", "pidFile"],
+        validate: (v) => typeof v === "string" && v.length > 0,
+        errorMessage: "pidFile must be a non-empty string",
+        parse: (v) => v
+      },
+      "realtime.logFile": {
+        path: ["realtime", "logFile"],
+        validate: (v) => typeof v === "string" && v.length > 0,
+        errorMessage: "logFile must be a non-empty string",
+        parse: (v) => v
+      },
+      "realtime.debounceMs": {
+        path: ["realtime", "debounceMs"],
+        validate: (v) => typeof v === "number" && v >= 0,
+        errorMessage: "debounceMs must be a non-negative number",
+        parse: (v) => Number.parseInt(v, 10)
+      },
+      "realtime.incremental": {
+        path: ["realtime", "incremental"],
+        validate: (v) => typeof v === "boolean",
+        errorMessage: "incremental must be true or false",
+        parse: (v) => v === "true"
+      },
+      "realtime.windowSize": {
+        path: ["realtime", "windowSize"],
+        validate: (v) => typeof v === "number" && v > 0,
+        errorMessage: "windowSize must be a positive number",
+        parse: (v) => Number.parseInt(v, 10)
+      }
+    };
+  }
+});
+
+// src/core/metrics.ts
+function createMetricsCollector() {
+  const optimizations = [];
+  let daemonMetrics = {
+    startTime: Date.now(),
+    sessionsWatched: 0,
+    totalOptimizations: 0,
+    totalTokensSaved: 0,
+    averageLatency: 0,
+    memoryUsage: 0
+  };
+  let cacheHits = 0;
+  let cacheMisses = 0;
+  function recordOptimization(metric) {
+    optimizations.push(metric);
+    daemonMetrics.totalOptimizations++;
+    daemonMetrics.totalTokensSaved += metric.tokensBefore - metric.tokensAfter;
+    if (metric.cacheHitRate > 0) {
+      const hits = Math.round(metric.entriesProcessed * metric.cacheHitRate);
+      cacheHits += hits;
+      cacheMisses += metric.entriesProcessed - hits;
+    }
+    daemonMetrics.averageLatency = (daemonMetrics.averageLatency * (daemonMetrics.totalOptimizations - 1) + metric.duration) / daemonMetrics.totalOptimizations;
+    if (optimizations.length > 1e3) {
+      optimizations.shift();
+    }
+  }
+  function updateDaemon(metric) {
+    daemonMetrics = {
+      ...daemonMetrics,
+      ...metric
+    };
+  }
+  function calculatePercentile(values, percentile) {
+    if (values.length === 0) return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.ceil(percentile / 100 * sorted.length) - 1;
+    return sorted[index] || 0;
+  }
+  function getSnapshot() {
+    const totalRuns = optimizations.length;
+    const totalDuration = optimizations.reduce((sum, m) => sum + m.duration, 0);
+    const totalTokensSaved = optimizations.reduce(
+      (sum, m) => sum + (m.tokensBefore - m.tokensAfter),
+      0
+    );
+    const totalTokensBefore = optimizations.reduce((sum, m) => sum + m.tokensBefore, 0);
+    const averageReduction = totalTokensBefore > 0 ? totalTokensSaved / totalTokensBefore : 0;
+    const durations = optimizations.map((m) => m.duration);
+    const totalCacheQueries = cacheHits + cacheMisses;
+    const hitRate = totalCacheQueries > 0 ? cacheHits / totalCacheQueries : 0;
+    return {
+      timestamp: Date.now(),
+      optimization: {
+        totalRuns,
+        totalDuration,
+        totalTokensSaved,
+        averageReduction,
+        p50Latency: calculatePercentile(durations, 50),
+        p95Latency: calculatePercentile(durations, 95),
+        p99Latency: calculatePercentile(durations, 99)
+      },
+      cache: {
+        hitRate,
+        totalHits: cacheHits,
+        totalMisses: cacheMisses,
+        size: optimizations.reduce((sum, m) => sum + m.entriesKept, 0)
+      },
+      daemon: {
+        uptime: Date.now() - daemonMetrics.startTime,
+        sessionsWatched: daemonMetrics.sessionsWatched,
+        memoryUsage: daemonMetrics.memoryUsage
+      }
+    };
+  }
+  function exportMetrics() {
+    return JSON.stringify(getSnapshot(), null, 2);
+  }
+  function reset() {
+    optimizations.length = 0;
+    cacheHits = 0;
+    cacheMisses = 0;
+    daemonMetrics = {
+      startTime: Date.now(),
+      sessionsWatched: 0,
+      totalOptimizations: 0,
+      totalTokensSaved: 0,
+      averageLatency: 0,
+      memoryUsage: 0
+    };
+  }
+  return {
+    recordOptimization,
+    updateDaemon,
+    getSnapshot,
+    export: exportMetrics,
+    reset
+  };
+}
+function getMetrics() {
+  if (!globalMetrics) {
+    globalMetrics = createMetricsCollector();
+  }
+  return globalMetrics;
+}
+var globalMetrics;
+var init_metrics = __esm({
+  "src/core/metrics.ts"() {
+    "use strict";
+    init_esm_shims();
+    globalMetrics = null;
+  }
+});
+
+// src/daemon/daemon-process.ts
+var daemon_process_exports = {};
+__export(daemon_process_exports, {
+  createDaemonCommand: () => createDaemonCommand
+});
+import { fork } from "child_process";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+function createDaemonCommand() {
+  function isDaemonRunning(pidFile) {
+    if (!existsSync2(pidFile)) {
+      return { running: false };
+    }
+    try {
+      const pidStr = readFileSync3(pidFile, "utf-8").trim();
+      const pid = Number.parseInt(pidStr, 10);
+      if (Number.isNaN(pid)) {
+        return { running: false };
+      }
+      try {
+        process.kill(pid, 0);
+        return { running: true, pid };
+      } catch {
+        unlinkSync(pidFile);
+        return { running: false };
+      }
+    } catch {
+      return { running: false };
+    }
+  }
+  function writePidFile(pidFile, pid) {
+    const dir = dirname2(pidFile);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync2(pidFile, String(pid), "utf-8");
+  }
+  function removePidFile(pidFile) {
+    if (existsSync2(pidFile)) {
+      unlinkSync(pidFile);
+    }
+  }
+  async function start(config) {
+    const { pidFile, logFile } = config.realtime;
+    const status2 = isDaemonRunning(pidFile);
+    if (status2.running) {
+      return {
+        success: false,
+        pid: status2.pid,
+        message: `Daemon already running (PID ${status2.pid})`,
+        error: "Already running"
+      };
+    }
+    try {
+      const daemonPath = join2(__dirname, "index.js");
+      const child = fork(daemonPath, [], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+          ...process.env,
+          SPARN_CONFIG: JSON.stringify(config),
+          SPARN_PID_FILE: pidFile,
+          SPARN_LOG_FILE: logFile
+        }
+      });
+      child.unref();
+      if (child.pid) {
+        writePidFile(pidFile, child.pid);
+        return {
+          success: true,
+          pid: child.pid,
+          message: `Daemon started (PID ${child.pid})`
+        };
+      }
+      return {
+        success: false,
+        message: "Failed to start daemon (no PID)",
+        error: "No PID"
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: "Failed to start daemon",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async function stop(config) {
+    const { pidFile } = config.realtime;
+    const status2 = isDaemonRunning(pidFile);
+    if (!status2.running || !status2.pid) {
+      return {
+        success: true,
+        message: "Daemon not running"
+      };
+    }
+    try {
+      process.kill(status2.pid, "SIGTERM");
+      const maxWait = 5e3;
+      const interval = 100;
+      let waited = 0;
+      while (waited < maxWait) {
+        try {
+          process.kill(status2.pid, 0);
+          await new Promise((resolve2) => setTimeout(resolve2, interval));
+          waited += interval;
+        } catch {
+          removePidFile(pidFile);
+          return {
+            success: true,
+            message: `Daemon stopped (PID ${status2.pid})`
+          };
+        }
+      }
+      try {
+        process.kill(status2.pid, "SIGKILL");
+        removePidFile(pidFile);
+        return {
+          success: true,
+          message: `Daemon force killed (PID ${status2.pid})`
+        };
+      } catch {
+        removePidFile(pidFile);
+        return {
+          success: true,
+          message: `Daemon stopped (PID ${status2.pid})`
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        message: "Failed to stop daemon",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async function status(config) {
+    const { pidFile } = config.realtime;
+    const daemonStatus = isDaemonRunning(pidFile);
+    if (!daemonStatus.running || !daemonStatus.pid) {
+      return {
+        running: false,
+        message: "Daemon not running"
+      };
+    }
+    const metrics = getMetrics().getSnapshot();
+    return {
+      running: true,
+      pid: daemonStatus.pid,
+      uptime: metrics.daemon.uptime,
+      sessionsWatched: metrics.daemon.sessionsWatched,
+      tokensSaved: metrics.optimization.totalTokensSaved,
+      message: `Daemon running (PID ${daemonStatus.pid})`
+    };
+  }
+  return {
+    start,
+    stop,
+    status
+  };
+}
+var init_daemon_process = __esm({
+  "src/daemon/daemon-process.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_metrics();
+  }
+});
+
+// src/cli/commands/hooks.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  hooksCommand: () => hooksCommand
+});
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, join as join3 } from "path";
+async function hooksCommand(options) {
+  const { subcommand, global } = options;
+  const settingsPath = global ? join3(homedir(), ".claude", "settings.json") : join3(process.cwd(), ".claude", "settings.json");
+  const hooksDir = join3(dirname3(dirname3(dirname3(__dirname))), "dist", "hooks");
+  const prePromptPath = join3(hooksDir, "pre-prompt.js");
+  const postToolResultPath = join3(hooksDir, "post-tool-result.js");
+  switch (subcommand) {
+    case "install":
+      return await installHooks(settingsPath, prePromptPath, postToolResultPath, global);
+    case "uninstall":
+      return await uninstallHooks(settingsPath, global);
+    case "status":
+      return await hooksStatus(settingsPath, global);
+    default:
+      return {
+        success: false,
+        message: `Unknown subcommand: ${subcommand}`,
+        error: "Invalid subcommand"
+      };
+  }
+}
+async function installHooks(settingsPath, prePromptPath, postToolResultPath, global) {
+  try {
+    if (!existsSync3(prePromptPath)) {
+      return {
+        success: false,
+        message: `Hook script not found: ${prePromptPath}`,
+        error: "Hook scripts not built. Run `npm run build` first."
+      };
+    }
+    if (!existsSync3(postToolResultPath)) {
+      return {
+        success: false,
+        message: `Hook script not found: ${postToolResultPath}`,
+        error: "Hook scripts not built. Run `npm run build` first."
+      };
+    }
+    let settings = {};
+    if (existsSync3(settingsPath)) {
+      const settingsJson = readFileSync4(settingsPath, "utf-8");
+      settings = JSON.parse(settingsJson);
+    } else {
+      const claudeDir = dirname3(settingsPath);
+      if (!existsSync3(claudeDir)) {
+        mkdirSync2(claudeDir, { recursive: true });
+      }
+    }
+    settings["hooks"] = {
+      ...typeof settings["hooks"] === "object" && settings["hooks"] !== null ? settings["hooks"] : {},
+      "pre-prompt": `node ${prePromptPath}`,
+      "post-tool-result": `node ${postToolResultPath}`
+    };
+    writeFileSync3(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    return {
+      success: true,
+      message: global ? "Hooks installed globally (all projects)" : "Hooks installed for current project",
+      installed: true,
+      hookPaths: {
+        prePrompt: prePromptPath,
+        postToolResult: postToolResultPath
       }
     };
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to install hooks",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function uninstallHooks(settingsPath, global) {
+  try {
+    if (!existsSync3(settingsPath)) {
+      return {
+        success: true,
+        message: "No hooks installed (settings.json not found)",
+        installed: false
+      };
+    }
+    const settingsJson = readFileSync4(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsJson);
+    if (settings["hooks"] && typeof settings["hooks"] === "object" && settings["hooks"] !== null) {
+      const hooks = settings["hooks"];
+      delete hooks["pre-prompt"];
+      delete hooks["post-tool-result"];
+      if (Object.keys(hooks).length === 0) {
+        delete settings["hooks"];
+      }
+    }
+    writeFileSync3(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    return {
+      success: true,
+      message: global ? "Hooks uninstalled globally" : "Hooks uninstalled from current project",
+      installed: false
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to uninstall hooks",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function hooksStatus(settingsPath, global) {
+  try {
+    if (!existsSync3(settingsPath)) {
+      return {
+        success: true,
+        message: global ? "No global hooks installed (settings.json not found)" : "No project hooks installed (settings.json not found)",
+        installed: false
+      };
+    }
+    const settingsJson = readFileSync4(settingsPath, "utf-8");
+    const settings = JSON.parse(settingsJson);
+    const hasHooks = settings["hooks"] && typeof settings["hooks"] === "object" && settings["hooks"] !== null && "pre-prompt" in settings["hooks"] && "post-tool-result" in settings["hooks"];
+    if (!hasHooks) {
+      return {
+        success: true,
+        message: global ? "No global hooks installed" : "No project hooks installed",
+        installed: false
+      };
+    }
+    const hooks = settings["hooks"];
+    return {
+      success: true,
+      message: global ? "Global hooks active" : "Project hooks active",
+      installed: true,
+      hookPaths: {
+        prePrompt: hooks["pre-prompt"] || "",
+        postToolResult: hooks["post-tool-result"] || ""
+      }
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to check hooks status",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+var init_hooks = __esm({
+  "src/cli/commands/hooks.ts"() {
+    "use strict";
+    init_esm_shims();
   }
 });
 
@@ -1465,18 +1965,18 @@ var init_config2 = __esm({
 init_esm_shims();
 init_banner();
 import { spawn as spawn2 } from "child_process";
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as join2, resolve } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname4, join as join4, resolve } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { Command } from "commander";
 function getVersion2() {
   try {
-    const pkg = JSON.parse(readFileSync3(join2(process.cwd(), "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync5(join4(process.cwd(), "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     const __filename2 = fileURLToPath3(import.meta.url);
-    const __dirname2 = dirname2(__filename2);
-    const pkg = JSON.parse(readFileSync3(join2(__dirname2, "../../package.json"), "utf-8"));
+    const __dirname2 = dirname4(__filename2);
+    const pkg = JSON.parse(readFileSync5(join4(__dirname2, "../../package.json"), "utf-8"));
     return pkg.version;
   }
 }
@@ -1860,6 +2360,139 @@ The config file is located at .sparn/config.yaml
     process.exit(1);
   }
 });
+program.command("daemon <subcommand>").description("Manage real-time optimization daemon").addHelpText(
+  "after",
+  `
+Subcommands:
+  start                                 # Start daemon
+  stop                                  # Stop daemon
+  status                                # Check daemon status
+
+Examples:
+  $ sparn daemon start                  # Start watching Claude Code sessions
+  $ sparn daemon stop                   # Stop daemon
+  $ sparn daemon status                 # Check if daemon is running
+
+The daemon watches ~/.claude/projects/**/*.jsonl and automatically
+optimizes contexts when they exceed the configured threshold.
+`
+).action(async (subcommand) => {
+  const { load: parseYAML2 } = await import("js-yaml");
+  const { createDaemonCommand: createDaemonCommand2 } = await Promise.resolve().then(() => (init_daemon_process(), daemon_process_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const configPath = resolve(process.cwd(), ".sparn/config.yaml");
+    const configYAML = readFileSync5(configPath, "utf-8");
+    const config = parseYAML2(configYAML);
+    const daemon = createDaemonCommand2();
+    switch (subcommand) {
+      case "start": {
+        const result = await daemon.start(config);
+        if (result.success) {
+          console.log(neuralCyan2(`
+\u2713 ${result.message}
+`));
+        } else {
+          console.error(errorRed2(`
+\u2717 ${result.message}
+`));
+          process.exit(1);
+        }
+        break;
+      }
+      case "stop": {
+        const result = await daemon.stop(config);
+        if (result.success) {
+          console.log(neuralCyan2(`
+\u2713 ${result.message}
+`));
+        } else {
+          console.error(errorRed2(`
+\u2717 ${result.message}
+`));
+          process.exit(1);
+        }
+        break;
+      }
+      case "status": {
+        const result = await daemon.status(config);
+        if (result.running) {
+          console.log(neuralCyan2(`
+\u2713 ${result.message}`));
+          if (result.sessionsWatched !== void 0) {
+            console.log(`  Sessions watched: ${result.sessionsWatched}`);
+          }
+          if (result.tokensSaved !== void 0) {
+            console.log(`  Tokens saved: ${result.tokensSaved.toLocaleString()}`);
+          }
+          console.log();
+        } else {
+          console.log(errorRed2(`
+\u2717 ${result.message}
+`));
+        }
+        break;
+      }
+      default:
+        console.error(errorRed2(`
+Unknown subcommand: ${subcommand}
+`));
+        console.error("Valid subcommands: start, stop, status\n");
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("hooks <subcommand>").description("Manage Claude Code hook integration").option("--global", "Install hooks globally (for all projects)").addHelpText(
+  "after",
+  `
+Subcommands:
+  install                               # Install hooks
+  uninstall                             # Uninstall hooks
+  status                                # Check hook status
+
+Examples:
+  $ sparn hooks install                 # Install hooks for current project
+  $ sparn hooks install --global        # Install hooks globally
+  $ sparn hooks uninstall               # Uninstall hooks
+  $ sparn hooks status                  # Check if hooks are active
+
+Hooks automatically optimize context before each Claude Code prompt
+and compress verbose tool results after execution.
+`
+).action(async (subcommand, options) => {
+  const { hooksCommand: hooksCommand2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
+  const { neuralCyan: neuralCyan2, errorRed: errorRed2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
+  try {
+    const result = await hooksCommand2({
+      subcommand,
+      global: options.global || false
+    });
+    if (result.success) {
+      console.log(neuralCyan2(`
+\u2713 ${result.message}`));
+      if (result.hookPaths) {
+        console.log("\nHook paths:");
+        console.log(`  pre-prompt: ${result.hookPaths.prePrompt}`);
+        console.log(`  post-tool-result: ${result.hookPaths.postToolResult}`);
+      }
+      console.log();
+    } else {
+      console.error(errorRed2(`
+\u2717 ${result.message}`));
+      if (result.error) {
+        console.error(`  ${result.error}`);
+      }
+      console.log();
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(errorRed2("Error:"), error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
 program.on("option:version", () => {
   console.log(getBanner(VERSION2));
   process.exit(0);