adhdev 0.9.54 → 0.9.55

package/dist/cli/index.js

@@ -1483,7 +1483,12 @@ function createDefaultGitCommandServices() {
       turnId
     }),
     compareSnapshots: ({ beforeSnapshotId, afterSnapshotId }) => defaultSnapshotStore.compare(beforeSnapshotId, afterSnapshotId),
-    getLog: ({ workspace, limit, path: filePath, since, until }) => getGitLog(workspace, { limit, path: filePath, since, until })
+    getLog: ({ workspace, limit, path: filePath, since, until }) => getGitLog(workspace, { limit, path: filePath, since, until }),
+    checkpoint: async ({ workspace, message, includeUntracked = false }) => gitCheckpoint(workspace, message, includeUntracked),
+    stashPush: async ({ workspace, message, includeUntracked = false }) => gitStashPush(workspace, message, includeUntracked),
+    stashPop: async ({ workspace, stashRef }) => gitStashPop(workspace, stashRef),
+    checkoutFiles: async ({ workspace, paths }) => gitCheckoutFiles(workspace, paths),
+    getRemoteUrl: async ({ workspace, remote = "origin" }) => gitGetRemoteUrl(workspace, remote)
   };
 }
 function validateWorkspace2(args) {
@@ -1546,9 +1551,6 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
   if (!isGitCommandName(command)) {
     return failure("invalid_args", `Unknown Git command: ${command}`);
   }
-  if (MUTATING_COMMAND_NAMES.has(command)) {
-    return failure("invalid_args", `${command} is not implemented in daemon-core read-only Git routing`);
-  }
   const workspaceResult = validateWorkspace2(args);
   if ("success" in workspaceResult) return workspaceResult;
   const { workspace } = workspaceResult;
@@ -1608,10 +1610,153 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
       }));
       return "success" in log2 ? log2 : { success: true, log: log2 };
     }
+    case "git_checkpoint": {
+      if (!services.checkpoint) return serviceNotImplemented(command);
+      const msg = validateMutatingMessage(args?.message);
+      if (typeof msg !== "string") return msg;
+      const includeUntracked = Boolean(args?.includeUntracked);
+      const checkpoint = await runService(() => services.checkpoint({ workspace, message: msg, includeUntracked }));
+      return "success" in checkpoint ? checkpoint : { success: true, checkpoint };
+    }
+    case "git_stash_push": {
+      if (!services.stashPush) return serviceNotImplemented(command);
+      const msg = validateMutatingMessage(args?.message);
+      if (typeof msg !== "string") return msg;
+      const includeUntracked = Boolean(args?.includeUntracked);
+      const stash = await runService(() => services.stashPush({ workspace, message: msg, includeUntracked }));
+      return "success" in stash ? stash : { success: true, stash };
+    }
+    case "git_stash_pop": {
+      if (!services.stashPop) return serviceNotImplemented(command);
+      const stashRef = optionalString(args?.stashRef);
+      if (stashRef !== void 0 && !/^stash@\{\d+\}$/.test(stashRef)) {
+        return failure("invalid_args", "stashRef must match stash@{N} format");
+      }
+      const popResult = await runService(() => services.stashPop({ workspace, stashRef }));
+      if (popResult !== void 0 && "success" in popResult) return popResult;
+      return { success: true, stashPopped: true };
+    }
+    case "git_checkout_files": {
+      if (!services.checkoutFiles) return serviceNotImplemented(command);
+      const paths = args?.paths;
+      if (!Array.isArray(paths) || paths.length === 0) {
+        return failure("invalid_args", "paths must be a non-empty array");
+      }
+      if (paths.length > 50) {
+        return failure("invalid_args", "paths array exceeds maximum of 50 entries");
+      }
+      const checkoutResult = await runService(() => services.checkoutFiles({ workspace, paths }));
+      return "success" in checkoutResult ? checkoutResult : { success: true, checkedOut: checkoutResult.checkedOut };
+    }
+    case "git_remote_url": {
+      if (!services.getRemoteUrl) return serviceNotImplemented(command);
+      const remote = typeof args?.remote === "string" && args.remote.trim() ? args.remote.trim() : "origin";
+      const remoteResult = await runService(() => services.getRemoteUrl({ workspace, remote }));
+      if ("success" in remoteResult) return remoteResult;
+      return { success: true, remoteUrl: remoteResult.remoteUrl, remote: remoteResult.remote };
+    }
     default:
       return failure("invalid_args", `Unknown Git command: ${command}`);
   }
 }
