@gowelle/stint-agent 1.0.0

package/dist/chunk-PPODHVVP.js

@@ -0,0 +1,408 @@
+import {
+  apiService,
+  config,
+  logger
+} from "./chunk-5DWSNHS6.js";
+
+// src/utils/process.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { spawn } from "child_process";
+var PID_FILE = path.join(os.homedir(), ".config", "stint", "daemon.pid");
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProcess(pid, signal = "SIGTERM") {
+  try {
+    process.kill(pid, signal);
+    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}`);
+  }
+}
+function spawnDetached(command, args, options = {}) {
+  const logDir = path.join(os.homedir(), ".config", "stint", "logs");
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+  const stdoutPath = options.stdout || path.join(logDir, "daemon.log");
+  const stderrPath = options.stderr || path.join(logDir, "daemon-error.log");
+  const out = fs.openSync(stdoutPath, "a");
+  const err = fs.openSync(stderrPath, "a");
+  const child = spawn(command, args, {
+    detached: true,
+    stdio: ["ignore", out, err],
+    cwd: options.cwd || process.cwd(),
+    env: options.env || process.env
+  });
+  child.unref();
+  logger.info("process", `Spawned detached process ${child.pid}`);
+  return child.pid;
+}
+function writePidFile(pid) {
+  const pidDir = path.dirname(PID_FILE);
+  if (!fs.existsSync(pidDir)) {
+    fs.mkdirSync(pidDir, { recursive: true });
+  }
+  fs.writeFileSync(PID_FILE, pid.toString(), { mode: 384 });
+  logger.info("process", `Wrote PID ${pid} to ${PID_FILE}`);
+}
+function readPidFile() {
+  try {
+    if (!fs.existsSync(PID_FILE)) {
+      return null;
+    }
+    const pidStr = fs.readFileSync(PID_FILE, "utf8").trim();
+    const pid = parseInt(pidStr, 10);
+    if (isNaN(pid)) {
+      logger.warn("process", `Invalid PID in file: ${pidStr}`);
+      return null;
+    }
+    return pid;
+  } catch (error) {
+    logger.error("process", "Failed to read PID file", error);
+    return null;
+  }
+}
+function removePidFile() {
+  try {
+    if (fs.existsSync(PID_FILE)) {
+      fs.unlinkSync(PID_FILE);
+      logger.info("process", "Removed PID file");
+    }
+  } catch (error) {
+    logger.error("process", "Failed to remove PID file", error);
+  }
+}
+function validatePidFile() {
+  const pid = readPidFile();
+  if (pid === null) {
+    return { valid: false, pid: null };
+  }
+  const running = isProcessRunning(pid);
+  if (!running) {
+    logger.warn("process", `PID file exists but process ${pid} is not running`);
+    removePidFile();
+    return { valid: false, pid: null };
+  }
+  return { valid: true, pid };
+}
+function getPidFilePath() {
+  return PID_FILE;
+}
+
+// src/services/git.ts
+import simpleGit from "simple-git";
+var GitServiceImpl = class {
+  getGit(path3) {
+    return simpleGit(path3);
+  }
+  async isRepo(path3) {
+    try {
+      const git = this.getGit(path3);
+      return await git.checkIsRepo();
+    } catch (error) {
+      logger.error("git", `Failed to check if ${path3} is a repo`, error);
+      return false;
+    }
+  }
+  async getRepoInfo(path3) {
+    try {
+      const git = this.getGit(path3);
+      const branchSummary = await git.branch();
+      const currentBranch = branchSummary.current;
+      const branches = branchSummary.all;
+      const remotes = await git.getRemotes(true);
+      const remoteUrl = remotes.length > 0 ? remotes[0].refs.fetch : null;
+      const status = await this.getStatus(path3);
+      const log = await git.log({ maxCount: 1 });
+      const lastCommit = log.latest;
+      if (!lastCommit) {
+        throw new Error("No commits found in repository");
+      }
+      return {
+        currentBranch,
+        branches,
+        remoteUrl,
+        status,
+        lastCommitSha: lastCommit.hash,
+        lastCommitMessage: lastCommit.message,
+        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}`);
+    }
+  }
+  async stageAll(path3) {
+    try {
+      const git = this.getGit(path3);
+      await git.add(".");
+      logger.info("git", `Staged all changes in ${path3}`);
+    } catch (error) {
+      logger.error("git", `Failed to stage all in ${path3}`, error);
+      throw new Error(`Failed to stage changes: ${error.message}`);
+    }
+  }
+  async stageFiles(path3, files) {
+    try {
+      const git = this.getGit(path3);
+      await git.add(files);
+      logger.info("git", `Staged ${files.length} files in ${path3}`);
+    } catch (error) {
+      logger.error("git", `Failed to stage files in ${path3}`, error);
+      throw new Error(`Failed to stage files: ${error.message}`);
+    }
+  }
+  async commit(path3, message) {
+    try {
+      const git = this.getGit(path3);
+      const result = await git.commit(message);
+      const sha = result.commit;
+      logger.success("git", `Created commit ${sha} in ${path3}`);
+      return sha;
+    } catch (error) {
+      logger.error("git", `Failed to commit in ${path3}`, error);
+      throw new Error(`Failed to create commit: ${error.message}`);
+    }
+  }
+  async getCurrentBranch(path3) {
+    try {
+      const git = this.getGit(path3);
+      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}`);
+    }
+  }
+  async getBranches(path3) {
+    try {
+      const git = this.getGit(path3);
+      const branchSummary = await git.branch();
+      return branchSummary.all.map((name) => ({
+        name,
+        current: name === branchSummary.current,
+        commit: branchSummary.branches[name]?.commit || ""
+      }));
+    } catch (error) {
+      logger.error("git", `Failed to get branches in ${path3}`, error);
+      throw new Error(`Failed to get branches: ${error.message}`);
+    }
+  }
+  async getStatus(path3) {
+    try {
+      const git = this.getGit(path3);
+      const status = await git.status();
+      return {
+        staged: status.staged,
+        unstaged: status.modified.concat(status.deleted),
+        untracked: status.not_added,
+        ahead: status.ahead,
+        behind: status.behind
+      };
+    } catch (error) {
+      logger.error("git", `Failed to get status in ${path3}`, error);
+      throw new Error(`Failed to get git status: ${error.message}`);
+    }
+  }
+};
+var gitService = new GitServiceImpl();
+
+// src/services/project.ts
+import path2 from "path";
+var ProjectServiceImpl = class {
+  async linkProject(projectPath, projectId) {
+    try {
+      const absolutePath = path2.resolve(projectPath);
+      const isRepo = await gitService.isRepo(absolutePath);
+      if (!isRepo) {
+        throw new Error(`${absolutePath} is not a git repository`);
+      }
+      const linkedProject = {
+        projectId,
+        linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      config.setProject(absolutePath, linkedProject);
+      logger.success("project", `Linked ${absolutePath} to project ${projectId}`);
+    } catch (error) {
+      logger.error("project", "Failed to link project", error);
+      throw error;
+    }
+  }
+  async unlinkProject(projectPath) {
+    try {
+      const absolutePath = path2.resolve(projectPath);
+      const linkedProject = this.getLinkedProject(absolutePath);
+      if (!linkedProject) {
+        throw new Error(`${absolutePath} is not linked to any project`);
+      }
+      config.removeProject(absolutePath);
+      logger.success("project", `Unlinked ${absolutePath}`);
+    } catch (error) {
+      logger.error("project", "Failed to unlink project", error);
+      throw error;
+    }
+  }
+  getLinkedProject(projectPath) {
+    const absolutePath = path2.resolve(projectPath);
+    return config.getProject(absolutePath) || null;
+  }
+  getAllLinkedProjects() {
+    return config.getProjects();
+  }
+  /**
+   * Get local path for a project ID
+   */
+  getProjectPath(projectId) {
+    const allProjects = this.getAllLinkedProjects();
+    for (const [path3, linkedProject] of Object.entries(allProjects)) {
+      if (linkedProject.projectId === projectId) {
+        return path3;
+      }
+    }
+    return null;
+  }
+};
+var projectService = new ProjectServiceImpl();
+
+// src/daemon/queue.ts
+var CommitQueueProcessor = class {
+  queue = [];
+  isProcessing = false;
+  /**
+   * Add commit to processing queue
+   */
+  addToQueue(commit, project) {
+    this.queue.push({ commit, project });
+    logger.info("queue", `Added commit ${commit.id} to queue (position: ${this.queue.length})`);
+    if (!this.isProcessing) {
+      this.processQueue();
+    }
+  }
+  /**
+   * Process commits sequentially
+   */
+  async processQueue() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    while (this.queue.length > 0) {
+      const item = this.queue.shift();
+      if (!item) break;
+      try {
+        await this.executeCommit(item.commit, item.project);
+      } catch (error) {
+        logger.error("queue", `Failed to execute commit ${item.commit.id}`, error);
+      }
+    }
+    this.isProcessing = false;
+  }
+  /**
+   * Execute a single commit
+   */
+  async executeCommit(commit, project) {
+    logger.info("queue", `Processing commit: ${commit.id} - ${commit.message}`);
+    try {
+      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}`);
+      const isRepo = await gitService.isRepo(projectPath);
+      if (!isRepo) {
+        throw new Error(`Directory ${projectPath} is not a git repository`);
+      }
+      const status = await gitService.getStatus(projectPath);
+      const hasChanges = status.staged.length > 0 || status.unstaged.length > 0 || status.untracked.length > 0;
+      if (hasChanges) {
+        throw new Error("Repository has uncommitted changes. Please commit or stash them first.");
+      }
+      if (commit.files && commit.files.length > 0) {
+        logger.info("queue", `Staging specific files: ${commit.files.join(", ")}`);
+        await gitService.stageFiles(projectPath, commit.files);
+      } else {
+        logger.info("queue", "Staging all changes");
+        await gitService.stageAll(projectPath);
+      }
+      logger.info("queue", `Creating commit with message: "${commit.message}"`);
+      const sha = await gitService.commit(projectPath, commit.message);
+      logger.success("queue", `Commit created successfully: ${sha}`);
+      await this.reportSuccess(commit.id, sha);
+      return sha;
+    } catch (error) {
+      const errorMessage = error.message;
+      logger.error("queue", `Commit execution failed: ${errorMessage}`);
+      await this.reportFailure(commit.id, errorMessage);
+      throw error;
+    }
+  }
+  /**
+   * Report successful execution to API
+   */
+  async reportSuccess(commitId, sha) {
+    try {
+      await apiService.markCommitExecuted(commitId, sha);
+      logger.success("queue", `Reported commit execution to API: ${commitId} -> ${sha}`);
+    } catch (error) {
+      logger.error("queue", "Failed to report commit success to API", error);
+    }
+  }
+  /**
+   * Report failed execution to API
+   */
+  async reportFailure(commitId, error) {
+    try {
+      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);
+    }
+  }
+  /**
+   * Find local path for a project ID
+   */
+  findProjectPath(projectId) {
+    const allProjects = projectService.getAllLinkedProjects();
+    for (const [path3, linkedProject] of Object.entries(allProjects)) {
+      if (linkedProject.projectId === projectId) {
+        return path3;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if queue is currently processing
+   */
+  isCurrentlyProcessing() {
+    return this.isProcessing;
+  }
+  /**
+   * Get queue length
+   */
+  getQueueLength() {
+    return this.queue.length;
+  }
+};
+var commitQueue = new CommitQueueProcessor();
+
+export {
+  gitService,
+  projectService,
+  isProcessRunning,
+  killProcess,
+  spawnDetached,
+  writePidFile,
+  removePidFile,
+  validatePidFile,
+  getPidFilePath,
+  commitQueue
+};