@gowelle/stint-agent 1.2.35 → 1.2.37

package/dist/{chunk-4655SBXG.js → chunk-XRNTJYCQ.js}

@@ -1,7 +1,7 @@
 import {
   config,
   logger
-} from "./chunk-RC7Z6GTK.js";
+} from "./chunk-HPHXBSGB.js";
 
 // src/services/git.ts
 import simpleGit from "simple-git";
@@ -30,7 +30,11 @@ var GitServiceImpl = class {
       const git = this.getGit(path3);
       return await git.checkIsRepo();
     } catch (error) {
-      logger.error("git", `Failed to check if ${path3} is a repo`, error);
+      logger.error(
+        "git",
+        `Failed to check if ${path3} is a repo`,
+        error
+      );
       return false;
     }
   }
@@ -53,7 +57,10 @@ var GitServiceImpl = class {
       onProgress?.("Determining default branch...");
       let defaultBranch = currentBranch;
       try {
-        const result = await git.raw(["symbolic-ref", "refs/remotes/origin/HEAD"]);
+        const result = await git.raw([
+          "symbolic-ref",
+          "refs/remotes/origin/HEAD"
+        ]);
         const match = result.trim().match(/refs\/remotes\/origin\/(.+)/);
         if (match) {
           defaultBranch = match[1];
@@ -85,8 +92,14 @@ var GitServiceImpl = class {
         lastCommitDate: lastCommit.date
       };
     } catch (error) {
-      logger.error("git", `Failed to get repo info for ${path3}`, error);
-      throw new Error(`Failed to get repository information: ${error.message}`);
+      logger.error(
+        "git",
+        `Failed to get repo info for ${path3}`,
+        error
+      );
+      throw new Error(
+        `Failed to get repository information: ${error.message}`
+      );
     }
   }
   async stageAll(path3, onOutput) {
@@ -127,8 +140,14 @@ var GitServiceImpl = class {
       const branchSummary = await git.branch();
       return branchSummary.current;
     } catch (error) {
-      logger.error("git", `Failed to get current branch in ${path3}`, error);
-      throw new Error(`Failed to get current branch: ${error.message}`);
+      logger.error(
+        "git",
+        `Failed to get current branch in ${path3}`,
+        error
+      );
+      throw new Error(
+        `Failed to get current branch: ${error.message}`
+      );
     }
   }
   async getBranches(path3) {
@@ -221,11 +240,20 @@ var GitServiceImpl = class {
           });
         }
       }
