@gowelle/stint-agent 1.2.35 → 1.2.37

package/dist/{chunk-MISINEGG.js → chunk-NODAAPCO.js}

@@ -1,15 +1,15 @@
 import {
   apiService
-} from "./chunk-H5GHDNXY.js";
+} from "./chunk-IBGWKTT7.js";
 import {
   gitService,
   projectService
-} from "./chunk-4655SBXG.js";
+} from "./chunk-XRNTJYCQ.js";
 import {
   authService,
   config,
   logger
-} from "./chunk-RC7Z6GTK.js";
+} from "./chunk-HPHXBSGB.js";
 
 // src/utils/notify.ts
 import notifier from "node-notifier";
@@ -23,21 +23,31 @@ function notify(options) {
     logger.debug("notify", "Notifications disabled, skipping notification");
     return;
   }
+  if (options.category && !config.isCategoryEnabled(options.category)) {
+    logger.debug(
+      "notify",
+      `Category "${options.category}" disabled, skipping notification`
+    );
+    return;
+  }
   try {
-    notifier.notify({
-      title: options.title,
-      message: options.message,
-      open: options.open,
-      icon: options.icon || DEFAULT_ICON,
-      sound: true,
-      wait: false,
-      appID: "Stint Agent"
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }, (error) => {
-      if (error) {
-        logger.error("notify", "Failed to send notification", error);
+    notifier.notify(
+      {
+        title: options.title,
+        message: options.message,
+        open: options.open,
+        icon: options.icon || DEFAULT_ICON,
+        sound: true,
+        wait: false,
+        appID: "Stint Agent"
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      },
+      (error) => {
+        if (error) {
+          logger.error("notify", "Failed to send notification", error);
+        }
       }
-    });
+    );
   } catch (error) {
     logger.error("notify", "Failed to send notification", error);
   }
@@ -107,7 +117,11 @@ var OutputBuffer = class {
     try {
       await apiService.streamCommitOutput(this.commitId, chunk);
     } catch (error) {
-      logger.debug("stream", `Failed to stream output for ${this.commitId}`, error);
+      logger.debug(
+        "stream",
+        `Failed to stream output for ${this.commitId}`,
+        error
+      );
     }
   }
   /**
@@ -140,12 +154,19 @@ var HookService = class {
         const result = await this.executeSingleHook(hook, cwd, onOutput);
         results.push(result);
         if (!result.success && hook.blockOnFailure) {
-          logger.warn("hooks", `Hook "${hook.name}" failed and is blocking. Stopping execution.`);
+          logger.warn(
+            "hooks",
+            `Hook "${hook.name}" failed and is blocking. Stopping execution.`
+          );
           break;
         }
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        logger.error("hooks", `Unexpected error running hook "${hook.name}"`, error);
+        logger.error(
+          "hooks",
+          `Unexpected error running hook "${hook.name}"`,
+          error
+        );
         results.push({
           hookId: hook.id,
           hookName: hook.name,
@@ -247,7 +268,10 @@ var CommitQueueProcessor = class {
    */
   addToQueue(commit, project) {
     this.queue.push({ commit, project });
-    logger.info("queue", `Added commit ${commit.id} to queue (position: ${this.queue.length})`);
+    logger.info(
+      "queue",
+      `Added commit ${commit.id} to queue (position: ${this.queue.length})`
+    );
     if (!this.isProcessing) {
       this.processQueue();
     }
@@ -266,7 +290,11 @@ var CommitQueueProcessor = class {
       try {
         await this.executeCommit(item.commit, item.project);
       } catch (error) {
-        logger.error("queue", `Failed to execute commit ${item.commit.id}`, error);
+        logger.error(
+          "queue",
+          `Failed to execute commit ${item.commit.id}`,
+          error
+        );
       }
     }
     this.isProcessing = false;
@@ -286,7 +314,9 @@ var CommitQueueProcessor = class {
       onProgress?.("Finding project directory...");
       const projectPath = this.findProjectPath(project.id);
       if (!projectPath) {
-        throw new Error(`Project ${project.id} is not linked to any local directory`);
+        throw new Error(
+          `Project ${project.id} is not linked to any local directory`
+        );
       }
       logger.info("queue", `Executing in directory: ${projectPath}`);
       streamer.append(`> Project directory: ${projectPath}
@@ -310,22 +340,34 @@ var CommitQueueProcessor = class {
         );
         if (failedBlockingHook) {
           const errorMsg = failedBlockingHook.error || "Unknown error";
-          logger.error("queue", `Blocking hook "${failedBlockingHook.hookName}" failed: ${errorMsg}`);
-          streamer.append(`
+          logger.error(
+            "queue",
+            `Blocking hook "${failedBlockingHook.hookName}" failed: ${errorMsg}`
+          );
+          streamer.append(
+            `
 Error: Blocking hook "${failedBlockingHook.hookName}" failed: ${errorMsg}
-`);
+`
+          );
           if (failedBlockingHook.output) {
             logger.warn("queue", `Hook output:
 ${failedBlockingHook.output}`);
           }
-          throw new Error(`Pre-commit hook "${failedBlockingHook.hookName}" failed: ${errorMsg}`);
+          throw new Error(
+            `Pre-commit hook "${failedBlockingHook.hookName}" failed: ${errorMsg}`
+          );
         }
         const failedNonBlockingHooks = hookResults.filter((r) => !r.success);
         if (failedNonBlockingHooks.length > 0) {
-          logger.warn("queue", `${failedNonBlockingHooks.length} hooks failed but were not blocking: ${failedNonBlockingHooks.map((h) => h.hookName).join(", ")}`);
-          streamer.append(`
+          logger.warn(
+            "queue",
+            `${failedNonBlockingHooks.length} hooks failed but were not blocking: ${failedNonBlockingHooks.map((h) => h.hookName).join(", ")}`
+          );
+          streamer.append(
+            `
 Warning: ${failedNonBlockingHooks.length} non-blocking hooks failed.
-`);
+`
+          );
         }
       }
       onProgress?.("Checking repository status...");
@@ -351,15 +393,23 @@ Warning: ${failedNonBlockingHooks.length} non-blocking hooks failed.
         }
       }
       if (status.staged.length === 0) {
-        throw new Error("No changes to commit. The working directory is clean.");
+        throw new Error(
+          "No changes to commit. The working directory is clean."
+        );
       }
       logger.info("queue", `Committing ${status.staged.length} staged files.`);
-      streamer.append(`
+      streamer.append(
+        `
 > Committing ${status.staged.length} staged files...
-`);
+`
+      );
       onProgress?.("Creating commit...");
       logger.info("queue", `Creating commit with message: "${commit.message}"`);
-      const sha = await gitService.commit(projectPath, commit.message, streamOutput);
+      const sha = await gitService.commit(
+        projectPath,
+        commit.message,
+        streamOutput
+      );
       logger.success("queue", `Commit created successfully: ${sha}`);
       streamer.append(`
 > Commit created: ${sha}
@@ -373,7 +423,12 @@ Warning: ${failedNonBlockingHooks.length} non-blocking hooks failed.
           streamer.append(`
 > Pushing to remote...
 `);
-          await gitService.push(projectPath, void 0, void 0, streamOutput);
+          await gitService.push(
+            projectPath,
+            void 0,
+            void 0,
+            streamOutput
+          );
           pushed = true;
           logger.success("queue", `Pushed commit ${sha} to remote`);
           streamer.append(`
@@ -381,7 +436,8 @@ Warning: ${failedNonBlockingHooks.length} non-blocking hooks failed.
 `);
           notify({
             title: `Commit Pushed - ${project.name}`,
-            message: `Commit "${commit.message}" successfully pushed.`
+            message: `Commit "${commit.message}" successfully pushed.`,
+            category: "commits"
           });
         } catch (error) {
           pushError = error.message;
@@ -390,17 +446,22 @@ Warning: ${failedNonBlockingHooks.length} non-blocking hooks failed.
 > Push failed: ${pushError}
 `);
           if (isConflict) {
-            logger.warn("queue", `Push failed due to remote conflict: ${pushError}`);
+            logger.warn(
+              "queue",
+              `Push failed due to remote conflict: ${pushError}`
+            );
             notify({
               title: `Push Conflict - ${project.name}`,
               message: `Commit "${commit.message}" created but push failed.
-Run "git pull --rebase" to resolve.`
+Run "git pull --rebase" to resolve.`,
+              category: "commits"
             });
           } else {
             logger.error("queue", `Push failed: ${pushError}`);
             notify({
               title: `Push Failed - ${project.name}`,
-              message: `Commit created but push failed: ${pushError}`
+              message: `Commit created but push failed: ${pushError}`,
+              category: "commits"
             });
           }
         }
