@gowelle/stint-agent 1.2.24 → 1.2.26

package/dist/{StatusDashboard-LBWMHOJP.js → StatusDashboard-6BRCPQQO.js}

@@ -2,10 +2,10 @@ import {
   gitService,
   projectService,
   validatePidFile
-} from "./chunk-7HPDJIUC.js";
+} from "./chunk-Z7ZSQCVR.js";
 import {
   authService
-} from "./chunk-OPGKT2KO.js";
+} from "./chunk-ZHIGA6EY.js";
 
 // src/components/StatusDashboard.tsx
 import { useState, useEffect } from "react";

package/dist/api-3Y72TBXG.js

@@ -0,0 +1,7 @@
+import {
+  apiService
+} from "./chunk-YXNR7UVV.js";
+import "./chunk-ZHIGA6EY.js";
+export {
+  apiService
+};

package/dist/{chunk-ZBOIXU7G.js → chunk-CCMXVYVO.js}

@@ -1,15 +1,15 @@
 import {
   apiService
-} from "./chunk-YXU3YS4B.js";
+} from "./chunk-YXNR7UVV.js";
 import {
   gitService,
   projectService
-} from "./chunk-7HPDJIUC.js";
+} from "./chunk-Z7ZSQCVR.js";
 import {
   authService,
   config,
   logger
-} from "./chunk-OPGKT2KO.js";
+} from "./chunk-ZHIGA6EY.js";
 
 // src/utils/notify.ts
 import notifier from "node-notifier";
@@ -43,8 +43,84 @@ function notify(options) {
   }
 }
 
+// src/utils/streamer.ts
+var OutputBuffer = class {
+  buffer = "";
+  commitId;
+  lastSendTime = 0;
+  timer = null;
+  MAX_BUFFER_SIZE = 50 * 1024;
+  // 50KB safety limit
+  FLUSH_INTERVAL = 500;
+  // 500ms
+  MIN_CHUNK_SIZE = 100;
+  // Minimum characters to trigger immediate send (optional optimization)
+  isClosed = false;
+  constructor(commitId) {
+    this.commitId = commitId;
+  }
+  /**
+   * Add output to the buffer
+   * @param data String data to append
+   */
+  append(data) {
+    if (this.isClosed) return;
+    const text = typeof data === "string" ? data : String(data);
+    if (!text) return;
+    this.buffer += text;
+    if (this.buffer.length > this.MAX_BUFFER_SIZE) {
+      this.flush();
+      return;
+    }
+    this.scheduleFlush();
+  }
+  /**
+   * Schedule a flush operation
+   */
+  scheduleFlush() {
+    const now = Date.now();
+    const timeSinceLastSend = now - this.lastSendTime;
+    if (this.timer) {
+      return;
+    }
+    if (timeSinceLastSend >= this.FLUSH_INTERVAL) {
+      this.flush();
+    } else {
+      const delay = this.FLUSH_INTERVAL - timeSinceLastSend;
+      this.timer = setTimeout(() => this.flush(), delay);
+    }
+  }
+  /**
+   * Flush current buffer to API
+   */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (!this.buffer) {
+      return;
+    }
+    const chunk = this.buffer;
+    this.buffer = "";
+    this.lastSendTime = Date.now();
+    try {
+      await apiService.streamCommitOutput(this.commitId, chunk);
+    } catch (error) {
+      logger.debug("stream", `Failed to stream output for ${this.commitId}`, error);
+    }
+  }
+  /**
+   * Close the buffer and flush remaining data
+   */
+  async close() {
+    this.isClosed = true;
+    await this.flush();
+  }
+};
+
 // src/services/hook.ts
