@adhdev/daemon-standalone 0.9.81-rc.1 → 0.9.81

package/dist/index.js

@@ -22155,6 +22155,217 @@ var require_dist2 = __commonJS({
         };
       }
     });
+    var git_executor_exports = {};
+    __export2(git_executor_exports, {
+      GitCommandError: () => GitCommandError,
+      isPathInside: () => isPathInside,
+      normalizeGitOutput: () => normalizeGitOutput,
+      resolveGitRepository: () => resolveGitRepository,
+      runGit: () => runGit
+    });
+    async function resolveGitRepository(workspace, options = {}) {
+      const normalizedWorkspace = await validateWorkspace(workspace);
+      const result = await execGitRaw(normalizedWorkspace, ["rev-parse", "--show-toplevel"], options, {
+        mapNotGitRepo: true
+      });
+      const repoRoot = path5.resolve(result.stdout.trim());
+      if (!repoRoot) {
+        throw new GitCommandError("not_git_repo", "Git did not return a repository root", {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          argv: ["rev-parse", "--show-toplevel"],
+          cwd: normalizedWorkspace
+        });
+      }
+      return {
+        workspace: normalizedWorkspace,
+        repoRoot,
+        isGitRepo: true
+      };
+    }
+    async function runGit(repoOrWorkspace, argv, options = {}) {
+      validateGitArgv(argv);
+      const repo = typeof repoOrWorkspace === "string" ? await resolveGitRepository(repoOrWorkspace, options) : repoOrWorkspace;
+      if (!repo.repoRoot || !repo.isGitRepo) {
+        throw new GitCommandError("not_git_repo", "Workspace is not a Git repository", {
+          argv,
+          cwd: repo.workspace
+        });
+      }
+      const cwd = options.cwd ? await validateWorkspace(options.cwd) : await validateWorkspace(repo.workspace);
+      const canonicalRepoRoot = await (0, import_promises.realpath)(repo.repoRoot);
+      const canonicalCwd = await (0, import_promises.realpath)(cwd);
+      if (!isPathInside(canonicalRepoRoot, canonicalCwd)) {
+        throw new GitCommandError("path_outside_repo", "Git cwd is outside the repository root", {
+          argv,
+          cwd
+        });
+      }
+      return execGitRaw(cwd, argv, options);
+    }
+    function normalizeGitOutput(value) {
+      if (typeof value === "string") return value.replace(/\r\n/g, "\n");
+      if (Buffer.isBuffer(value)) return value.toString("utf8").replace(/\r\n/g, "\n");
+      if (value == null) return "";
+      return String(value).replace(/\r\n/g, "\n");
+    }
+    function isPathInside(parent, child) {
+      const relative3 = path5.relative(path5.resolve(parent), path5.resolve(child));
+      return relative3 === "" || !relative3.startsWith("..") && !path5.isAbsolute(relative3);
+    }
+    async function validateWorkspace(workspace) {
+      if (typeof workspace !== "string" || workspace.length === 0 || workspace.includes("\0")) {
+        throw new GitCommandError("invalid_args", "Workspace must be a non-empty path");
+      }
+      if (!path5.isAbsolute(workspace)) {
+        throw new GitCommandError("invalid_args", "Workspace must be an absolute path", { cwd: workspace });
+      }
+      const normalizedWorkspace = path5.resolve(workspace);
+      try {
+        const info = await (0, import_promises.stat)(normalizedWorkspace);
+        if (!info.isDirectory()) {
+          throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
+            cwd: normalizedWorkspace
+          });
+        }
+        await (0, import_promises.access)(normalizedWorkspace, import_node_fs.constants.R_OK);
+      } catch (error48) {
+        if (error48 instanceof GitCommandError) throw error48;
+        throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
+          cwd: normalizedWorkspace,
+          cause: error48
+        });
+      }
+      return normalizedWorkspace;
+    }
+    function validateGitArgv(argv) {
+      if (!Array.isArray(argv) || argv.length === 0) {
+        throw new GitCommandError("invalid_args", "Git argv must be a non-empty string array", { argv });
+      }
+      for (const arg of argv) {
+        if (typeof arg !== "string" || arg.length === 0 || arg.includes("\0")) {
+          throw new GitCommandError("invalid_args", "Git argv contains an invalid argument", { argv });
+        }
+      }
+      if (argv.includes("-C") || argv.some((arg) => arg.startsWith("--git-dir") || arg.startsWith("--work-tree"))) {
+        throw new GitCommandError("invalid_args", "Git argv contains unsafe repository override arguments", {
+          argv
+        });
+      }
+    }
+    async function execGitRaw(cwd, argv, options, behavior = {}) {
+      validateGitArgv(argv);
+      try {
+        const result = await execFileAsync("git", [...argv], {
+          cwd,
+          encoding: "utf8",
+          timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+          maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
+          windowsHide: true
+        });
+        return {
+          stdout: normalizeGitOutput(result.stdout),
+          stderr: normalizeGitOutput(result.stderr)
+        };
+      } catch (error48) {
+        throw mapExecError(error48, cwd, argv, behavior);
+      }
+    }
+    function mapExecError(error48, cwd, argv, behavior) {
+      const execError = error48;
+      const stdout = normalizeGitOutput(execError.stdout);
+      const stderr = normalizeGitOutput(execError.stderr);
+      const code = execError.code;
+      const signal = execError.signal;
+      const message = [stderr.trim(), execError.message].filter(Boolean).join("\n");
+      if (code === "ENOENT") {
+        return new GitCommandError("git_not_installed", "Git executable was not found", {
+          stdout,
+          stderr,
+          exitCode: code,
+          signal,
+          argv,
+          cwd,
+          cause: error48
+        });
+      }
+      if (execError.killed || /timed out/i.test(execError.message)) {
+        return new GitCommandError("timeout", "Git command timed out", {
+          stdout,
+          stderr,
+          exitCode: code,
+          signal,
+          argv,
+          cwd,
+          cause: error48
+        });
+      }
+      if (behavior.mapNotGitRepo && /not a git repository/i.test(stderr + "\n" + execError.message)) {
+        return new GitCommandError("not_git_repo", "Workspace is not a Git repository", {
+          stdout,
+          stderr,
+          exitCode: code,
+          signal,
+          argv,
+          cwd,
+          cause: error48
+        });
+      }
+      return new GitCommandError("git_command_failed", message || "Git command failed", {
+        stdout,
+        stderr,
+        exitCode: code,
+        signal,
+        argv,
+        cwd,
+        cause: error48
+      });
+    }
+    var import_node_child_process;
+    var import_node_fs;
+    var import_promises;
+    var path5;
+    var import_node_util;
+    var execFileAsync;
+    var DEFAULT_TIMEOUT_MS;
+    var DEFAULT_MAX_BUFFER;
+    var GitCommandError;
+    var init_git_executor = __esm2({
+      "src/git/git-executor.ts"() {
+        "use strict";
+        import_node_child_process = require("child_process");
+        import_node_fs = require("fs");
+        import_promises = require("fs/promises");
+        path5 = __toESM2(require("path"));
+        import_node_util = require("util");
+        execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+        DEFAULT_TIMEOUT_MS = 5e3;
+        DEFAULT_MAX_BUFFER = 1024 * 1024;
+        GitCommandError = class extends Error {
+          reason;
+          stdout;
+          stderr;
+          exitCode;
+          signal;
+          argv;
+          cwd;
+          constructor(reason, message, details = {}) {
+            super(message);
+            if (details.cause !== void 0) {
+              this.cause = details.cause;
+            }
+            this.name = "GitCommandError";
+            this.reason = reason;
+            this.stdout = normalizeGitOutput(details.stdout);
+            this.stderr = normalizeGitOutput(details.stderr);
+            this.exitCode = details.exitCode;
+            this.signal = details.signal;
+            this.argv = details.argv ? [...details.argv] : void 0;
+            this.cwd = details.cwd;
+          }
+        };
+      }
+    });
     var git_worktree_exports = {};
     __export2(git_worktree_exports, {
       createWorktree: () => createWorktree,
@@ -27844,203 +28055,21 @@ ${lastSnapshot}`;
     });
     module2.exports = __toCommonJS2(index_exports);
     init_repo_mesh_types();
-    var import_node_child_process = require("child_process");
-    var import_node_fs = require("fs");
-    var import_promises = require("fs/promises");
-    var path5 = __toESM2(require("path"));
-    var import_node_util = require("util");
-    var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
-    var DEFAULT_TIMEOUT_MS = 5e3;
-    var DEFAULT_MAX_BUFFER = 1024 * 1024;
-    var GitCommandError = class extends Error {
-      reason;
-      stdout;
-      stderr;
-      exitCode;
-      signal;
-      argv;
-      cwd;
-      constructor(reason, message, details = {}) {
-        super(message);
-        if (details.cause !== void 0) {
-          this.cause = details.cause;
-        }
-        this.name = "GitCommandError";
-        this.reason = reason;
-        this.stdout = normalizeGitOutput(details.stdout);
-        this.stderr = normalizeGitOutput(details.stderr);
-        this.exitCode = details.exitCode;
-        this.signal = details.signal;
-        this.argv = details.argv ? [...details.argv] : void 0;
-        this.cwd = details.cwd;
-      }
-    };
-    async function resolveGitRepository(workspace, options = {}) {
-      const normalizedWorkspace = await validateWorkspace(workspace);
-      const result = await execGitRaw(normalizedWorkspace, ["rev-parse", "--show-toplevel"], options, {
-        mapNotGitRepo: true
-      });
-      const repoRoot = path5.resolve(result.stdout.trim());
-      if (!repoRoot) {
-        throw new GitCommandError("not_git_repo", "Git did not return a repository root", {
-          stdout: result.stdout,
-          stderr: result.stderr,
-          argv: ["rev-parse", "--show-toplevel"],
-          cwd: normalizedWorkspace
-        });
-      }
-      return {
-        workspace: normalizedWorkspace,
-        repoRoot,
-        isGitRepo: true
-      };
-    }
-    async function runGit(repoOrWorkspace, argv, options = {}) {
-      validateGitArgv(argv);
-      const repo = typeof repoOrWorkspace === "string" ? await resolveGitRepository(repoOrWorkspace, options) : repoOrWorkspace;
-      if (!repo.repoRoot || !repo.isGitRepo) {
-        throw new GitCommandError("not_git_repo", "Workspace is not a Git repository", {
-          argv,
-          cwd: repo.workspace
-        });
-      }
-      const cwd = options.cwd ? await validateWorkspace(options.cwd) : await validateWorkspace(repo.workspace);
-      const canonicalRepoRoot = await (0, import_promises.realpath)(repo.repoRoot);
-      const canonicalCwd = await (0, import_promises.realpath)(cwd);
-      if (!isPathInside(canonicalRepoRoot, canonicalCwd)) {
-        throw new GitCommandError("path_outside_repo", "Git cwd is outside the repository root", {
-          argv,
-          cwd
-        });
-      }
-      return execGitRaw(cwd, argv, options);
-    }
-    function normalizeGitOutput(value) {
-      if (typeof value === "string") return value.replace(/\r\n/g, "\n");
-      if (Buffer.isBuffer(value)) return value.toString("utf8").replace(/\r\n/g, "\n");
-      if (value == null) return "";
-      return String(value).replace(/\r\n/g, "\n");
-    }
-    function isPathInside(parent, child) {
-      const relative3 = path5.relative(path5.resolve(parent), path5.resolve(child));
-      return relative3 === "" || !relative3.startsWith("..") && !path5.isAbsolute(relative3);
-    }
-    async function validateWorkspace(workspace) {
-      if (typeof workspace !== "string" || workspace.length === 0 || workspace.includes("\0")) {
-        throw new GitCommandError("invalid_args", "Workspace must be a non-empty path");
-      }
-      if (!path5.isAbsolute(workspace)) {
-        throw new GitCommandError("invalid_args", "Workspace must be an absolute path", { cwd: workspace });
-      }
-      const normalizedWorkspace = path5.resolve(workspace);
-      try {
-        const info = await (0, import_promises.stat)(normalizedWorkspace);
-        if (!info.isDirectory()) {
-          throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
-            cwd: normalizedWorkspace
-          });
-        }
-        await (0, import_promises.access)(normalizedWorkspace, import_node_fs.constants.R_OK);
-      } catch (error48) {
-        if (error48 instanceof GitCommandError) throw error48;
-        throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
-          cwd: normalizedWorkspace,
-          cause: error48
-        });
-      }
-      return normalizedWorkspace;
-    }
-    function validateGitArgv(argv) {
-      if (!Array.isArray(argv) || argv.length === 0) {
-        throw new GitCommandError("invalid_args", "Git argv must be a non-empty string array", { argv });
-      }
-      for (const arg of argv) {
-        if (typeof arg !== "string" || arg.length === 0 || arg.includes("\0")) {
-          throw new GitCommandError("invalid_args", "Git argv contains an invalid argument", { argv });
-        }
-      }
-      if (argv.includes("-C") || argv.some((arg) => arg.startsWith("--git-dir") || arg.startsWith("--work-tree"))) {
-        throw new GitCommandError("invalid_args", "Git argv contains unsafe repository override arguments", {
-          argv
-        });
-      }
-    }
-    async function execGitRaw(cwd, argv, options, behavior = {}) {
-      validateGitArgv(argv);
-      try {
-        const result = await execFileAsync("git", [...argv], {
-          cwd,
-          encoding: "utf8",
-          timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-          maxBuffer: options.maxBuffer ?? DEFAULT_MAX_BUFFER,
-          windowsHide: true
-        });
-        return {
-          stdout: normalizeGitOutput(result.stdout),
-          stderr: normalizeGitOutput(result.stderr)
-        };
-      } catch (error48) {
-        throw mapExecError(error48, cwd, argv, behavior);
-      }
-    }
-    function mapExecError(error48, cwd, argv, behavior) {
-      const execError = error48;
-      const stdout = normalizeGitOutput(execError.stdout);
-      const stderr = normalizeGitOutput(execError.stderr);
-      const code = execError.code;
-      const signal = execError.signal;
-      const message = [stderr.trim(), execError.message].filter(Boolean).join("\n");
-      if (code === "ENOENT") {
-        return new GitCommandError("git_not_installed", "Git executable was not found", {
-          stdout,
-          stderr,
-          exitCode: code,
-          signal,
-          argv,
-          cwd,
-          cause: error48
-        });
-      }
-      if (execError.killed || /timed out/i.test(execError.message)) {
-        return new GitCommandError("timeout", "Git command timed out", {
-          stdout,
-          stderr,
-          exitCode: code,
-          signal,
-          argv,
-          cwd,
-          cause: error48
-        });
-      }
-      if (behavior.mapNotGitRepo && /not a git repository/i.test(stderr + "\n" + execError.message)) {
-        return new GitCommandError("not_git_repo", "Workspace is not a Git repository", {
-          stdout,
-          stderr,
-          exitCode: code,
-          signal,
-          argv,
-          cwd,
-          cause: error48
-        });
-      }
-      return new GitCommandError("git_command_failed", message || "Git command failed", {
-        stdout,
-        stderr,
-        exitCode: code,
-        signal,
-        argv,
-        cwd,
-        cause: error48
-      });
-    }
+    init_git_executor();
+    init_git_executor();
     async function getGitRepoStatus(workspace, options = {}) {
       const lastCheckedAt = Date.now();
+      const includeSubmodules = options.includeSubmodules !== false;
       try {
         const repo = await resolveGitRepository(workspace, options);
         const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
         const parsed = parsePorcelainV2Status(statusOutput.stdout);
         const head = await readHead(repo, options);
         const stashCount = await readStashCount(repo, options);
+        let submodules;
+        if (includeSubmodules) {
+          submodules = await getSubmoduleStatuses(repo, options);
+        }
         return {
           workspace: repo.workspace,
           repoRoot: repo.repoRoot,
@@ -28059,7 +28088,8 @@ ${lastSnapshot}`;
           hasConflicts: parsed.conflictFiles.length > 0,
           conflictFiles: parsed.conflictFiles,
           stashCount,
-          lastCheckedAt
+          lastCheckedAt,
+          submodules
         };
       } catch (error48) {
         if (error48 instanceof GitCommandError) {
@@ -28181,8 +28211,40 @@ ${lastSnapshot}`;
         reason: error48.reason
       };
     }
+    async function getSubmoduleStatuses(repo, options) {
+      if (!repo.repoRoot) return [];
+      try {
+        const result = await runGit(repo, ["submodule", "status", "--recursive"], options);
+        return parseSubmoduleStatusOutput(result.stdout, repo.repoRoot, options.submoduleIgnorePaths);
+      } catch {
+        return [];
+      }
+    }
+    function parseSubmoduleStatusOutput(output, repoRoot, ignorePaths) {
+      const submodules = [];
+      const ignoreSet = new Set(ignorePaths || []);
+      for (const line of output.split("\n")) {
+        if (!line.trim()) continue;
+        const match = line.match(/^([\-+\s])([0-9a-f]{40})\s+(\S+)(?:\s+\(([^)]+)\))?/);
+        if (!match) continue;
+        const prefix = match[1];
+        const commit = match[2];
+        const path28 = match[3];
+        if (ignoreSet.has(path28)) continue;
+        submodules.push({
+          path: path28,
+          commit,
+          repoPath: repoRoot + "/" + path28,
+          dirty: prefix === "+",
+          outOfSync: prefix === "-",
+          lastCheckedAt: Date.now()
+        });
+      }
+      return submodules;
+    }
     var import_promises2 = require("fs/promises");
     var path23 = __toESM2(require("path"));
+    init_git_executor();
     var DEFAULT_MAX_FILES = 200;
     var DEFAULT_MAX_BYTES = 2e5;
     async function getGitDiffSummary(workspace, options = {}) {
@@ -28703,6 +28765,7 @@ ${lastSnapshot}`;
       return new GitWorkspaceMonitor(options);
     }
     var path32 = __toESM2(require("path"));
+    init_git_executor();
     var GIT_COMMAND_NAMES = /* @__PURE__ */ new Set([
       "git_status",
       "git_diff_summary",
@@ -47579,12 +47642,25 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 });
                 if (!node) return { success: false, error: "Failed to register worktree node" };
               }
+              const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
+              if (initSubmodules) {
+                try {
+                  const { runGit: runGit2 } = await Promise.resolve().then(() => (init_git_executor(), git_executor_exports));
+                  await runGit2(
+                    { workspace: result.worktreePath, repoRoot: result.worktreePath, isGitRepo: true },
+                    ["submodule", "update", "--init", "--recursive"],
+                    { timeoutMs: 12e4 }
+                  );
+                } catch (subErr) {
+                  console.warn("[mesh] Submodule init failed for worktree:", subErr.message);
+                }
+              }
               try {
                 const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
                 appendLedgerEntry2(meshId, {
                   kind: "node_cloned",
                   nodeId: node.id,
-                  payload: { sourceNodeId, branch: result.branch, worktreePath: result.worktreePath }
+                  payload: { sourceNodeId, branch: result.branch, worktreePath: result.worktreePath, submodulesInitialized: initSubmodules }
                 });
               } catch {
               }