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

package/dist/git/git-status.d.ts

@@ -1,6 +1,10 @@
 import type { GitRepoStatus } from './git-types.js';
 export interface GitStatusOptions {
     timeoutMs?: number;
+    /** When true, include submodule status in the result. Defaults to true. */
+    includeSubmodules?: boolean;
+    /** Optional filter to exclude specific submodule paths from status */
+    submoduleIgnorePaths?: string[];
 }
 export declare function getGitRepoStatus(workspace: string, options?: GitStatusOptions): Promise<GitRepoStatus>;
 interface ParsedPorcelainStatus {

package/dist/git/git-types.d.ts

@@ -11,6 +11,22 @@ export interface GitRepoIdentity {
     repoRoot: string | null;
     isGitRepo: boolean;
 }
+export interface GitSubmoduleStatus {
+    /** Submodule path relative to repo root */
+    path: string;
+    /** Current commit SHA the submodule is at */
+    commit: string;
+    /** Path to the submodule repo (absolute) */
+    repoPath: string;
+    /** Whether the submodule has uncommitted changes */
+    dirty: boolean;
+    /** Whether the submodule commit differs from what the parent repo expects */
+    outOfSync: boolean;
+    /** Last checked timestamp */
+    lastCheckedAt: number;
+    /** Error message if submodule status could not be read */
+    error?: string;
+}
 export interface GitRepoStatus extends GitRepoIdentity {
     branch: string | null;
     headCommit: string | null;
@@ -27,6 +43,8 @@ export interface GitRepoStatus extends GitRepoIdentity {
     conflictFiles: string[];
     stashCount: number;
     lastCheckedAt: number;
+    /** Submodule statuses when auto-discover is enabled */
+    submodules?: GitSubmoduleStatus[];
     error?: string;
     reason?: GitFailureReason;
 }

package/dist/index.js

@@ -49,6 +49,211 @@ var init_repo_mesh_types = __esm({
   }
 });
 
+// src/git/git-executor.ts
+var git_executor_exports = {};
+__export(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 = path.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 = path.relative(path.resolve(parent), path.resolve(child));
+  return relative3 === "" || !relative3.startsWith("..") && !path.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 (!path.isAbsolute(workspace)) {
+    throw new GitCommandError("invalid_args", "Workspace must be an absolute path", { cwd: workspace });
+  }
+  const normalizedWorkspace = path.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 (error) {
+    if (error instanceof GitCommandError) throw error;
+    throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
+      cwd: normalizedWorkspace,
+      cause: error
+    });
+  }
+  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 (error) {
+    throw mapExecError(error, cwd, argv, behavior);
+  }
+}
+function mapExecError(error, cwd, argv, behavior) {
+  const execError = error;
+  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: error
+    });
+  }
+  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: error
+    });
+  }
+  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: error
+    });
+  }
+  return new GitCommandError("git_command_failed", message || "Git command failed", {
+    stdout,
+    stderr,
+    exitCode: code,
+    signal,
+    argv,
+    cwd,
+    cause: error
+  });
+}
+var import_node_child_process, import_node_fs, import_promises, path, import_node_util, execFileAsync, DEFAULT_TIMEOUT_MS, DEFAULT_MAX_BUFFER, GitCommandError;
+var init_git_executor = __esm({
+  "src/git/git-executor.ts"() {
+    "use strict";
+    import_node_child_process = require("child_process");
+    import_node_fs = require("fs");
+    import_promises = require("fs/promises");
+    path = __toESM(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;
+      }
+    };
+  }
+});
+
 // src/git/git-worktree.ts
 var git_worktree_exports = {};
 __export(git_worktree_exports, {
@@ -5698,206 +5903,24 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 init_repo_mesh_types();
 
-// src/git/git-executor.ts
-var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
-var import_promises = require("fs/promises");
-var path = __toESM(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 = path.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 = path.relative(path.resolve(parent), path.resolve(child));
-  return relative3 === "" || !relative3.startsWith("..") && !path.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 (!path.isAbsolute(workspace)) {
-    throw new GitCommandError("invalid_args", "Workspace must be an absolute path", { cwd: workspace });
-  }
-  const normalizedWorkspace = path.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 (error) {
-    if (error instanceof GitCommandError) throw error;
-    throw new GitCommandError("invalid_args", "Workspace must be an existing directory", {
-      cwd: normalizedWorkspace,
-      cause: error
-    });
-  }
-  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 (error) {
-    throw mapExecError(error, cwd, argv, behavior);
-  }
-}
-function mapExecError(error, cwd, argv, behavior) {
-  const execError = error;
-  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: error
-    });
-  }
-  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: error
-    });
-  }
-  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: error
-    });
-  }
-  return new GitCommandError("git_command_failed", message || "Git command failed", {
-    stdout,
-    stderr,
-    exitCode: code,
-    signal,
-    argv,
-    cwd,
-    cause: error
-  });
-}
+// src/git/index.ts
+init_git_executor();
 
 // src/git/git-status.ts
+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,
@@ -5916,7 +5939,8 @@ async function getGitRepoStatus(workspace, options = {}) {
       hasConflicts: parsed.conflictFiles.length > 0,
       conflictFiles: parsed.conflictFiles,
       stashCount,
-      lastCheckedAt
+      lastCheckedAt,
+      submodules
     };
   } catch (error) {
     if (error instanceof GitCommandError) {
@@ -6038,10 +6062,42 @@ function emptyStatus(workspace, lastCheckedAt, error) {
     reason: error.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;
+}
 
 // src/git/git-diff.ts
 var import_promises2 = require("fs/promises");
 var path2 = __toESM(require("path"));
+init_git_executor();
 var DEFAULT_MAX_FILES = 200;
 var DEFAULT_MAX_BYTES = 2e5;
 async function getGitDiffSummary(workspace, options = {}) {
@@ -6570,6 +6626,7 @@ function createGitWorkspaceMonitor(options = {}) {
 
 // src/git/git-commands.ts
 var path3 = __toESM(require("path"));
+init_git_executor();
 var GIT_COMMAND_NAMES = /* @__PURE__ */ new Set([
   "git_status",
   "git_diff_summary",
@@ -25608,12 +25665,25 @@ var DaemonCommandRouter = class {
             });
             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 {
           }