+function validateMutatingMessage(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return failure("invalid_args", "message must be a non-empty string");
+  }
+  const msg = value.trim();
+  if (msg.length > 200) {
+    return failure("invalid_args", "message must be 200 characters or fewer");
+  }
+  return msg;
+}
+async function gitCheckpoint(workspace, message, includeUntracked) {
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot;
+  const statusResult = await getGitRepoStatus(workspace);
+  if (statusResult.hasConflicts) {
+    throw new GitCommandError("conflict", "Repository has conflicts \u2014 resolve before checkpointing");
+  }
+  const addArgs = includeUntracked ? ["-A"] : ["-u"];
+  await runGit(repo, ["add", ...addArgs], { cwd: repoRoot });
+  const fullMsg = `adhdev: checkpoint ${message}`;
+  let commitSha;
+  try {
+    await runGit(repo, ["commit", "-m", fullMsg], { cwd: repoRoot });
+    const revResult = await runGit(repo, ["rev-parse", "HEAD"], { cwd: repoRoot });
+    commitSha = revResult.stdout.trim();
+  } catch (err) {
+    const output = (err?.stdout || "") + (err?.stderr || "");
+    if (/nothing to commit/i.test(output)) {
+      throw new GitCommandError("git_command_failed", "Nothing to commit");
+    }
+    throw err;
+  }
+  return {
+    workspace: repo.workspace,
+    repoRoot,
+    isGitRepo: true,
+    commit: commitSha,
+    message: fullMsg,
+    lastCheckedAt: Date.now()
+  };
+}
+async function gitStashPush(workspace, message, includeUntracked) {
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot;
+  const stashArgs = ["stash", "push", "-m", message];
+  if (includeUntracked) stashArgs.push("--include-untracked");
+  const result = await runGit(repo, stashArgs, { cwd: repoRoot });
+  if (/No local changes to save/i.test(result.stdout + result.stderr)) {
+    throw new GitCommandError("git_command_failed", "Nothing to stash");
+  }
+  return {
+    workspace: repo.workspace,
+    repoRoot,
+    isGitRepo: true,
+    stashRef: "stash@{0}",
+    message,
+    lastCheckedAt: Date.now()
+  };
+}
+async function gitStashPop(workspace, stashRef) {
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot;
+  const popArgs = stashRef ? ["stash", "pop", stashRef] : ["stash", "pop"];
+  await runGit(repo, popArgs, { cwd: repoRoot });
+}
+async function gitCheckoutFiles(workspace, paths) {
+  const repo = await resolveGitRepository(workspace);
+  const repoRoot = repo.repoRoot;
+  const normalizedPaths = [];
+  for (const p of paths) {
+    if (typeof p !== "string" || !p.trim() || p.includes("\0")) {
+      throw new GitCommandError("invalid_args", `Invalid path: ${String(p)}`);
+    }
+    if (path3.isAbsolute(p)) {
+      throw new GitCommandError("invalid_args", `Path must be repository-relative, not absolute: ${p}`);
+    }
+    const normalized = path3.normalize(p.trim()).split(path3.sep).join("/");
+    if (normalized.startsWith("../") || normalized === "..") {
+      throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
+    }
+    const absolutePath = path3.resolve(repoRoot, normalized);
+    if (!isPathInside(repoRoot, absolutePath)) {
+      throw new GitCommandError("path_outside_repo", `Path is outside repository root: ${p}`);
+    }
+    normalizedPaths.push(normalized);
+  }
+  await runGit(repo, ["checkout", "--", ...normalizedPaths], { cwd: repoRoot });
+  return { checkedOut: normalizedPaths };
+}
+async function gitGetRemoteUrl(workspace, remote) {
+  const repo = await resolveGitRepository(workspace);
+  const result = await runGit(repo, ["remote", "get-url", remote], { cwd: repo.repoRoot });
+  const remoteUrl = result.stdout.trim();
+  if (!remoteUrl) {
+    throw new GitCommandError("git_command_failed", `Remote '${remote}' has no URL`);
+  }
+  return { remoteUrl, remote };
+}
 function formatOptionalGitLogRangeArg(flag, value) {
   return value ? [`${flag}=${value}`] : [];
 }