@@ -414,7 +475,8 @@ Run "git pull --rebase" to resolve.`
       if (!pushed && !pushError) {
         notify({
           title: `Commit Created - ${project.name}`,
-          message: `Commit "${commit.message}" created locally.`
+          message: `Commit "${commit.message}" created locally.`,
+          category: "commits"
         });
       }
       return sha;
@@ -427,7 +489,8 @@ Run "git pull --rebase" to resolve.`
       await streamer.close();
       notify({
         title: `Commit Failed - ${project.name}`,
-        message: `Failed to execute commit "${commit.message}": ${msg}`
+        message: `Failed to execute commit "${commit.message}": ${msg}`,
+        category: "commits"
       });
       await this.reportFailure(commit.id, msg);
       throw error;
@@ -444,9 +507,16 @@ Run "git pull --rebase" to resolve.`
     try {
       await apiService.markCommitExecuted(commitId, sha, pushed, pushError);
       const status = pushed ? "executed" : "committed (push failed)";
-      logger.success("queue", `Reported commit ${status} to API: ${commitId} -> ${sha}`);
+      logger.success(
+        "queue",
+        `Reported commit ${status} to API: ${commitId} -> ${sha}`
+      );
     } catch (error) {
-      logger.error("queue", "Failed to report commit success to API", error);
+      logger.error(
+        "queue",
+        "Failed to report commit success to API",
+        error
+      );
     }
   }
   /**
@@ -457,7 +527,11 @@ Run "git pull --rebase" to resolve.`
       await apiService.markCommitFailed(commitId, error);
       logger.info("queue", `Reported commit failure to API: ${commitId}`);
     } catch (apiError) {
-      logger.error("queue", "Failed to report commit failure to API", apiError);
+      logger.error(
+        "queue",
+        "Failed to report commit failure to API",
+        apiError
+      );
     }
   }
   /**
@@ -493,7 +567,12 @@ import Pusher from "pusher-js";
 import fs from "fs";
 import os from "os";
 import path2 from "path";
-var STATUS_FILE_PATH = path2.join(os.homedir(), ".config", "stint", "daemon.status.json");
+var STATUS_FILE_PATH = path2.join(
+  os.homedir(),
+  ".config",
+  "stint",
+  "daemon.status.json"
+);
 function writeStatus(update) {
   try {
     const dir = path2.dirname(STATUS_FILE_PATH);
@@ -535,7 +614,10 @@ var WebSocketServiceImpl = class {
   async connect() {
     this.currentPusherClient = null;
     if (this.echo) {
-      logger.debug("websocket", "Closing existing connection before reconnecting...");
+      logger.debug(
+        "websocket",
+        "Closing existing connection before reconnecting..."
+      );
       this.echo.disconnect();
       this.echo = null;
       await new Promise((resolve) => setTimeout(resolve, 10));
@@ -563,7 +645,10 @@ var WebSocketServiceImpl = class {
         wsPort = 443;
         forceTLS = true;
       }
-      logger.info("websocket", `Connecting to ${wsHost}:${wsPort} with key ${reverbAppKey}...`);
+      logger.info(
+        "websocket",
+        `Connecting to ${wsHost}:${wsPort} with key ${reverbAppKey}...`
+      );
       const { WebSocket } = await import("ws");
       global.WebSocket = WebSocket;
       const pusherClient = new Pusher(reverbAppKey, {
@@ -586,8 +671,8 @@ var WebSocketServiceImpl = class {
               const response = await fetch(`${apiUrl}/api/broadcasting/auth`, {
                 method: "POST",
                 headers: {
-                  "Authorization": `Bearer ${token}`,
-                  "Accept": "application/json",
+                  Authorization: `Bearer ${token}`,
+                  Accept: "application/json",
                   "Content-Type": "application/json"
                 },
                 body: JSON.stringify({
@@ -597,7 +682,10 @@ var WebSocketServiceImpl = class {
               });
               if (!response.ok) {
                 const errorText = await response.text();
-                logger.error("websocket", `Auth failed (${response.status}): ${errorText}`);
+                logger.error(
+                  "websocket",
+                  `Auth failed (${response.status}): ${errorText}`
+                );
                 callback(new Error(`Auth failed: ${response.status}`));
                 return;
               }
@@ -629,7 +717,10 @@ var WebSocketServiceImpl = class {
       });
       this.echo = echoInstance;
       this.currentPusherClient = pusherClient;
-      logger.info("websocket", "Echo instance created, setting up connection handlers...");
+      logger.info(
+        "websocket",
+        "Echo instance created, setting up connection handlers..."
+      );
       return new Promise((resolve, reject) => {
         let isSettled = false;
         const safeResolve = () => {
@@ -655,20 +746,34 @@ var WebSocketServiceImpl = class {
         const connectionTimeout = setTimeout(() => {
           if (this.currentPusherClient !== pusherClient) return;
           const state = pusherClient.connection.state || "unknown";
-          logger.error("websocket", `Connection timeout after 30s (state: ${state})`);
+          logger.error(
+            "websocket",
+            `Connection timeout after 30s (state: ${state})`
+          );
           if (state !== "connected") {
-            safeReject(new Error(`Connection timeout - stuck in state: ${state}`));
+            safeReject(
+              new Error(`Connection timeout - stuck in state: ${state}`)
+            );
           }
         }, 3e4);
-        pusherClient.connection.bind("state_change", (states) => {
-          if (this.currentPusherClient === pusherClient) {
-            logger.info("websocket", `Connection state: ${states.previous} -> ${states.current}`);
+        pusherClient.connection.bind(
+          "state_change",
+          (states) => {
+            if (this.currentPusherClient === pusherClient) {
+              logger.info(
+                "websocket",
+                `Connection state: ${states.previous} -> ${states.current}`
+              );
+            }
           }
-        });
+        );
         pusherClient.connection.bind("connected", () => {
           if (this.currentPusherClient !== pusherClient) return;
           clearTimeout(connectionTimeout);
-          logger.success("websocket", "\u2705 Connected to Broadcaster via Sanctum");
+          logger.success(
+            "websocket",
+            "\u2705 Connected to Broadcaster via Sanctum"
+          );
           writeStatus({ connected: true });
           this.reconnectAttempts = 0;
           this.isManualDisconnect = false;
@@ -680,7 +785,10 @@ var WebSocketServiceImpl = class {
           const errorMessage = error instanceof Error ? error.message : JSON.stringify(error) || "Unknown connection error";
           logger.error("websocket", `WebSocket error: ${errorMessage}`);
           if (error && typeof error === "object" && "data" in error && error.data?.code === 1006) {
-            logger.warn("websocket", "Detected abnormal closure (1006), ensuring reconnection...");
+            logger.warn(
+              "websocket",
+              "Detected abnormal closure (1006), ensuring reconnection..."
+            );
             this.handleDisconnect();
           }
           if (pusherClient.connection.state === "failed") {
@@ -689,7 +797,10 @@ var WebSocketServiceImpl = class {
         });
         pusherClient.connection.bind("disconnected", () => {
           if (this.currentPusherClient !== pusherClient) {
-            logger.debug("websocket", "Ignoring disconnected event from previous connection attempt");
+            logger.debug(
+              "websocket",
+              "Ignoring disconnected event from previous connection attempt"
+            );
             return;
           }
           logger.warn("websocket", "WebSocket disconnected");
@@ -706,7 +817,10 @@ var WebSocketServiceImpl = class {
         });
         pusherClient.connection.bind("unavailable", () => {
           if (this.currentPusherClient !== pusherClient) return;
-          logger.warn("websocket", "WebSocket connection unavailable, attempting auto-reconnect");
+          logger.warn(
+            "websocket",
+            "WebSocket connection unavailable, attempting auto-reconnect"
+          );
           writeStatus({ connected: false });
           safeReject(new Error("WebSocket connection unavailable"));
         });
@@ -761,50 +875,90 @@ var WebSocketServiceImpl = class {
     logger.info("websocket", `Subscribing to private channel: ${channel}`);
     const privateChannel = this.echo.private(channel);
     writeStatus({ channel });
-    privateChannel.listen(".commit.approved", async (data) => {
-      logger.info("websocket", `Commit approved: ${data.pendingCommit.id}`);
-      writeStatus({ lastEvent: "commit.approved", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
-      let commit = data.pendingCommit;
-      if (commit.has_large_files) {
-        try {
-          logger.info("websocket", `Commit ${commit.id} marked as large, fetching full details...`);
-          const { apiService: apiService2 } = await import("./api-Z3HF3YU7.js");
-          const fullCommit = await apiService2.getCommit(commit.id);
-          commit = {
-            ...commit,
-            files: fullCommit.files,
-            has_large_files: false
-            // Clear flag as we now have the files
-          };
-          logger.success("websocket", `Fetched full details for commit ${commit.id}`);
-        } catch (error) {
-          logger.error("websocket", `Failed to fetch full commit details for ${commit.id}`, error);
+    privateChannel.listen(
+      ".commit.approved",
+      async (data) => {
+        logger.info("websocket", `Commit approved: ${data.pendingCommit.id}`);
+        writeStatus({
+          lastEvent: "commit.approved",
+          lastEventTime: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        let commit = data.pendingCommit;
+        if (commit.has_large_files) {
+          try {
+            logger.info(
+              "websocket",
+              `Commit ${commit.id} marked as large, fetching full details...`
+            );
+            const { apiService: apiService2 } = await import("./api-AFSILC7K.js");
+            const fullCommit = await apiService2.getCommit(commit.id);
+            commit = {
+              ...commit,
+              files: fullCommit.files,
+              has_large_files: false
+              // Clear flag as we now have the files
+            };
+            logger.success(
+              "websocket",
+              `Fetched full details for commit ${commit.id}`
+            );
+          } catch (error) {
+            logger.error(
+              "websocket",
+              `Failed to fetch full commit details for ${commit.id}`,
+              error
+            );
+          }
         }
+        this.commitApprovedHandlers.forEach(
+          (handler) => handler(commit, data.pendingCommit.project)
+          // Use the potentially updated commit object
+        );
       }
-      this.commitApprovedHandlers.forEach(
-        (handler) => handler(commit, data.pendingCommit.project)
-        // Use the potentially updated commit object
-      );
-    }).listen(".commit.pending", (data) => {
+    ).listen(".commit.pending", (data) => {
       logger.info("websocket", `Commit pending: ${data.pendingCommit.id}`);
-      writeStatus({ lastEvent: "commit.pending", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
-      this.commitPendingHandlers.forEach((handler) => handler(data.pendingCommit));
+      writeStatus({
+        lastEvent: "commit.pending",
+        lastEventTime: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.commitPendingHandlers.forEach(
+        (handler) => handler(data.pendingCommit)
+      );
     }).listen(".suggestion.created", (data) => {
       logger.info("websocket", `Suggestion created: ${data.suggestion.id}`);
-      writeStatus({ lastEvent: "suggestion.created", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
-      this.suggestionCreatedHandlers.forEach((handler) => handler(data.suggestion));
+      writeStatus({
+        lastEvent: "suggestion.created",
+        lastEventTime: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.suggestionCreatedHandlers.forEach(
+        (handler) => handler(data.suggestion)
+      );
     }).listen(".project.updated", (data) => {
       logger.info("websocket", `Project updated: ${data.project.id}`);
-      writeStatus({ lastEvent: "project.updated", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
+      writeStatus({
+        lastEvent: "project.updated",
+        lastEventTime: (/* @__PURE__ */ new Date()).toISOString()
+      });
       this.projectUpdatedHandlers.forEach((handler) => handler(data.project));
     }).listen(".sync.requested", (data) => {
-      logger.info("websocket", `Sync requested for project: ${data.project.id}`);
-      writeStatus({ lastEvent: "sync.requested", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
-      this.syncRequestedHandlers.forEach((handler) => handler(data.project.id));
+      logger.info(
+        "websocket",
+        `Sync requested for project: ${data.project.id}`
+      );
+      writeStatus({
+        lastEvent: "sync.requested",
+        lastEventTime: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.syncRequestedHandlers.forEach(
+        (handler) => handler(data.project.id)
+      );
     }).listen(".agent.disconnected", (data) => {
       const reason = data.reason ?? "Server requested disconnect";
       logger.warn("websocket", `Agent disconnected by server: ${reason}`);
-      writeStatus({ lastEvent: "agent.disconnected", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
+      writeStatus({
+        lastEvent: "agent.disconnected",
+        lastEventTime: (/* @__PURE__ */ new Date()).toISOString()
+      });
       this.agentDisconnectedHandlers.forEach((handler) => handler(reason));
     });
     logger.success("websocket", `Subscribed to private channel: ${channel}`);
@@ -846,7 +1000,10 @@ var WebSocketServiceImpl = class {
     if (this.reconnectAttempts < this.maxReconnectAttempts) {
       const delay = this.getReconnectDelay();
       this.reconnectAttempts++;
-      logger.info("websocket", `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+      logger.info(
+        "websocket",
+        `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+      );
       this.reconnectTimer = setTimeout(async () => {
         try {
           await this.connect();
@@ -856,7 +1013,10 @@ var WebSocketServiceImpl = class {
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
           if (errorMessage.includes("disconnected during connection")) {
-            logger.debug("websocket", "Connection disconnected during reconnection attempt, will retry");
+            logger.debug(
+              "websocket",
+              "Connection disconnected during reconnection attempt, will retry"
+            );
           } else {
             logger.error("websocket", "Reconnection failed", error);
           }