haansi 0.1.0 → 0.1.2

package/dist/haansi.js

@@ -65,8 +65,10 @@ async function validateToken(token, apiUrl) {
 async function init() {
   const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL;
   console.log("Haansi CLI \u2014 Setup\n");
-  console.log(`You can generate an API token at https://app.haansi.co/settings/tokens
-`);
+  console.log(
+    `You can generate an API token at https://app.haansi.co/settings/tokens
+`
+  );
   const token = await prompt("Paste your Haansi API token: ");
   if (!token) {
     console.error("Error: No token provided.");
@@ -97,7 +99,7 @@ var init_init = __esm({
     import_node_fs = require("node:fs");
     import_node_path = require("node:path");
     import_node_os = require("node:os");
-    DEFAULT_API_URL = "https://api.haansi.com";
+    DEFAULT_API_URL = "https://api.haansi.co";
     HAANSI_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".haansi");
     CREDENTIALS_FILE = (0, import_node_path.join)(HAANSI_DIR, "credentials.json");
   }
@@ -938,6 +940,43 @@ var init_ingester = __esm({
       /**
        * Mark a session as processed and persist state.
        */
+      /**
+       * Return the number of lines already uploaded for this session (0 if unknown).
+       */
+      getUploadedLineCount(sessionId) {
+        const state = this.loadState();
+        return state.processed[sessionId]?.uploadedLineCount ?? 0;
+      }
+      /**
+       * Return whether this session was previously finalized.
+       */
+      isFinalized(sessionId) {
+        const state = this.loadState();
+        return state.processed[sessionId]?.finalized ?? false;
+      }
+      /**
+       * Return all session IDs that are tracked but not yet finalized.
+       * These are sessions that were previously uploaded as open and may
+       * need finalization if they no longer appear in the scan results.
+       */
+      getOpenSessionIds() {
+        const state = this.loadState();
+        return Object.values(state.processed).filter((r) => r.finalized === false).map((r) => r.sessionId);
+      }
+      /**
+       * Mark a session as finalized without re-reading its file.
+       * Used when a previously-open session is no longer receiving new lines.
+       */
+      markFinalized(sessionId) {
+        const state = this.loadState();
+        const record2 = state.processed[sessionId];
+        if (record2) {
+          record2.finalized = true;
+          record2.processedAt = (/* @__PURE__ */ new Date()).toISOString();
+          state.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+          this.saveState(state);
+        }
+      }
       markProcessed(session, status, extras) {
         const state = this.loadState();
         state.processed[session.sessionId] = {
@@ -1002,17 +1041,22 @@ function resolveToken() {
   }
   return null;
 }
-async function uploadSession(sessionId, jsonlContent, apiUrl, token) {
-  const body = (0, import_zlib.gzipSync)(Buffer.from(jsonlContent, "utf-8"));
+async function uploadSession(sessionId, jsonlContent, apiUrl, token, isOpen) {
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/x-ndjson",
+    "x-session-id": sessionId,
+    "x-session-open": isOpen ? "true" : "false"
+  };
+  let body;
+  if (jsonlContent.length > 0) {
+    body = (0, import_zlib.gzipSync)(Buffer.from(jsonlContent, "utf-8"));
+    headers["Content-Encoding"] = "gzip";
+  }
   const response = await fetch(`${apiUrl}/api/v1/sessions/raw`, {
     method: "POST",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      "Content-Type": "application/x-ndjson",
-      "Content-Encoding": "gzip",
-      "x-session-id": sessionId
-    },
-    body
+    headers,
+    body: body ? new Uint8Array(body) : void 0
   });
   if (!response.ok) {
     const text = await response.text().catch(() => "");
@@ -1033,39 +1077,97 @@ async function collect(options) {
     projectPath: options.projectPath
   });
   const scanResult = options.projectPath ? await ingester.scan({ forceAll: options.forceAll }) : await ingester.scanAll({ forceAll: options.forceAll });
-  const toUpload = [...scanResult.newSessions, ...scanResult.updatedSessions];
-  const sessions = options.limit ? toUpload.slice(0, options.limit) : toUpload;
-  if (sessions.length === 0) {
-    logger3.info("No new sessions to upload");
-    return { uploaded: 0, skipped: scanResult.unchangedCount, errors: 0 };
-  }
-  logger3.info(`Uploading ${sessions.length} session(s)`, {
-    apiUrl,
-    dryRun: options.dryRun ?? false
-  });
+  const activeSessions = [
+    ...scanResult.newSessions,
+    ...scanResult.updatedSessions
+  ];
+  const activeSessionIds = new Set(activeSessions.map((s) => s.sessionId));
+  const sessions = options.limit ? activeSessions.slice(0, options.limit) : activeSessions;
   let uploaded = 0;
   let errors = 0;
-  for (const session of sessions) {
-    const shortId = session.sessionId.slice(0, 8);
-    try {
-      const rawContent = (0, import_fs4.readFileSync)(session.filePath, "utf-8");
-      const scrubbed = edgeScrub(rawContent);
-      if (options.dryRun) {
+  if (sessions.length > 0) {
+    logger3.info(`Uploading ${sessions.length} active session(s)`, {
+      apiUrl,
+      dryRun: options.dryRun ?? false
+    });
+    for (const session of sessions) {
+      const shortId = session.sessionId.slice(0, 8);
+      try {
+        const rawContent = (0, import_fs4.readFileSync)(session.filePath, "utf-8");
+        const allLines = rawContent.split("\n").filter((l) => l.trim().length > 0);
+        const totalLines = allLines.length;
+        let uploadedLineCount = ingester.getUploadedLineCount(
+          session.sessionId
+        );
+        const wasPreviouslyFinalized = ingester.isFinalized(session.sessionId);
+        if (wasPreviouslyFinalized && totalLines > uploadedLineCount) {
+          uploadedLineCount = 0;
+        }
+        if (totalLines < uploadedLineCount) {
+          uploadedLineCount = 0;
+        }
+        const deltaLines = allLines.slice(uploadedLineCount);
+        if (deltaLines.length === 0) {
+          continue;
+        }
+        const deltaContent = edgeScrub(deltaLines.join("\n") + "\n");
+        if (options.dryRun) {
+          logger3.info(
+            `[dry-run] Would upload delta for session ${shortId} (${deltaLines.length} new lines, open)`
+          );
+          uploaded++;
+          continue;
+        }
+        await uploadSession(
+          session.sessionId,
+          deltaContent,
+          apiUrl,
+          token,
+          true
+        );
+        ingester.markProcessed(session, "pending", {
+          uploadedLineCount: totalLines,
+          finalized: false
+        });
+        uploaded++;
         logger3.info(
-          `[dry-run] Would upload session ${shortId} (${rawContent.length} bytes)`
+          `delta uploaded session ${shortId} (${deltaLines.length} new lines, open)`
         );
+      } catch (err) {
+        errors++;
+        logger3.error(`Failed to upload session ${shortId}`, {
+          err: err.message
+        });
+      }
+    }
+  }
+  const openSessionIds = ingester.getOpenSessionIds();
+  const toFinalize = openSessionIds.filter((id) => !activeSessionIds.has(id));
+  if (toFinalize.length > 0) {
+    logger3.info(`Finalizing ${toFinalize.length} idle session(s)`);
+    for (const sessionId of toFinalize) {
+      const shortId = sessionId.slice(0, 8);
+      try {
+        if (options.dryRun) {
+          logger3.info(`[dry-run] Would finalize session ${shortId}`);
+          uploaded++;
+          continue;
+        }
+        await uploadSession(sessionId, "", apiUrl, token, false);
+        ingester.markFinalized(sessionId);
         uploaded++;
-        continue;
+        logger3.info(`finalized session ${shortId}`);
+      } catch (err) {
+        errors++;
+        logger3.error(`Failed to finalize session ${shortId}`, {
+          err: err.message
+        });
       }
-      await uploadSession(session.sessionId, scrubbed, apiUrl, token);
-      ingester.markProcessed(session, "pending", {});
-      uploaded++;
-      logger3.info(`Uploaded session ${shortId}`);
-    } catch (err) {
-      errors++;
-      logger3.error(`Failed to upload session ${shortId}`, { err: err.message });
     }
   }
+  if (sessions.length === 0 && toFinalize.length === 0) {
+    logger3.info("No new sessions to upload");
+  }
   return { uploaded, skipped: scanResult.unchangedCount, errors };
 }
 async function main2() {
@@ -1104,7 +1206,7 @@ var init_collector = __esm({
     init_logger();
     (0, import_dotenv2.config)({ path: (0, import_path3.resolve)(__dirname, "../../../.env") });
     logger3 = createLogger("claude-collector");
-    DEFAULT_API_URL2 = "https://api.haansi.com";
+    DEFAULT_API_URL2 = "https://api.haansi.co";
     CREDENTIALS_FILE2 = (0, import_path3.join)((0, import_os3.homedir)(), ".haansi", "credentials.json");
     EDGE_SCRUB_PATTERNS = [
       {
@@ -30355,8 +30457,8 @@ var require_dist = __commonJS({
         return ajv;
       }
       const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
-      const list = opts.formats || formats_1.formatNames;
-      addFormats(ajv, list, formats, exportName);
+      const list2 = opts.formats || formats_1.formatNames;
+      addFormats(ajv, list2, formats, exportName);
       if (opts.keywords)
         (0, limit_1.default)(ajv);
       return ajv;
@@ -30368,11 +30470,11 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs, exportName) {
+    function addFormats(ajv, list2, fs, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
-      for (const f of list)
+      for (const f of list2)
         ajv.addFormat(f, fs[f]);
     }
     module2.exports = exports2 = formatsPlugin;
@@ -31991,6 +32093,25 @@ function resolveToken2() {
   }
   return null;
 }
+function triggerCollectInBackground() {
+  if (isCollecting) return;
+  isCollecting = true;
+  collect({}).then(({ uploaded, skipped, errors }) => {
+    console.error(
+      `[mcp-server] Collection done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
+    );
+    lastCollectTime = Date.now();
+  }).catch((err) => {
+    console.error("[mcp-server] Collection error:", err.message);
+  }).finally(() => {
+    isCollecting = false;
+  });
+}
+function maybeCollect() {
+  if (Date.now() - lastCollectTime >= COLLECT_COOLDOWN_MS) {
+    triggerCollectInBackground();
+  }
+}
 async function apiGet(path) {
   const response = await fetch(`${API_URL}/api/v1${path}`, {
     headers: { Authorization: `Bearer ${TOKEN}` }
@@ -32005,6 +32126,7 @@ async function main4() {
   try {
     await apiGet("/sessions/recent?limit=1");
     console.error("[mcp-server] API connection ok");
+    triggerCollectInBackground();
   } catch (err) {
     console.error(
       "[mcp-server] WARNING: API connection check failed:",
@@ -32015,7 +32137,7 @@ async function main4() {
   await mcpServer.connect(transport);
   console.error("[mcp-server] haansi-solutions MCP server running on stdio");
 }
-var import_dotenv4, import_path5, import_fs5, import_os4, DEFAULT_API_URL3, CREDENTIALS_FILE3, API_URL, TOKEN, mcpServer, server;
+var import_dotenv4, import_path5, import_fs5, import_os4, DEFAULT_API_URL3, CREDENTIALS_FILE3, API_URL, TOKEN, isCollecting, lastCollectTime, COLLECT_COOLDOWN_MS, mcpServer, server;
 var init_mcp_server2 = __esm({
   "../service-capture/claude-sessions/mcp-server.ts"() {
     "use strict";
@@ -32023,11 +32145,12 @@ var init_mcp_server2 = __esm({
     import_path5 = require("path");
     import_fs5 = require("fs");
     import_os4 = require("os");
+    init_collector();
     init_mcp();
     init_stdio2();
     init_types2();
     (0, import_dotenv4.config)({ path: (0, import_path5.resolve)(__dirname, "../../../.env") });
-    DEFAULT_API_URL3 = "https://api.haansi.com";
+    DEFAULT_API_URL3 = "https://api.haansi.co";
     CREDENTIALS_FILE3 = (0, import_path5.join)((0, import_os4.homedir)(), ".haansi", "credentials.json");
     API_URL = process.env.HAANSI_API_URL ?? DEFAULT_API_URL3;
     TOKEN = resolveToken2();
@@ -32037,6 +32160,9 @@ var init_mcp_server2 = __esm({
       );
       process.exit(1);
     }
+    isCollecting = false;
+    lastCollectTime = 0;
+    COLLECT_COOLDOWN_MS = 5 * 60 * 1e3;
     mcpServer = new McpServer(
       { name: "haansi-solutions", version: "0.2.0" },
       { capabilities: { tools: {} } }
@@ -32079,6 +32205,7 @@ var init_mcp_server2 = __esm({
       ]
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      maybeCollect();
       const { name, arguments: args } = request.params;
       console.error(`[mcp-server] Tool: ${name}`);
       try {
@@ -32150,7 +32277,9 @@ async function setupMcp() {
     try {
       config6 = JSON.parse((0, import_node_fs2.readFileSync)(CLAUDE_JSON, "utf-8"));
     } catch {
-      console.error(`Warning: Could not parse ${CLAUDE_JSON} \u2014 will overwrite with new config.`);
+      console.error(
+        `Warning: Could not parse ${CLAUDE_JSON} \u2014 will overwrite with new config.`
+      );
     }
   }
   if (!config6.mcpServers) {
@@ -32162,7 +32291,9 @@ async function setupMcp() {
   };
   (0, import_node_fs2.writeFileSync)(CLAUDE_JSON, JSON.stringify(config6, null, 2) + "\n", "utf-8");
   console.log(`MCP server configured in ${CLAUDE_JSON}`);
-  console.log("Restart Claude Code to activate the haansi-solutions MCP server.");
+  console.log(
+    "Restart Claude Code to activate the haansi-solutions MCP server."
+  );
 }
 var import_node_fs2, import_node_path2, import_node_os2, CLAUDE_JSON;
 var init_setup_mcp = __esm({
@@ -32175,6 +32306,162 @@ var init_setup_mcp = __esm({
   }
 });
 
+// src/commands/setup-daemon.ts
+var setup_daemon_exports = {};
+__export(setup_daemon_exports, {
+  setupDaemon: () => setupDaemon
+});
+function findHaansiBin() {
+  try {
+    return (0, import_node_child_process.execSync)("which haansi", { encoding: "utf-8" }).trim();
+  } catch {
+    throw new Error(
+      "Could not find haansi in PATH. Make sure it is installed globally (npm install -g haansi)."
+    );
+  }
+}
+function buildPlist(haansiPath) {
+  const binDir = haansiPath.replace(/\/[^/]+$/, "");
+  const path = `${binDir}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${haansiPath}</string>
+    <string>daemon</string>
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${path}</string>
+  </dict>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${LOG_FILE}</string>
+  <key>StandardErrorPath</key>
+  <string>${LOG_FILE}</string>
+</dict>
+</plist>`;
+}
+async function setupDaemon(uninstall) {
+  if (uninstall) {
+    if (!(0, import_node_fs3.existsSync)(PLIST_PATH)) {
+      console.log("Daemon is not installed.");
+      return;
+    }
+    try {
+      (0, import_node_child_process.execSync)(`launchctl unload "${PLIST_PATH}"`, { stdio: "pipe" });
+    } catch {
+    }
+    (0, import_node_fs3.unlinkSync)(PLIST_PATH);
+    console.log("Daemon stopped and removed.");
+    return;
+  }
+  const haansiPath = findHaansiBin();
+  (0, import_node_fs3.mkdirSync)((0, import_node_path3.join)((0, import_node_os3.homedir)(), ".haansi"), { recursive: true });
+  (0, import_node_fs3.writeFileSync)(PLIST_PATH, buildPlist(haansiPath), "utf-8");
+  try {
+    (0, import_node_child_process.execSync)(`launchctl unload "${PLIST_PATH}"`, { stdio: "pipe" });
+  } catch {
+  }
+  (0, import_node_child_process.execSync)(`launchctl load "${PLIST_PATH}"`, { stdio: "inherit" });
+  console.log("Daemon installed and started.");
+  console.log(`Plist : ${PLIST_PATH}`);
+  console.log(`Logs  : ${LOG_FILE}`);
+  console.log(`
+The daemon will start automatically on every login.`);
+  console.log(`To uninstall: haansi setup-daemon --uninstall`);
+}
+var import_node_child_process, import_node_fs3, import_node_path3, import_node_os3, PLIST_LABEL, PLIST_PATH, LOG_FILE;
+var init_setup_daemon = __esm({
+  "src/commands/setup-daemon.ts"() {
+    "use strict";
+    import_node_child_process = require("node:child_process");
+    import_node_fs3 = require("node:fs");
+    import_node_path3 = require("node:path");
+    import_node_os3 = require("node:os");
+    PLIST_LABEL = "co.haansi.daemon";
+    PLIST_PATH = (0, import_node_path3.join)(
+      (0, import_node_os3.homedir)(),
+      "Library",
+      "LaunchAgents",
+      `${PLIST_LABEL}.plist`
+    );
+    LOG_FILE = (0, import_node_path3.join)((0, import_node_os3.homedir)(), ".haansi", "daemon.log");
+  }
+});
+
+// src/commands/list.ts
+var list_exports = {};
+__export(list_exports, {
+  list: () => list
+});
+function resolveToken3() {
+  if (process.env.HAANSI_TOKEN) return process.env.HAANSI_TOKEN;
+  if ((0, import_node_fs4.existsSync)(CREDENTIALS_FILE4)) {
+    try {
+      const creds = JSON.parse((0, import_node_fs4.readFileSync)(CREDENTIALS_FILE4, "utf-8"));
+      if (creds.token) return creds.token;
+    } catch {
+    }
+  }
+  throw new Error("No token found. Run `haansi init` first.");
+}
+async function apiGet2(path, token, apiUrl) {
+  const response = await fetch(`${apiUrl}/api/v1${path}`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(`API error ${response.status}: ${body.slice(0, 200)}`);
+  }
+  return response.json();
+}
+async function list(options) {
+  const apiUrl = process.env.HAANSI_API_URL ?? DEFAULT_API_URL4;
+  const token = resolveToken3();
+  let data;
+  if (options.search) {
+    data = await apiGet2(
+      `/sessions/search?q=${encodeURIComponent(options.search)}&top_k=${options.limit}`,
+      token,
+      apiUrl
+    );
+  } else {
+    data = await apiGet2(
+      `/sessions/recent?limit=${options.limit}`,
+      token,
+      apiUrl
+    );
+  }
+  if (!data.results || data.results.length === 0) {
+    console.log("No solutions found. Run `haansi collect` to upload sessions.");
+    return;
+  }
+  const separator = "\n" + "\u2500".repeat(60) + "\n";
+  console.log(data.results.join(separator));
+  console.log(`
+${data.results.length} result(s)`);
+}
+var import_node_fs4, import_node_path4, import_node_os4, DEFAULT_API_URL4, CREDENTIALS_FILE4;
+var init_list = __esm({
+  "src/commands/list.ts"() {
+    "use strict";
+    import_node_fs4 = require("node:fs");
+    import_node_path4 = require("node:path");
+    import_node_os4 = require("node:os");
+    DEFAULT_API_URL4 = "https://api.haansi.co";
+    CREDENTIALS_FILE4 = (0, import_node_path4.join)((0, import_node_os4.homedir)(), ".haansi", "credentials.json");
+  }
+});
+
 // src/index.ts
 var command = process.argv[2];
 async function run2() {
@@ -32191,9 +32478,16 @@ async function run2() {
       const limitIdx = process.argv.indexOf("--limit");
       const limit = limitIdx !== -1 ? parseInt(process.argv[limitIdx + 1], 10) : void 0;
       const projectPath = process.env.CLAUDE_PROJECT_PATH || void 0;
-      const { uploaded, skipped, errors } = await collect2({ forceAll, dryRun, limit, projectPath });
-      console.log(`
-Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`);
+      const { uploaded, skipped, errors } = await collect2({
+        forceAll,
+        dryRun,
+        limit,
+        projectPath
+      });
+      console.log(
+        `
+Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`
+      );
       if (errors > 0) process.exit(1);
       break;
     }
@@ -32210,6 +32504,21 @@ Collector done: ${uploaded} uploaded, ${skipped} unchanged, ${errors} errors`);
       await setupMcp2();
       break;
     }
+    case "setup-daemon": {
+      const { setupDaemon: setupDaemon2 } = await Promise.resolve().then(() => (init_setup_daemon(), setup_daemon_exports));
+      const uninstall = process.argv.includes("--uninstall");
+      await setupDaemon2(uninstall);
+      break;
+    }
+    case "list": {
+      const { list: list2 } = await Promise.resolve().then(() => (init_list(), list_exports));
+      const searchIdx = process.argv.indexOf("--search");
+      const search = searchIdx !== -1 ? process.argv[searchIdx + 1] : void 0;
+      const limitIdx = process.argv.indexOf("--limit");
+      const limit = limitIdx !== -1 ? parseInt(process.argv[limitIdx + 1], 10) : 10;
+      await list2({ search, limit });
+      break;
+    }
     case "help":
     default: {
       printUsage();
@@ -32231,8 +32540,14 @@ Commands:
   daemon                 Run the collector on a schedule (every 30 min)
   mcp-server             Start the Haansi MCP server (used by Claude Code)
   setup-mcp              Add haansi-solutions MCP entry to ~/.claude.json
+  list                   List or search mined solutions
+  setup-daemon           Install launchd service to auto-start daemon on login (macOS)
   help                   Show this help message
 
+Options for list:
+  --search <query>       Semantic search instead of listing recent
+  --limit <n>            Number of results (default: 10)
+
 Options for collect:
   --force-all            Re-upload all sessions, not just new ones
   --dry-run              Scan without uploading
@@ -32240,7 +32555,7 @@ Options for collect:
 
 Environment variables:
   HAANSI_TOKEN           API token (or use \`haansi init\` to save it)
-  HAANSI_API_URL         API base URL (default: https://api.haansi.com)
+  HAANSI_API_URL         API base URL (default: https://api.haansi.co)
   CLAUDE_PROJECT_PATH    Collect from a specific project path only
   CLAUDE_COLLECT_SCHEDULE  Cron expression for daemon (default: */30 * * * *)
 `);

package/package.json

@@ -1,9 +1,14 @@
 {
   "name": "haansi",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Haansi CLI - Session collector and MCP server for Claude Code",
-  "bin": { "haansi": "./dist/haansi.js" },
-  "files": ["dist/", "README.md"],
+  "bin": {
+    "haansi": "./dist/haansi.js"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
   "scripts": {
     "build": "node build.mjs",
     "prepublishOnly": "npm run build"
@@ -13,5 +18,7 @@
     "typescript": "^5.7.2",
     "@types/node": "^22.10.1"
   },
-  "engines": { "node": ">=18.0.0" }
+  "engines": {
+    "node": ">=18.0.0"
+  }
 }