-import { exec } from "child_process";
+import { spawn } from "child_process";
 var HookService = class {
   /**
    * Execute a list of hooks sequentially
@@ -52,7 +128,7 @@ var HookService = class {
    * @param cwd Current working directory (project root)
    * @returns List of results
    */
-  async executeHooks(hooks, cwd) {
+  async executeHooks(hooks, cwd, onOutput) {
     const results = [];
     const enabledHooks = hooks.filter((h) => h.enabled);
     if (enabledHooks.length === 0) {
@@ -61,7 +137,7 @@ var HookService = class {
     logger.info("hooks", `Running ${enabledHooks.length} pre-commit hooks...`);
     for (const hook of enabledHooks) {
       try {
-        const result = await this.executeSingleHook(hook, cwd);
+        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.`);
@@ -88,48 +164,74 @@ var HookService = class {
   /**
    * Execute a single hook with timeout
    */
-  executeSingleHook(hook, cwd) {
+  executeSingleHook(hook, cwd, onOutput) {
     return new Promise((resolve) => {
       const startTime = Date.now();
       logger.debug("hooks", `Executing hook: ${hook.name} (${hook.command})`);
-      const timeout = hook.timeout || 3e4;
-      exec(hook.command, {
+      if (onOutput) {
+        onOutput(`
+> Running hook: ${hook.name}
+`);
+      }
+      const child = spawn(hook.command, {
         cwd,
-        timeout,
-        maxBuffer: 10 * 1024 * 1024
-        // 10MB output buffer
-      }, (error, stdout, stderr) => {
-        const duration = Date.now() - startTime;
-        const combinedOutput = (stdout + "\n" + stderr).trim();
-        if (error) {
-          if (error.signal === "SIGTERM" && duration >= timeout) {
-            resolve({
-              hookId: hook.id,
-              hookName: hook.name,
-              success: false,
-              output: combinedOutput,
-              error: `Timed out after ${timeout}ms`,
-              duration
-            });
-            return;
-          }
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, FORCE_COLOR: "1" }
+        // Force color output for better terminal experience
+      });
+      let combinedOutput = "";
+      child.stdout.on("data", (data) => {
+        const text = data.toString();
+        combinedOutput += text;
+        if (onOutput) onOutput(text);
+      });
+      child.stderr.on("data", (data) => {
+        const text = data.toString();
+        combinedOutput += text;
+        if (onOutput) onOutput(text);
+      });
+      const timeoutMs = hook.timeout || 3e4;
+      const timeoutTimer = setTimeout(() => {
+        if (child.kill()) {
+          const duration = Date.now() - startTime;
+          const timeoutMsg = `
+Hook timed out after ${timeoutMs}ms`;
+          combinedOutput += timeoutMsg;
+          if (onOutput) onOutput(timeoutMsg);
           resolve({
             hookId: hook.id,
             hookName: hook.name,
             success: false,
-            output: combinedOutput,
-            error: error.message,
-            duration
-          });
-        } else {
-          resolve({
-            hookId: hook.id,
-            hookName: hook.name,
-            success: true,
-            output: combinedOutput,
+            output: combinedOutput.trim(),
+            error: `Timed out after ${timeoutMs}ms`,
             duration
           });
         }
+      }, timeoutMs);
+      child.on("close", (code) => {
+        clearTimeout(timeoutTimer);
+        const duration = Date.now() - startTime;
+        resolve({
+          hookId: hook.id,
+          hookName: hook.name,
+          success: code === 0,
+          output: combinedOutput.trim(),
+          error: code !== 0 ? `Process exited with code ${code}` : void 0,
+          duration
+        });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timeoutTimer);
+        const duration = Date.now() - startTime;
+        resolve({
+          hookId: hook.id,
+          hookName: hook.name,
+          success: false,
+          output: combinedOutput.trim(),
+          error: err.message,
+          duration
+        });
       });
     });
   }
@@ -174,13 +276,21 @@ var CommitQueueProcessor = class {
    */
   async executeCommit(commit, project, onProgress, options) {
     logger.info("queue", `Processing commit: ${commit.id} - ${commit.message}`);
+    const streamer = new OutputBuffer(commit.id);
+    const streamOutput = (text) => {
+      streamer.append(text);
+    };
     try {
+      streamer.append(`Processing commit: ${commit.message}
+`);
       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`);
       }
       logger.info("queue", `Executing in directory: ${projectPath}`);
+      streamer.append(`> Project directory: ${projectPath}
+`);
       onProgress?.("Validating repository...");
       const isRepo = await gitService.isRepo(projectPath);
       if (!isRepo) {
@@ -189,13 +299,21 @@ var CommitQueueProcessor = class {
       if (project.commitSettings?.hooks?.length) {
         onProgress?.("Running pre-commit hooks...");
         logger.info("queue", "Executing pre-commit hooks...");
-        const hookResults = await hookService.executeHooks(project.commitSettings.hooks, projectPath);
+        streamer.append("\n> Executing pre-commit hooks...\n");
+        const hookResults = await hookService.executeHooks(
+          project.commitSettings.hooks,
+          projectPath,
+          streamOutput
+        );
         const failedBlockingHook = hookResults.find(
           (r) => !r.success && project.commitSettings?.hooks.find((h) => h.id === r.hookId)?.blockOnFailure
         );
         if (failedBlockingHook) {
           const errorMsg = failedBlockingHook.error || "Unknown error";
           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}`);
@@ -205,20 +323,29 @@ ${failedBlockingHook.output}`);
         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(`
+Warning: ${failedNonBlockingHooks.length} non-blocking hooks failed.
+`);
         }
       }
       onProgress?.("Checking repository status...");
       let status = await gitService.getStatus(projectPath);
       if (commit.files && commit.files.length > 0) {
         onProgress?.(`Staging ${commit.files.length} specified files...`);
-        await gitService.stageFiles(projectPath, commit.files);
+        streamer.append(`
+> Staging ${commit.files.length} files...
+`);
+        await gitService.stageFiles(projectPath, commit.files, streamOutput);
         status = await gitService.getStatus(projectPath);
         logger.info("queue", `Auto-staged files: ${commit.files.join(", ")}`);
       } else if (status.staged.length === 0) {
         const hasChanges = status.unstaged.length > 0 || status.untracked.length > 0;
         if (hasChanges) {
           onProgress?.("Staging all changes...");
-          await gitService.stageAll(projectPath);
+          streamer.append(`
+> Auto-staging all changes...
+`);
+          await gitService.stageAll(projectPath, streamOutput);
           status = await gitService.getStatus(projectPath);
           logger.info("queue", `Auto-staged all changes`);
         }
@@ -227,19 +354,31 @@ ${failedBlockingHook.output}`);
         throw new Error("No changes to commit. The working directory is clean.");
       }
       logger.info("queue", `Committing ${status.staged.length} staged files.`);
+      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);
+      const sha = await gitService.commit(projectPath, commit.message, streamOutput);
       logger.success("queue", `Commit created successfully: ${sha}`);
+      streamer.append(`
+> Commit created: ${sha}
+`);
       let pushed = false;
       let pushError;
       const shouldPush = options?.push !== false;
       if (shouldPush) {
         try {
           onProgress?.("Pushing to remote...");
-          await gitService.push(projectPath);
+          streamer.append(`
+> Pushing to remote...
+`);
+          await gitService.push(projectPath, void 0, void 0, streamOutput);
           pushed = true;
           logger.success("queue", `Pushed commit ${sha} to remote`);
+          streamer.append(`
+> Implementation sent to remote successfully.
+`);
           notify({
             title: `Commit Pushed - ${project.name}`,
             message: `Commit "${commit.message}" successfully pushed.`
@@ -247,6 +386,9 @@ ${failedBlockingHook.output}`);
         } catch (error) {
           pushError = error.message;
           const isConflict = pushError.includes("rejected") || pushError.includes("non-fast-forward") || pushError.includes("failed to push") || pushError.includes("Updates were rejected");
+          streamer.append(`
+> Push failed: ${pushError}
+`);
           if (isConflict) {
             logger.warn("queue", `Push failed due to remote conflict: ${pushError}`);
             notify({
@@ -265,6 +407,10 @@ Run "git pull --rebase" to resolve.`
       }
       onProgress?.("Reporting to server...");
       await this.reportSuccess(commit.id, sha, pushed, pushError);
+      streamer.append(`
+> Execution completed.
+`);
+      await streamer.close();
       if (!pushed && !pushError) {
         notify({
           title: `Commit Created - ${project.name}`,
@@ -275,6 +421,10 @@ Run "git pull --rebase" to resolve.`
     } catch (error) {
       const msg = error.message;
       logger.error("queue", `Commit execution failed: ${msg}`);
+      streamer.append(`
+> Execution failed: ${msg}
+`);
+      await streamer.close();
       notify({
         title: `Commit Failed - ${project.name}`,
         message: `Failed to execute commit "${commit.message}": ${msg}`
@@ -382,6 +532,11 @@ var WebSocketServiceImpl = class {
    * @throws Error if connection fails or no auth token available
    */
   async connect() {
+    if (this.echo) {
+      logger.debug("websocket", "Closing existing connection before reconnecting...");
+      this.echo.disconnect();
+      this.echo = null;
+    }
     try {
       const token = await authService.getToken();
       if (!token) {
@@ -561,7 +716,7 @@ var WebSocketServiceImpl = class {
       if (commit.has_large_files) {
         try {
           logger.info("websocket", `Commit ${commit.id} marked as large, fetching full details...`);
-          const { apiService: apiService2 } = await import("./api-SBH72CS3.js");
+          const { apiService: apiService2 } = await import("./api-3Y72TBXG.js");
           const fullCommit = await apiService2.getCommit(commit.id);
           commit = {
             ...commit,

package/dist/{chunk-YXU3YS4B.js → chunk-YXNR7UVV.js}

@@ -2,7 +2,7 @@ import {
   authService,
   config,
   logger
-} from "./chunk-OPGKT2KO.js";
+} from "./chunk-ZHIGA6EY.js";
 
 // src/utils/circuit-breaker.ts
 var CircuitBreaker = class {
@@ -98,7 +98,7 @@ var CircuitBreaker = class {
 };
 
 // src/services/api.ts
-var AGENT_VERSION = "1.2.24";
+var AGENT_VERSION = "1.2.26";
 var ApiServiceImpl = class {
   sessionId = null;
   circuitBreaker = new CircuitBreaker({
@@ -399,6 +399,9 @@ var ApiServiceImpl = class {
     logger.info("api", `Fetched user: ${user.email}`);
     return user;
   }
+  /**
+   * Create project
+   */
   async createProject(data) {
     logger.info("api", `Creating project: ${data.name}`);
     const response = await this.request("/api/agent/projects", {
@@ -409,6 +412,25 @@ var ApiServiceImpl = class {
     logger.success("api", `Created project: ${project.name} (${project.id})`);
     return project;
   }
+  /**
+   * Stream commit output chunk to API
+   * @param commitId - Commit ID
+   * @param output - Output chunk string
+   */
+  async streamCommitOutput(commitId, output) {
+    if (!output) return;
+    try {
+      await this.request(`/api/agent/commits/${commitId}/stream`, {
+        method: "POST",
+        body: JSON.stringify({ output }),
+        headers: {
+          // customized headers if needed
+        }
+      });
+    } catch (error) {
+      logger.debug("api", `Stream failed for ${commitId}`, error);
+    }
+  }
 };
 var apiService = new ApiServiceImpl();
 

package/dist/{chunk-7HPDJIUC.js → chunk-Z7ZSQCVR.js}

@@ -1,13 +1,24 @@
 import {
   config,
   logger
-} from "./chunk-OPGKT2KO.js";
+} from "./chunk-ZHIGA6EY.js";
 
 // src/services/git.ts
 import simpleGit from "simple-git";
 var GitServiceImpl = class {
-  getGit(path3) {
-    return simpleGit(path3);
+  getGit(path3, onOutput) {
+    const git = simpleGit(path3);
+    if (onOutput) {
+      git.outputHandler((_command, stdout, stderr) => {
+        stdout.on("data", (data) => {
+          onOutput(data.toString());
+        });
+        stderr.on("data", (data) => {
+          onOutput(data.toString());
+        });
+      });
+    }
+    return git;
   }
   /**
    * Check if a directory is a git repository
@@ -78,9 +89,9 @@ var GitServiceImpl = class {
       throw new Error(`Failed to get repository information: ${error.message}`);
     }
   }
-  async stageAll(path3) {
+  async stageAll(path3, onOutput) {
     try {
-      const git = this.getGit(path3);
+      const git = this.getGit(path3, onOutput);
       await git.add(".");
       logger.info("git", `Staged all changes in ${path3}`);
     } catch (error) {
@@ -88,9 +99,9 @@ var GitServiceImpl = class {
       throw new Error(`Failed to stage changes: ${error.message}`);
     }
   }
-  async stageFiles(path3, files) {
+  async stageFiles(path3, files, onOutput) {
     try {
-      const git = this.getGit(path3);
+      const git = this.getGit(path3, onOutput);
       await git.add(files);
       logger.info("git", `Staged ${files.length} files in ${path3}`);
     } catch (error) {
@@ -98,9 +109,9 @@ var GitServiceImpl = class {
       throw new Error(`Failed to stage files: ${error.message}`);
     }
   }
-  async commit(path3, message) {
+  async commit(path3, message, onOutput) {
     try {
-      const git = this.getGit(path3);
+      const git = this.getGit(path3, onOutput);
       const result = await git.commit(message);
       const sha = result.commit;
       logger.success("git", `Created commit ${sha} in ${path3}`);
@@ -223,9 +234,9 @@ var GitServiceImpl = class {
    * @param remote - Remote name (default: 'origin')
    * @param branch - Branch name (optional, uses current branch if not specified)
    */
-  async push(path3, remote = "origin", branch) {
+  async push(path3, remote = "origin", branch, onOutput) {
     try {
-      const git = this.getGit(path3);
+      const git = this.getGit(path3, onOutput);
       if (branch) {
         await git.push(remote, branch);
       } else {

package/dist/{chunk-OPGKT2KO.js → chunk-ZHIGA6EY.js}

@@ -308,7 +308,7 @@ var AuthServiceImpl = class {
       return null;
     }
     try {
-      const { apiService } = await import("./api-SBH72CS3.js");
+      const { apiService } = await import("./api-3Y72TBXG.js");
       const user = await apiService.getCurrentUser();
       logger.info("auth", `Token validated for user: ${user.email}`);
       return user;

package/dist/daemon/runner.js

@@ -3,20 +3,20 @@ import {
   commitQueue,
   notify,
   websocketService
-} from "../chunk-ZBOIXU7G.js";
+} from "../chunk-CCMXVYVO.js";
 import {
   apiService
-} from "../chunk-YXU3YS4B.js";
+} from "../chunk-YXNR7UVV.js";
 import {
   gitService,
   projectService,
   removePidFile,
   writePidFile
-} from "../chunk-7HPDJIUC.js";
+} from "../chunk-Z7ZSQCVR.js";
 import {
   authService,
   logger
-} from "../chunk-OPGKT2KO.js";
+} from "../chunk-ZHIGA6EY.js";
 
 // src/daemon/runner.ts
 import "dotenv/config";

package/dist/index.js

@@ -2,10 +2,10 @@
 import {
   commitQueue,
   websocketService
-} from "./chunk-ZBOIXU7G.js";
+} from "./chunk-CCMXVYVO.js";
 import {
   apiService
-} from "./chunk-YXU3YS4B.js";
+} from "./chunk-YXNR7UVV.js";
 import {
   getPidFilePath,
   gitService,
@@ -14,14 +14,14 @@ import {
   projectService,
   spawnDetached,
   validatePidFile
-} from "./chunk-7HPDJIUC.js";
+} from "./chunk-Z7ZSQCVR.js";
 import {
   __commonJS,
   __toESM,
   authService,
   config,
   logger
-} from "./chunk-OPGKT2KO.js";
+} from "./chunk-ZHIGA6EY.js";
 
 // node_modules/semver/internal/constants.js
 var require_constants = __commonJS({
@@ -2552,7 +2552,7 @@ function registerStatusCommand(program2) {
       try {
         const { render } = await import("ink");
         const { createElement } = await import("react");
-        const { StatusDashboard } = await import("./StatusDashboard-LBWMHOJP.js");
+        const { StatusDashboard } = await import("./StatusDashboard-6BRCPQQO.js");
         render(createElement(StatusDashboard, { cwd }));
         return;
       } catch (error) {
@@ -4356,7 +4356,7 @@ ${chalk14.bold("Config file:")} ${chalk14.cyan(configPath)}
 }
 
 // src/index.ts
-var AGENT_VERSION = "1.2.24";
+var AGENT_VERSION = "1.2.26";
 var program = new Command();
 program.name("stint").description("Stint Agent - Local daemon for Stint Project Assistant").version(AGENT_VERSION, "-v, --version", "output the current version").addHelpText("after", `
 ${chalk15.bold("Examples:")}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gowelle/stint-agent",
-  "version": "1.2.24",
+  "version": "1.2.26",
   "description": "Local agent for Stint - Project Assistant",
   "author": "Gowelle John <gowelle.john@icloud.com>",
   "license": "MIT",

package/dist/api-SBH72CS3.js

@@ -1,7 +0,0 @@
-import {
-  apiService
-} from "./chunk-YXU3YS4B.js";
-import "./chunk-OPGKT2KO.js";
-export {
-  apiService
-};