-      logger.info("git", `Found ${changedFiles.length} changed files in ${path3}`);
+      logger.info(
+        "git",
+        `Found ${changedFiles.length} changed files in ${path3}`
+      );
       return changedFiles;
     } catch (error) {
-      logger.error("git", `Failed to get changed files in ${path3}`, error);
-      throw new Error(`Failed to get changed files: ${error.message}`);
+      logger.error(
+        "git",
+        `Failed to get changed files in ${path3}`,
+        error
+      );
+      throw new Error(
+        `Failed to get changed files: ${error.message}`
+      );
     }
   }
   /**
@@ -279,7 +307,10 @@ var ProjectServiceImpl = class {
         linkedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       config.setProject(linkPath, linkedProject);
-      logger.success("project", `Linked ${linkPath} must be to project ${projectId}`);
+      logger.success(
+        "project",
+        `Linked ${linkPath} must be to project ${projectId}`
+      );
     } catch (error) {
       logger.error("project", "Failed to link project", error);
       throw error;
@@ -350,7 +381,9 @@ function killProcess(pid, signal = "SIGTERM") {
     logger.info("process", `Sent ${signal} to process ${pid}`);
   } catch (error) {
     logger.error("process", `Failed to kill process ${pid}`, error);
-    throw new Error(`Failed to kill process ${pid}: ${error.message}`);
+    throw new Error(
+      `Failed to kill process ${pid}: ${error.message}`
+    );
   }
 }
 function spawnDetached(command, args, options = {}) {

package/dist/daemon/runner.js

@@ -3,20 +3,20 @@ import {
   commitQueue,
   notify,
   websocketService
-} from "../chunk-MISINEGG.js";
+} from "../chunk-NODAAPCO.js";
 import {
   apiService
-} from "../chunk-H5GHDNXY.js";
+} from "../chunk-IBGWKTT7.js";
 import {
   gitService,
   projectService,
   removePidFile,
   writePidFile
-} from "../chunk-4655SBXG.js";
+} from "../chunk-XRNTJYCQ.js";
 import {
   authService,
   logger
-} from "../chunk-RC7Z6GTK.js";
+} from "../chunk-HPHXBSGB.js";
 
 // src/daemon/runner.ts
 import "dotenv/config";
@@ -69,20 +69,30 @@ var FileWatcher = class {
         logger.warn("watcher", `Project path does not exist: ${projectPath}`);
         return;
       }
-      const watcher = fs.watch(projectPath, { recursive: true }, (eventType, filename) => {
-        if (!filename) return;
-        const filenameStr = Buffer.isBuffer(filename) ? filename.toString("utf8") : filename;
-        if (this.shouldIgnore(filenameStr)) {
-          return;
-        }
-        logger.debug("watcher", `File change detected: ${filenameStr} (${eventType}) in ${projectPath}`);
-        const watcherInfo = this.watchers.get(projectPath);
-        if (watcherInfo && !watcherInfo.enabled) {
-          logger.debug("watcher", `Auto-sync disabled for project ${projectId}, skipping sync`);
-          return;
+      const watcher = fs.watch(
+        projectPath,
+        { recursive: true },
+        (eventType, filename) => {
+          if (!filename) return;
+          const filenameStr = Buffer.isBuffer(filename) ? filename.toString("utf8") : filename;
+          if (this.shouldIgnore(filenameStr)) {
+            return;
+          }
+          logger.debug(
+            "watcher",
+            `File change detected: ${filenameStr} (${eventType}) in ${projectPath}`
+          );
+          const watcherInfo = this.watchers.get(projectPath);
+          if (watcherInfo && !watcherInfo.enabled) {
+            logger.debug(
+              "watcher",
+              `Auto-sync disabled for project ${projectId}, skipping sync`
+            );
+            return;
+          }
+          this.debounceSync(projectPath, projectId);
         }
-        this.debounceSync(projectPath, projectId);
-      });
+      );
       watcher.on("error", (error) => {
         logger.error("watcher", `Watcher error for ${projectPath}`, error);
         const watcherInfo = this.watchers.get(projectPath);
@@ -101,7 +111,10 @@ var FileWatcher = class {
         enabled: true
         // Enabled by default until settings are fetched
       });
-      logger.info("watcher", `Started watching: ${projectPath} (project: ${projectId})`);
+      logger.info(
+        "watcher",
+        `Started watching: ${projectPath} (project: ${projectId})`
+      );
     } catch (error) {
       logger.error("watcher", `Failed to watch ${projectPath}`, error);
     }
@@ -151,7 +164,11 @@ var FileWatcher = class {
       try {
         await this.performSync(projectPath, projectId);
       } catch (error) {
-        logger.error("watcher", `Sync failed for ${projectPath}`, error);
+        logger.error(
+          "watcher",
+          `Sync failed for ${projectPath}`,
+          error
+        );
       } finally {
         watcherInfo.debounceTimer = null;
       }
@@ -165,29 +182,29 @@ var FileWatcher = class {
     try {
       const isRepo = await gitService.isRepo(projectPath);
       if (!isRepo) {
-        logger.warn("watcher", `Project ${projectPath} is no longer a git repository`);
+        logger.warn(
+          "watcher",
+          `Project ${projectPath} is no longer a git repository`
+        );
         return;
       }
       const repoInfo = await gitService.getRepoInfo(projectPath);
       const changedFiles = await gitService.getChangedFiles(projectPath);
-      const response = await apiService.syncProject(projectId, repoInfo, changedFiles);
+      const response = await apiService.syncProject(
+        projectId,
+        repoInfo,
+        changedFiles
+      );
       if (response.auto_sync) {
         this.updateProjectSettings(projectId, response.auto_sync);
       }
       logger.success("watcher", `Synced project ${projectId}`);
-      let projectName = projectId;
-      try {
-        const projects = await apiService.getLinkedProjects();
-        const p = projects.find((proj) => proj.id === projectId);
-        if (p) projectName = p.name;
-      } catch (_e) {
-      }
-      notify({
-        title: "Sync Complete",
-        message: `Project "${projectName}" synced successfully.`
-      });
     } catch (error) {
-      logger.error("watcher", `Failed to sync project ${projectId}`, error);
+      logger.error(
+        "watcher",
+        `Failed to sync project ${projectId}`,
+        error
+      );
     }
   }
   /**
@@ -203,7 +220,11 @@ var FileWatcher = class {
         watcherInfo.watcher.close();
         logger.debug("watcher", `Stopped watching: ${projectPath}`);
       } catch (error) {
-        logger.error("watcher", `Error stopping watcher for ${projectPath}`, error);
+        logger.error(
+          "watcher",
+          `Error stopping watcher for ${projectPath}`,
+          error
+        );
       }
     }
     this.watchers.clear();
@@ -226,7 +247,10 @@ var FileWatcher = class {
         return;
       }
     }
-    logger.warn("watcher", `Cannot sync: project ${projectId} not found in linked projects`);
+    logger.warn(
+      "watcher",
+      `Cannot sync: project ${projectId} not found in linked projects`
+    );
   }
   /**
    * Remove a project from watching (called when a project is unlinked)
@@ -242,7 +266,11 @@ var FileWatcher = class {
       this.watchers.delete(projectPath);
       logger.info("watcher", `Stopped watching: ${projectPath}`);
     } catch (error) {
-      logger.error("watcher", `Error removing watcher for ${projectPath}`, error);
+      logger.error(
+        "watcher",
+        `Error removing watcher for ${projectPath}`,
+        error
+      );
     }
   }
   /**
@@ -253,12 +281,61 @@ var FileWatcher = class {
       if (watcherInfo.projectId === projectId) {
         watcherInfo.enabled = settings.enabled;
         watcherInfo.debounceDelay = settings.interval * 1e3;
-        logger.debug("watcher", `Updated settings for project ${projectId}: enabled=${settings.enabled}, interval=${settings.interval}s`);
+        logger.debug(
+          "watcher",
+          `Updated settings for project ${projectId}: enabled=${settings.enabled}, interval=${settings.interval}s`
+        );
       }
     }
   }
 };
 
+// src/daemon/sync.ts
+async function syncPendingCommits() {
+  logger.info("sync", "Syncing pending commits...");
+  const linkedProjects = projectService.getAllLinkedProjects();
+  const linkedProjectIds = Object.values(linkedProjects).map(
+    (p) => p.projectId
+  );
+  if (linkedProjectIds.length === 0) {
+    logger.info("sync", "No linked projects found locally.");
+    return;
+  }
+  try {
+    const apiProjects = await apiService.getLinkedProjects();
+    const relevantProjects = apiProjects.filter(
+      (p) => linkedProjectIds.includes(p.id)
+    );
+    logger.info(
+      "sync",
+      `Checking ${relevantProjects.length} projects for pending commits...`
+    );
+    for (const project of relevantProjects) {
+      try {
+        const pendingCommits = await apiService.getPendingCommits(project.id);
+        if (pendingCommits.length > 0) {
+          logger.info(
+            "sync",
+            `Found ${pendingCommits.length} pending commits for project ${project.name}`
+          );
+          for (const commit of pendingCommits) {
+            commitQueue.addToQueue(commit, project);
+          }
+        }
+      } catch (error) {
+        logger.error(
+          "sync",
+          `Failed to sync commits for project ${project.name}`,
+          error
+        );
+      }
+    }
+    logger.success("sync", "Pending commit sync complete");
+  } catch (error) {
+    logger.error("sync", "Failed to sync pending commits", error);
+  }
+}
+
 // src/daemon/index.ts
 var heartbeatInterval = null;
 var isShuttingDown = false;
@@ -284,11 +361,15 @@ async function startDaemon() {
     logger.success("daemon", "WebSocket connected");
     await websocketService.subscribeToUserChannel(user.id);
     websocketService.onCommitApproved((commit, project) => {
-      logger.info("daemon", `Commit approved: ${commit.id} for project ${project.name}`);
+      logger.info(
+        "daemon",
+        `Commit approved: ${commit.id} for project ${project.name}`
+      );
       notify({
         title: "Commit Approved",
         message: `${commit.message}
-Project: ${project.name}`
+Project: ${project.name}`,
+        category: "commits"
       });
       commitQueue.addToQueue(commit, project);
     });
@@ -304,21 +385,29 @@ Project: ${project.name}`
       }
       notify({
         title: `New Proposal - ${projectName}`,
-        message: commit.message
+        message: commit.message,
+        category: "commits"
       });
     });
     websocketService.onProjectUpdated((project) => {
       logger.info("daemon", `Project updated: ${project.id} - ${project.name}`);
       if (project.settings?.auto_sync) {
-        fileWatcher.updateProjectSettings(project.id, project.settings.auto_sync);
+        fileWatcher.updateProjectSettings(
+          project.id,
+          project.settings.auto_sync
+        );
       }
       notify({
         title: "Project Updated",
-        message: project.name
+        message: project.name,
+        category: "sync"
       });
     });
     websocketService.onDisconnect(() => {
-      logger.warn("daemon", "WebSocket disconnected, will attempt to reconnect");
+      logger.warn(
+        "daemon",
+        "WebSocket disconnected, will attempt to reconnect"
+      );
     });
     websocketService.onAgentDisconnected(async (reason) => {
       logger.warn("daemon", `Server disconnected agent: ${reason}`);
@@ -327,13 +416,16 @@ Project: ${project.name}`
       process.exit(0);
     });
     websocketService.onSuggestionCreated((suggestion) => {
-      logger.info("daemon", `Suggestion created: ${suggestion.title} (${suggestion.priority})`);
+      logger.info(
+        "daemon",
+        `Suggestion created: ${suggestion.title} (${suggestion.priority})`
+      );
       notify({
         title: "New Suggestion",
         message: `${suggestion.title}
 Priority: ${suggestion.priority}`,
-        open: `https://stint.codes/projects/${suggestion.project_id}/suggestions/${suggestion.id}`
-        // Hypothetical URL structure
+        open: `https://stint.codes/projects/${suggestion.project_id}/suggestions/${suggestion.id}`,
+        category: "suggestions"
       });
     });
     websocketService.onSyncRequested(async (projectId) => {
@@ -350,11 +442,16 @@ Priority: ${suggestion.priority}`,
         }
         notify({
           title: "Sync Requested",
-          message: `Syncing project "${projectName}"...`
+          message: `Syncing project "${projectName}"...`,
+          category: "sync"
         });
         await fileWatcher.syncProjectById(projectId);
       } catch (error) {
-        logger.error("daemon", `Failed to sync project ${projectId}`, error);
+        logger.error(
+          "daemon",
+          `Failed to sync project ${projectId}`,
+          error
+        );
       }
     });
     setupSignalHandlers();
@@ -365,16 +462,24 @@ Priority: ${suggestion.priority}`,
     const linkedProjects = projectService.getAllLinkedProjects();
     const projectEntries = Object.entries(linkedProjects);
     if (projectEntries.length > 0) {
-      logger.info("daemon", `Syncing ${projectEntries.length} linked project(s) on startup...`);
+      logger.info(
+        "daemon",
+        `Syncing ${projectEntries.length} linked project(s) on startup...`
+      );
       for (const [, linkedProject] of projectEntries) {
         try {
           await fileWatcher.syncProjectById(linkedProject.projectId);
         } catch (error) {
-          logger.error("daemon", `Failed to sync project ${linkedProject.projectId} on startup`, error);
+          logger.error(
+            "daemon",
+            `Failed to sync project ${linkedProject.projectId} on startup`,
+            error
+          );
         }
       }
       logger.success("daemon", "Initial project sync complete");
     }
+    await syncPendingCommits();
     logger.success("daemon", "Daemon started successfully");
     await new Promise(() => {
     });
@@ -431,7 +536,11 @@ async function shutdown(reason) {
     websocketService.disconnect();
     logger.info("daemon", "Disconnected from WebSocket");
   } catch (error) {
-    logger.error("daemon", "Failed to disconnect from WebSocket", error);
+    logger.error(
+      "daemon",
+      "Failed to disconnect from WebSocket",
+      error
+    );
   }
   try {
     await apiService.disconnect(shutdownReason);