@@ -1669,7 +1814,7 @@ function validateGitLogPath(repoRoot, filePath) {
   }
   return normalized;
 }
-var path3, GIT_COMMAND_NAMES, MUTATING_COMMAND_NAMES, SNAPSHOT_REASONS, FAILURE_REASONS, defaultSnapshotStore, defaultGitCommandServices;
+var path3, GIT_COMMAND_NAMES, SNAPSHOT_REASONS, FAILURE_REASONS, defaultSnapshotStore, defaultGitCommandServices;
 var init_git_commands = __esm({
   "../../oss/packages/daemon-core/src/git/git-commands.ts"() {
     "use strict";
@@ -1688,13 +1833,8 @@ var init_git_commands = __esm({
       "git_checkpoint",
       "git_stash_push",
       "git_stash_pop",
-      "git_checkout_files"
-    ]);
-    MUTATING_COMMAND_NAMES = /* @__PURE__ */ new Set([
-      "git_checkpoint",
-      "git_stash_push",
-      "git_stash_pop",
-      "git_checkout_files"
+      "git_checkout_files",
+      "git_remote_url"
     ]);
     SNAPSHOT_REASONS = /* @__PURE__ */ new Set([
       "session_baseline",
@@ -1721,6 +1861,33 @@ var init_git_commands = __esm({
   }
 });
 
+// ../../oss/packages/daemon-core/src/git/turn-snapshot-tracker.ts
+var BUSY_STATUSES, TERMINAL_STATUSES, TurnSnapshotTracker;
+var init_turn_snapshot_tracker = __esm({
+  "../../oss/packages/daemon-core/src/git/turn-snapshot-tracker.ts"() {
+    "use strict";
+    BUSY_STATUSES = /* @__PURE__ */ new Set(["streaming", "waiting_approval"]);
+    TERMINAL_STATUSES = /* @__PURE__ */ new Set(["idle", "error"]);
+    TurnSnapshotTracker = class {
+      lastStatus = /* @__PURE__ */ new Map();
+      onTurnCompleted;
+      constructor(onTurnCompleted) {
+        this.onTurnCompleted = onTurnCompleted;
+      }
+      record(sessionId, status, workspace) {
+        const prev = this.lastStatus.get(sessionId);
+        this.lastStatus.set(sessionId, status);
+        if (workspace && prev && BUSY_STATUSES.has(prev) && TERMINAL_STATUSES.has(status)) {
+          this.onTurnCompleted({ sessionId, workspace });
+        }
+      }
+      forget(sessionId) {
+        this.lastStatus.delete(sessionId);
+      }
+    };
+  }
+});
+
 // ../../oss/packages/daemon-core/src/git/index.ts
 var init_git = __esm({
   "../../oss/packages/daemon-core/src/git/index.ts"() {
@@ -1732,6 +1899,7 @@ var init_git = __esm({
     init_git_snapshot_store();
     init_git_monitor();
     init_git_commands();
+    init_turn_snapshot_tracker();
   }
 });
 
@@ -11887,6 +12055,16 @@ var init_handler = __esm({
             return result;
           }
         }
+        if (cmd === "send_chat" && this._ctx.onBeforeSendChat) {
+          const sessionId = this._currentRoute.session?.sessionId;
+          const workspace = sessionId ? this._ctx.instanceManager?.getInstance(sessionId)?.getState?.()?.workspace : void 0;
+          if (workspace && sessionId) {
+            try {
+              this._ctx.onBeforeSendChat({ workspace, sessionId });
+            } catch {
+            }
+          }
+        }
         try {
           result = await this.dispatch(cmd, args);
           this.logCommandEnd(cmd, result, startedAt);
@@ -14164,6 +14342,7 @@ function resolveCliAdapterConfig(provider) {
     sendDelayMs: typeof provider.sendDelayMs === "number" ? Math.max(0, provider.sendDelayMs) : 0,
     sendKey: typeof provider.sendKey === "string" && provider.sendKey.length > 0 ? provider.sendKey : "\r",
     submitStrategy: provider.submitStrategy === "immediate" ? "immediate" : "wait_for_echo",
+    requirePromptEchoBeforeSubmit: provider.requirePromptEchoBeforeSubmit === true,
     providerResolutionMeta: {
       type: provider.type,
       name: provider.name,
@@ -14429,6 +14608,7 @@ var init_provider_cli_adapter = __esm({
         this.sendDelayMs = resolvedConfig.sendDelayMs;
         this.sendKey = resolvedConfig.sendKey;
         this.submitStrategy = resolvedConfig.submitStrategy;
+        this.requirePromptEchoBeforeSubmit = resolvedConfig.requirePromptEchoBeforeSubmit;
         this.providerResolutionMeta = resolvedConfig.providerResolutionMeta;
         this.cliScripts = provider.scripts || {};
         const scriptNames = listCliScriptNames(this.cliScripts);
@@ -14725,6 +14905,7 @@ var init_provider_cli_adapter = __esm({
       sendDelayMs;
       sendKey;
       submitStrategy;
+      requirePromptEchoBeforeSubmit;
       static SCRIPT_STATUS_DEBOUNCE_MS = 3e3;
       /** Inject CLI scripts after construction (e.g. when resolved by ProviderLoader) */
       setCliScripts(scripts) {
@@ -16245,6 +16426,22 @@ var init_provider_cli_adapter = __esm({
           }
         }
         if (elapsed >= state.maxEchoWaitMs) {
+          const diagnostic = {
+            elapsed,
+            maxEchoWaitMs: state.maxEchoWaitMs,
+            submitDelayMs: state.submitDelayMs,
+            promptSnippet: state.normalizedPromptSnippet,
+            requirePromptEchoBeforeSubmit: this.requirePromptEchoBeforeSubmit,
+            screenText: summarizeCliTraceText(screenText, 1e3)
+          };
+          this.recordTrace("submit_echo_missing", diagnostic);
+          if (this.requirePromptEchoBeforeSubmit) {
+            const message = `${this.cliName} prompt echo was not observed on the PTY screen before submit`;
+            LOG.warn("CLI", `[${this.cliType}] ${message} elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs} screen=${JSON.stringify(diagnostic.screenText).slice(0, 240)}`);
+            completion.rejectOnce(new Error(message));
+            return;
+          }
+          LOG.warn("CLI", `[${this.cliType}] prompt echo was not observed before submit; sending submit key anyway elapsed=${elapsed}ms maxEchoWaitMs=${state.maxEchoWaitMs}`);
           this.submitSendKey(state, completion);
           return;
         }
@@ -16709,6 +16906,7 @@ var init_provider_cli_adapter = __esm({
           sendDelayMs: this.sendDelayMs,
           sendKey: this.sendKey,
           submitStrategy: this.submitStrategy,
+          requirePromptEchoBeforeSubmit: this.requirePromptEchoBeforeSubmit,
           submitPendingUntil: this.submitPendingUntil,
           responseSettleIgnoreUntil: this.responseSettleIgnoreUntil,
           resizeSuppressUntil: this.resizeSuppressUntil,
@@ -38009,6 +38207,7 @@ var init_provider_schema = __esm({
       "sendDelayMs",
       "sendKey",
       "submitStrategy",
+      "requirePromptEchoBeforeSubmit",
       "timeouts",
       "disableUpstream"
     ]);
@@ -49584,6 +49783,7 @@ async function initDaemonComponents(config2) {
     providerLoader,
     instanceManager,
     sessionRegistry,
+    gitCommandServices: createDefaultGitCommandServices(),
     onProviderSettingChanged: async (providerType) => {
       await refreshProviderAvailability(providerType);
       config2.onStatusChange?.();
@@ -49591,7 +49791,8 @@ async function initDaemonComponents(config2) {
     onProviderSourceConfigChanged: async () => {
       await refreshProviderAvailability();
       config2.onStatusChange?.();
-    }
+    },
+    onBeforeSendChat: config2.onBeforeSendChat
   });
   agentStreamManager = new DaemonAgentStreamManager(
     LOG.forComponent("AgentStream").asLogFn(),
@@ -49717,6 +49918,7 @@ var init_daemon_lifecycle = __esm({
     init_logger();
     init_runtime_defaults();
     init_config();
+    init_git_commands();
   }
 });
 
@@ -49767,6 +49969,7 @@ __export(src_exports, {
   ProviderLoader: () => ProviderLoader,
   STANDALONE_CDP_SCAN_INTERVAL_MS: () => STANDALONE_CDP_SCAN_INTERVAL_MS,
   SessionHostPtyTransportFactory: () => SessionHostPtyTransportFactory,
+  TurnSnapshotTracker: () => TurnSnapshotTracker,
   VersionArchive: () => VersionArchive,
   appendRecentActivity: () => appendRecentActivity,
   buildAssistantChatMessage: () => buildAssistantChatMessage,
@@ -89833,7 +90036,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.54" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.55" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -89857,6 +90060,19 @@ var init_adhdev_daemon = __esm({
       sessionHostEndpoint = null;
       sessionHostController = null;
       gitWorkspaceMonitor = createGitWorkspaceMonitor();
+      turnSnapshotTracker = new TurnSnapshotTracker(({ sessionId, workspace }) => {
+        const gitServices = this.components?.commandHandler?.ctx?.gitCommandServices;
+        if (gitServices?.createSnapshot) {
+          void Promise.resolve(gitServices.createSnapshot({
+            workspace,
+            reason: "after_agent_work",
+            sessionId
+          })).catch(() => {
+          });
+        }
+        void this.gitWorkspaceMonitor.refresh({ workspace, includeDiffSummary: false }).catch(() => {
+        });
+      });
       running = false;
       localPort;
       ideType = "unknown";
@@ -90028,7 +90244,8 @@ var init_adhdev_daemon = __esm({
           })),
           instanceId: `daemon_${loadConfig().machineId || "daemon"}`,
           version: pkgVersion,
-          profile: "live"
+          profile: "live",
+          getGitSummaryForWorkspace: (workspace) => this.gitWorkspaceMonitor.getCompactSummary(workspace)
         });
       }
       invalidateHotChatSnapshotCache() {
@@ -90214,7 +90431,8 @@ var init_adhdev_daemon = __esm({
           })),
           instanceId: `daemon_${loadConfig().machineId || "daemon"}`,
           version: pkgVersion,
-          profile: "metadata"
+          profile: "metadata",
+          getGitSummaryForWorkspace: (workspace) => this.gitWorkspaceMonitor.getCompactSummary(workspace)
         });
       }
       buildDaemonMetadataUpdateForSubscription(subscription) {
@@ -90358,6 +90576,27 @@ ${err?.stack || ""}`);
             onStreamsUpdated: (ideType, streams) => {
               if (!this.components) return;
               forwardAgentStreamsToIdeInstance(this.components.instanceManager, ideType, streams);
+              for (const stream of streams) {
+                if (stream.sessionId) {
+                  const workspace = this.components?.instanceManager?.getInstance(stream.sessionId)?.getState()?.workspace;
+                  this.turnSnapshotTracker.record(stream.sessionId, stream.status || "idle", workspace);
+                }
+              }
+            },
+            onBeforeSendChat: ({ workspace }) => {
+              void this.gitWorkspaceMonitor.refresh({
+                workspace,
+                includeDiffSummary: false
+              }).catch(() => {
+              });
+              const gitServices = this.components?.commandHandler?.ctx?.gitCommandServices;
+              if (gitServices?.createSnapshot) {
+                void Promise.resolve(gitServices.createSnapshot({
+                  workspace,
+                  reason: "before_user_input_dispatch"
+                })).catch(() => {
+                });
+              }
             }
           });
           const providerSourceConfig = this.components.providerLoader.getSourceConfig();