dsh-easygit-plugin 0.2.0 → 0.2.2

package/lib/index.js

@@ -329,6 +329,59 @@ var init_command_policy = __esm({
 function isRepositoryAction(action) {
   return REPOSITORY_ACTIONS.includes(action);
 }
+function repositoryMutationCommand(action, body) {
+  const paths = Array.isArray(body.paths) && body.paths.every((path) => typeof path === "string") ? body.paths.map(quoteShellArg).join(" ") : "";
+  if (action === "stage-paths" && paths) return "git add -- " + paths;
+  if (action === "unstage-paths" && paths) return "git reset HEAD -- " + paths;
+  if (action === "stage-all") return "git add -A";
+  if (action === "unstage-all") return "git reset HEAD -- :/";
+  if (action === "commit" && typeof body.message === "string") return "git commit -m " + quoteShellArg(body.message.trim());
+  if (action === "create-branch" && typeof body.name === "string" && typeof body.base === "string") {
+    return "git switch -c " + quoteShellArg(body.name) + " " + quoteShellArg(body.base);
+  }
+  if (action === "switch-branch" && typeof body.name === "string") return "git switch " + quoteShellArg(body.name);
+  if (action === "delete-branch" && typeof body.name === "string") {
+    return "git branch " + (body.force === true ? "-D" : "-d") + " -- " + quoteShellArg(body.name);
+  }
+  if (action === "fetch" && typeof body.remote === "string") return "git fetch " + quoteShellArg(body.remote);
+  if (action === "pull") return "git pull --ff-only";
+  if (action === "push") {
+    if (body.setUpstream === true && typeof body.remote === "string" && typeof body.branch === "string") {
+      return "git push -u " + quoteShellArg(body.remote) + " " + quoteShellArg(body.branch);
+    }
+    return "git push";
+  }
+  if (action === "rebase" && typeof body.target === "string") return "git rebase " + quoteShellArg(body.target);
+  if (action === "rebase-continue") return "git -c core.editor=true rebase --continue";
+  if (action === "rebase-abort") return "git rebase --abort";
+  return null;
+}
+async function attachRepositoryRecovery(action, sessionId, body, result, context, dependencies) {
+  const failure = asRecord(result);
+  const syncAction = action === "fetch" || action === "pull" || action === "push" || action === "rebase" || action === "rebase-continue" || action === "rebase-abort";
+  const recoverable = failure.code === "GIT_FAILED" || failure.code === "TIMEOUT" || failure.reason === "BRANCH_EXISTS" || syncAction && failure.code === "STATE_CONFLICT";
+  if (failure.ok !== false || !recoverable) return result;
+  const command = repositoryMutationCommand(action, body);
+  const operationId = typeof body.operationId === "string" ? body.operationId : "";
+  if (!command || !context || !operationId) return result;
+  try {
+    const handled = await dependencies.recoverFailedCommand(
+      sessionId,
+      context.workdir,
+      operationId,
+      action,
+      command,
+      typeof failure.message === "string" ? failure.message : "Git \u64CD\u4F5C\u5931\u8D25",
+      typeof failure.diagnostics === "string" ? failure.diagnostics : "",
+      typeof failure.code === "string" ? failure.code : "GIT_FAILED",
+      typeof failure.reason === "string" ? failure.reason : ""
+    );
+    return handled ? { ...failure, ...handled } : result;
+  } catch (error) {
+    console.log("easygit \u4FEE\u6B63\u63D0\u8BAE\u751F\u6210\u5931\u8D25", errorMessage(error));
+    return result;
+  }
+}
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -367,8 +420,7 @@ function sendJson(res, status, data) {
   });
   res.end(JSON.stringify(data));
 }
-async function dispatchRepositoryAction(action, sessionId, body, dependencies) {
-  const context = dependencies.repositoryContext(sessionId);
+async function dispatchRepositoryAction(action, sessionId, body, context, dependencies) {
   if (!context) return { ok: false, code: "SESSION_NOT_FOUND", message: "\u65E0\u6CD5\u786E\u5B9A\u5F53\u524D\u4F1A\u8BDD\u7684\u4ED3\u5E93\u76EE\u5F55" };
   const repository = dependencies.repository;
   const base = { sessionId, workdir: context.workdir, operationId: body.operationId, sandboxPolicy: context.policy };
@@ -379,6 +431,7 @@ async function dispatchRepositoryAction(action, sessionId, body, dependencies) {
   if (action === "get-commit-detail") return repository.getCommitDetail(context.workdir, body.hash, void 0, context.policy);
   if (action === "get-commit-diff") return repository.getCommitDiff(context.workdir, body.hash, void 0, context.policy);
   if (action === "get-stashes") return repository.getStashes(context.workdir, void 0, context.policy);
+  if (action === "get-sync-state") return repository.getSyncState(context.workdir, void 0, context.policy);
   if (action === "stage-paths") return repository.stagePaths(base, body.paths);
   if (action === "unstage-paths") return repository.unstagePaths(base, body.paths);
   if (action === "stage-all") return repository.stageAll(base);
@@ -386,9 +439,24 @@ async function dispatchRepositoryAction(action, sessionId, body, dependencies) {
   if (action === "commit") return repository.commit(base, body.message);
   if (action === "create-branch") return repository.createBranch(base, body.name, body.base);
   if (action === "switch-branch") return repository.switchBranch(base, body.name);
-  return repository.deleteBranch(base, body.name, body.force === true, body.confirmRisk === true);
+  if (action === "delete-branch") return repository.deleteBranch(base, body.name, body.force === true, body.confirmRisk === true);
+  if (action === "fetch") return repository.fetchRemote(base, body.remote);
+  if (action === "pull") return repository.pullFfOnly(base);
+  if (action === "push") return repository.pushCurrent(base, body.remote, body.branch, body.setUpstream === true);
+  if (action === "rebase") return repository.rebaseOnto(base, body.target, body.confirmRisk === true);
+  if (action === "rebase-continue") return repository.continueRebase(base, body.confirmRisk === true);
+  return repository.abortRebase(base, body.confirmRisk === true);
 }
 async function dispatchProposalAction(action, sessionId, body, dependencies) {
+  if (action === "request-analysis") {
+    const proposal = dependencies.findProposal(sessionId, body.proposalId);
+    if (!proposal || proposal.closed || proposal.status !== "failed" || proposal.needsAgentAnalysis !== true || !proposal.failure) {
+      return { status: 200, data: { ok: false, error: "\u8BE5\u5931\u8D25\u8BB0\u5F55\u5DF2\u4E0D\u518D\u7B49\u5F85 Agent \u5206\u6790" } };
+    }
+    proposal.analysisRequestedAt = Date.now();
+    await dependencies.flushProposal(sessionId);
+    return { status: 200, data: { ok: true } };
+  }
   if (action === "state") {
     const proposal = dependencies.latestPending(sessionId);
     if (proposal && proposal.status === "pending" && proposal.copied === true && proposal.fingerprint) {
@@ -452,16 +520,16 @@ async function dispatchProposalAction(action, sessionId, body, dependencies) {
       dependencies.resolveExecutionPolicy(sessionId),
       () => dependencies.flushProposal(sessionId)
     );
-    console.log("git-guide HTTP execute", proposal.proposalId, "ok=", result.ok);
+    console.log("easygit HTTP execute", proposal.proposalId, "ok=", result.ok);
     return { status: 200, data: result };
   }
   return { status: 400, data: { ok: false, error: "unknown action: " + action } };
 }
-function registerGitGuideActions(webServer, dependencies) {
+function registerEasyGitActions(webServer, dependencies) {
   if (!webServer) return void 0;
   return webServer.register({
     kind: "prefix",
-    path: "/git-guide",
+    path: "/easygit",
     handler: async (req, res) => {
       if (req.method !== "POST") {
         sendJson(res, 405, { ok: false, error: "method not allowed" });
@@ -497,7 +565,9 @@ function registerGitGuideActions(webServer, dependencies) {
       try {
         await dependencies.proposalStorageReady;
         if (isRepositoryAction(action)) {
-          sendJson(res, 200, await dispatchRepositoryAction(action, sessionId, body, dependencies));
+          const context = dependencies.repositoryContext(sessionId);
+          const result = await dispatchRepositoryAction(action, sessionId, body, context, dependencies);
+          sendJson(res, 200, await attachRepositoryRecovery(action, sessionId, body, result, context, dependencies));
           return;
         }
         const response = await dispatchProposalAction(action, sessionId, body, dependencies);
@@ -522,6 +592,7 @@ var init_actions = __esm({
       "get-commit-detail",
       "get-commit-diff",
       "get-stashes",
+      "get-sync-state",
       "stage-paths",
       "unstage-paths",
       "stage-all",
@@ -529,7 +600,13 @@ var init_actions = __esm({
       "commit",
       "create-branch",
       "switch-branch",
-      "delete-branch"
+      "delete-branch",
+      "fetch",
+      "pull",
+      "push",
+      "rebase",
+      "rebase-continue",
+      "rebase-abort"
     ];
   }
 });
@@ -538,6 +615,10 @@ var init_actions = __esm({
 function isRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isGitFailureContext(value) {
+  if (!isRecord(value)) return false;
+  return (value.source === "workbench" || value.source === "proposal") && typeof value.code === "string" && typeof value.action === "string" && typeof value.command === "string" && typeof value.message === "string" && typeof value.stdout === "string" && typeof value.stderr === "string" && typeof value.diagnostics === "string" && (value.exitCode === null || typeof value.exitCode === "number" && Number.isSafeInteger(value.exitCode)) && typeof value.timedOut === "boolean" && typeof value.mayHavePartialChanges === "boolean" && typeof value.occurredAt === "number" && Number.isSafeInteger(value.occurredAt);
+}
 function isStoredProposal(value, sessionId) {
   if (!isRecord(value) || value.sessionId !== sessionId) return false;
   if (typeof value.proposalId !== "string" || !/^g-[0-9a-f-]{36}$/i.test(value.proposalId)) return false;
@@ -548,7 +629,7 @@ function isStoredProposal(value, sessionId) {
   if (!Array.isArray(value.reasons) || !value.reasons.every((reason) => typeof reason === "string")) return false;
   if (!Array.isArray(value.steps) || value.steps.length === 0 || value.steps.length > 10) return false;
   if (!value.steps.every((step) => isRecord(step) && typeof step.command === "string" && (step.result === null || isRecord(step.result)))) return false;
-  return typeof value.confirmed === "boolean" && typeof value.closed === "boolean" && typeof value.copied === "boolean" && typeof value.verified === "boolean" && (value.fingerprint === null || typeof value.fingerprint === "string") && (value.result === null || isRecord(value.result));
+  return typeof value.confirmed === "boolean" && typeof value.closed === "boolean" && typeof value.copied === "boolean" && typeof value.verified === "boolean" && (value.fingerprint === null || typeof value.fingerprint === "string") && (value.result === null || isRecord(value.result)) && (value.failure === void 0 || isGitFailureContext(value.failure)) && (value.recoverySuggestion === void 0 || typeof value.recoverySuggestion === "string") && (value.needsAgentAnalysis === void 0 || typeof value.needsAgentAnalysis === "boolean") && (value.analysisRequestedAt === void 0 || typeof value.analysisRequestedAt === "number" && Number.isSafeInteger(value.analysisRequestedAt));
 }
 var import_node_crypto, DEFAULT_PROPOSALS_PER_SESSION, DEFAULT_MAX_SESSIONS, DEFAULT_SESSION_TTL_MS, ProposalService, proposalService;
 var init_proposal_service = __esm({
@@ -679,6 +760,10 @@ var init_proposal_service = __esm({
           result: proposal.result,
           closed: proposal.closed,
           copied: proposal.copied,
+          ...proposal.failure ? { failure: proposal.failure } : {},
+          ...typeof proposal.recoverySuggestion === "string" ? { recoverySuggestion: proposal.recoverySuggestion } : {},
+          ...proposal.needsAgentAnalysis === true ? { needsAgentAnalysis: true } : {},
+          ...typeof proposal.analysisRequestedAt === "number" ? { analysisRequestedAt: proposal.analysisRequestedAt } : {},
           status: proposal.status || (proposal.closed ? "dismissed" : "pending")
         };
       }
@@ -724,6 +809,15 @@ function validPathspec(path) {
 function validBranchName(name) {
   return typeof name === "string" && name.length > 0 && name.length <= 255 && !/[\0\r\n\s~^:?*\[\\]/.test(name) && !name.startsWith("-") && !name.startsWith(".") && !name.endsWith(".") && !name.includes("..") && !name.includes("@{") && !name.endsWith(".lock");
 }
+function validRemoteName(name) {
+  return typeof name === "string" && name.length > 0 && name.length <= 255 && /^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(name) && !name.includes("..") && !name.includes("@{") && !name.endsWith(".lock");
+}
+function conflictCount(files) {
+  return files.filter((file) => {
+    const status = file.indexStatus + file.workTreeStatus;
+    return status.includes("U") || status === "AA" || status === "DD";
+  }).length;
+}
 function validCommitHash(hash) {
   return typeof hash === "string" && /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i.test(hash);
 }
@@ -1007,6 +1101,103 @@ var init_git_repository_service = __esm({
         });
         return { ok: true, data: stashes };
       }
+      async getSyncState(workdir, signal, sandboxPolicy) {
+        const summary = await this.getSummary(workdir, signal, sandboxPolicy);
+        if (!summary.ok) return summary;
+        const [remoteResult, upstreamResult, rebaseResult] = await Promise.all([
+          this.run(workdir, "git remote", 15e3, 2e4, signal, sandboxPolicy),
+          this.run(workdir, "git rev-parse --abbrev-ref --symbolic-full-name @{upstream}", 15e3, 4096, signal, sandboxPolicy),
+          this.run(workdir, 'test -d "$(git rev-parse --git-path rebase-merge)" || test -d "$(git rev-parse --git-path rebase-apply)"', 15e3, 4096, signal, sandboxPolicy)
+        ]);
+        if (remoteResult.exitCode !== 0) {
+          return errorResult("GIT_FAILED", "\u65E0\u6CD5\u8BFB\u53D6\u8FDC\u7A0B\u4ED3\u5E93", redactAndLimit(outputOf(remoteResult), 8192));
+        }
+        const remotes = (remoteResult.stdout?.text ?? "").split("\n").map((entry) => redactAndLimit(entry.trim(), 255)).filter(Boolean);
+        const upstream = upstreamResult.exitCode === 0 ? redactAndLimit(upstreamResult.stdout?.text ?? "", 512).trim() : "";
+        let ahead = 0;
+        let behind = 0;
+        if (upstream) {
+          const counts = await this.run(workdir, "git rev-list --left-right --count HEAD...@{upstream}", 15e3, 4096, signal, sandboxPolicy);
+          if (counts.exitCode !== 0) return errorResult("GIT_FAILED", "\u65E0\u6CD5\u8BA1\u7B97\u672C\u5730\u4E0E\u4E0A\u6E38\u7684\u63D0\u4EA4\u5DEE\u5F02", redactAndLimit(outputOf(counts), 8192));
+          const [aheadText = "0", behindText = "0"] = (counts.stdout?.text ?? "").trim().split(/\s+/);
+          ahead = /^\d+$/.test(aheadText) ? Number(aheadText) : 0;
+          behind = /^\d+$/.test(behindText) ? Number(behindText) : 0;
+        }
+        const conflicts = conflictCount(summary.data.files);
+        return {
+          ok: true,
+          data: {
+            topLevel: summary.data.topLevel,
+            branch: summary.data.branch,
+            head: summary.data.head,
+            upstream,
+            remotes,
+            ahead,
+            behind,
+            dirty: summary.data.files.length > 0,
+            conflictCount: conflicts,
+            rebaseInProgress: rebaseResult.exitCode === 0,
+            files: summary.data.files
+          }
+        };
+      }
+      async fetchRemote(request, remote) {
+        if (!validRemoteName(remote)) return errorResult("INVALID_ARGUMENT", "\u8FDC\u7A0B\u4ED3\u5E93\u540D\u79F0\u4E0D\u5408\u6CD5");
+        const state = await this.getSyncState(request.workdir, request.signal, request.sandboxPolicy);
+        if (!state.ok) return state;
+        if (!state.data.remotes.includes(remote)) return errorResult("STATE_CONFLICT", "\u8FDC\u7A0B\u4ED3\u5E93\u4E0D\u5B58\u5728", void 0, "NO_REMOTE");
+        return this.mutateSync(request, "git fetch " + quoteShellArg(remote), "\u83B7\u53D6\u8FDC\u7A0B\u66F4\u65B0\u5931\u8D25");
+      }
+      async pullFfOnly(request) {
+        const state = await this.getSyncState(request.workdir, request.signal, request.sandboxPolicy);
+        if (!state.ok) return state;
+        if (!state.data.branch) return errorResult("STATE_CONFLICT", "\u5206\u79BB HEAD \u72B6\u6001\u4E0D\u80FD\u76F4\u63A5\u62C9\u53D6", void 0, "DETACHED_HEAD");
+        if (!state.data.upstream) return errorResult("STATE_CONFLICT", "\u5F53\u524D\u5206\u652F\u6CA1\u6709\u4E0A\u6E38\u8DDF\u8E2A\u5206\u652F", void 0, "NO_UPSTREAM");
+        if (state.data.rebaseInProgress) return errorResult("STATE_CONFLICT", "Rebase \u8FDB\u884C\u4E2D\uFF0C\u8BF7\u5148\u7EE7\u7EED\u6216\u4E2D\u6B62", void 0, "REBASE_IN_PROGRESS");
+        if (state.data.conflictCount > 0) return errorResult("STATE_CONFLICT", "\u5B58\u5728\u5C1A\u672A\u89E3\u51B3\u7684\u51B2\u7A81", void 0, "CONFLICTS_PRESENT");
+        return this.mutateSync(request, "git pull --ff-only", "\u62C9\u53D6\u8FDC\u7A0B\u66F4\u65B0\u5931\u8D25");
+      }
+      async pushCurrent(request, remote, branch, setUpstream) {
+        const state = await this.getSyncState(request.workdir, request.signal, request.sandboxPolicy);
+        if (!state.ok) return state;
+        if (!state.data.branch) return errorResult("STATE_CONFLICT", "\u5206\u79BB HEAD \u72B6\u6001\u4E0D\u80FD\u76F4\u63A5\u63A8\u9001", void 0, "DETACHED_HEAD");
+        if (state.data.rebaseInProgress) return errorResult("STATE_CONFLICT", "Rebase \u8FDB\u884C\u4E2D\uFF0C\u8BF7\u5148\u7EE7\u7EED\u6216\u4E2D\u6B62", void 0, "REBASE_IN_PROGRESS");
+        if (setUpstream) {
+          if (state.data.upstream) return errorResult("STATE_CONFLICT", "\u5F53\u524D\u5206\u652F\u5DF2\u7ECF\u6709\u4E0A\u6E38\uFF0C\u8BF7\u4F7F\u7528\u666E\u901A\u63A8\u9001");
+          if (!validRemoteName(remote) || !state.data.remotes.includes(remote)) return errorResult("STATE_CONFLICT", "\u8BF7\u9009\u62E9\u5B58\u5728\u7684\u8FDC\u7A0B\u4ED3\u5E93", void 0, "NO_REMOTE");
+          if (!validBranchName(branch) || branch !== state.data.branch) return errorResult("INVALID_ARGUMENT", "\u53EA\u80FD\u4E3A\u5F53\u524D\u672C\u5730\u5206\u652F\u5EFA\u7ACB\u4E0A\u6E38");
+          return this.mutateSync(request, "git push -u " + quoteShellArg(remote) + " " + quoteShellArg(branch), "\u63A8\u9001\u5E76\u5EFA\u7ACB\u4E0A\u6E38\u5931\u8D25");
+        }
+        if (!state.data.upstream) return errorResult("STATE_CONFLICT", "\u5F53\u524D\u5206\u652F\u6CA1\u6709\u4E0A\u6E38\u8DDF\u8E2A\u5206\u652F", void 0, "NO_UPSTREAM");
+        return this.mutateSync(request, "git push", "\u63A8\u9001\u5931\u8D25");
+      }
+      async rebaseOnto(request, target, confirmRisk) {
+        if (!validBranchName(target)) return errorResult("INVALID_ARGUMENT", "Rebase \u76EE\u6807\u5FC5\u987B\u662F\u5B89\u5168\u7684\u672C\u5730\u6216\u8FDC\u7A0B\u5206\u652F\u5F15\u7528");
+        if (!confirmRisk) return errorResult("PERMISSION_DENIED", "Rebase \u4F1A\u91CD\u5199\u672C\u5730\u63D0\u4EA4\u5386\u53F2\uFF0C\u6267\u884C\u524D\u5FC5\u987B\u786E\u8BA4\u98CE\u9669");
+        const state = await this.getSyncState(request.workdir, request.signal, request.sandboxPolicy);
+        if (!state.ok) return state;
+        if (!state.data.branch) return errorResult("STATE_CONFLICT", "\u5206\u79BB HEAD \u72B6\u6001\u4E0D\u80FD\u5F00\u59CB Rebase", void 0, "DETACHED_HEAD");
+        if (state.data.rebaseInProgress) return errorResult("STATE_CONFLICT", "\u5DF2\u6709 Rebase \u6B63\u5728\u8FDB\u884C", void 0, "REBASE_IN_PROGRESS");
+        if (state.data.dirty) return errorResult("STATE_CONFLICT", "Rebase \u524D\u9700\u8981\u63D0\u4EA4\u6216\u8D2E\u85CF\u5DE5\u4F5C\u533A\u6539\u52A8", void 0, "DIRTY_WORKTREE");
+        const exists = await this.run(request.workdir, "git rev-parse --verify --quiet " + quoteShellArg(target + "^{commit}"), 15e3, 4096, request.signal, request.sandboxPolicy);
+        if (exists.exitCode !== 0) return errorResult("STATE_CONFLICT", "Rebase \u76EE\u6807\u5F15\u7528\u4E0D\u5B58\u5728", void 0, "REF_NOT_FOUND");
+        return this.mutateSync(request, "git rebase " + quoteShellArg(target), "Rebase \u5931\u8D25");
+      }
+      async continueRebase(request, confirmRisk) {
+        if (!confirmRisk) return errorResult("PERMISSION_DENIED", "\u7EE7\u7EED Rebase \u524D\u5FC5\u987B\u786E\u8BA4\u5386\u53F2\u91CD\u5199\u98CE\u9669");
+        const state = await this.getSyncState(request.workdir, request.signal, request.sandboxPolicy);
+        if (!state.ok) return state;
+        if (!state.data.rebaseInProgress) return errorResult("STATE_CONFLICT", "\u5F53\u524D\u6CA1\u6709\u6B63\u5728\u8FDB\u884C\u7684 Rebase", void 0, "NO_REBASE_IN_PROGRESS");
+        if (state.data.conflictCount > 0) return errorResult("STATE_CONFLICT", "\u4ECD\u6709\u51B2\u7A81\u6587\u4EF6\uFF0C\u8BF7\u89E3\u51B3\u5E76\u6682\u5B58\u540E\u518D\u7EE7\u7EED", void 0, "CONFLICTS_PRESENT");
+        return this.mutateSync(request, "git -c core.editor=true rebase --continue", "\u7EE7\u7EED Rebase \u5931\u8D25");
+      }
+      async abortRebase(request, confirmRisk) {
+        if (!confirmRisk) return errorResult("PERMISSION_DENIED", "\u4E2D\u6B62 Rebase \u4F1A\u4E22\u5F03\u672C\u6B21\u53D8\u57FA\u8FC7\u7A0B\u4E2D\u7684\u4FEE\u6539\uFF0C\u6267\u884C\u524D\u5FC5\u987B\u786E\u8BA4\u98CE\u9669");
+        const state = await this.getSyncState(request.workdir, request.signal, request.sandboxPolicy);
+        if (!state.ok) return state;
+        if (!state.data.rebaseInProgress) return errorResult("STATE_CONFLICT", "\u5F53\u524D\u6CA1\u6709\u6B63\u5728\u8FDB\u884C\u7684 Rebase", void 0, "NO_REBASE_IN_PROGRESS");
+        return this.mutateSync(request, "git rebase --abort", "\u4E2D\u6B62 Rebase \u5931\u8D25");
+      }
       async stagePaths(request, paths) {
         const valid = this.validatePaths(paths);
         if (!valid.ok) return valid;
@@ -1031,6 +1222,18 @@ var init_git_repository_service = __esm({
       }
       async createBranch(request, name, base) {
         if (!validBranchName(name) || !validBranchName(base)) return errorResult("INVALID_ARGUMENT", "\u5206\u652F\u540D\u548C\u57FA\u7840\u5206\u652F\u5FC5\u987B\u662F\u5B89\u5168\u7684\u672C\u5730 Git \u5F15\u7528");
+        const repository = await this.getTopLevel(request.workdir, request.signal, request.sandboxPolicy);
+        if (!repository.ok) return repository;
+        const exists = await this.run(
+          request.workdir,
+          "git show-ref --verify --quiet " + quoteShellArg("refs/heads/" + name),
+          15e3,
+          4096,
+          request.signal,
+          request.sandboxPolicy
+        );
+        if (exists.exitCode === 0) return errorResult("STATE_CONFLICT", "\u540C\u540D\u672C\u5730\u5206\u652F\u5DF2\u7ECF\u5B58\u5728", void 0, "BRANCH_EXISTS");
+        if (exists.exitCode !== 1) return errorResult("GIT_FAILED", "\u65E0\u6CD5\u68C0\u67E5\u76EE\u6807\u5206\u652F\u662F\u5426\u5B58\u5728", redactAndLimit(outputOf(exists), 8192));
         return this.mutate(request, "git switch -c " + quoteShellArg(name) + " " + quoteShellArg(base), false, "\u521B\u5EFA\u5206\u652F\u5931\u8D25");
       }
       async switchBranch(request, name) {
@@ -1066,7 +1269,13 @@ var init_git_repository_service = __esm({
         }
         return { ok: true, data: paths };
       }
-      async mutate(request, command, requiresStagedContent = false, failureMessage = "Git \u64CD\u4F5C\u5931\u8D25") {
+      mutate(request, command, requiresStagedContent = false, failureMessage = "Git \u64CD\u4F5C\u5931\u8D25") {
+        return this.mutateAndRead(request, command, failureMessage, requiresStagedContent, () => this.getSummary(request.workdir, request.signal, request.sandboxPolicy));
+      }
+      mutateSync(request, command, failureMessage) {
+        return this.mutateAndRead(request, command, failureMessage, false, () => this.getSyncState(request.workdir, request.signal, request.sandboxPolicy));
+      }
+      async mutateAndRead(request, command, failureMessage, requiresStagedContent, readResult) {
         if (!request.sessionId || !request.workdir) return errorResult("SESSION_NOT_FOUND", "\u65E0\u6CD5\u786E\u5B9A\u5F53\u524D\u4F1A\u8BDD\u7684\u4ED3\u5E93\u76EE\u5F55");
         if (typeof request.operationId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(request.operationId)) {
           return errorResult("INVALID_ARGUMENT", "operationId \u5FC5\u987B\u662F 1\u2013128 \u4E2A\u5B89\u5168\u5B57\u7B26");
@@ -1095,8 +1304,8 @@ var init_git_repository_service = __esm({
             }
             const executed = await this.run(request.workdir, command, 12e4, MUTATION_OUTPUT_MAX_CHARS, request.signal, request.sandboxPolicy);
             if (executed.exitCode !== 0) return errorResult(mutationErrorCode(executed), failureMessage, redactAndLimit(outputOf(executed), 8192));
-            const summary = await this.getSummary(request.workdir, request.signal, request.sandboxPolicy);
-            return summary.ok ? { ...summary, operationId: String(request.operationId) } : summary;
+            const result2 = await readResult();
+            return result2.ok ? { ...result2, operationId: String(request.operationId) } : result2;
           } finally {
             release();
             if (this.locks.get(lockKey) === queued) this.locks.delete(lockKey);
@@ -1330,10 +1539,28 @@ var require_plugin = __commonJS({
       const failedStep = proposal.steps.find((step) => step.result?.ok === false);
       const lastResult = failedStep ? failedStep.result : last?.result;
       const diagnostics = ok ? "" : await captureDiagnostics(shell, proposal.workdir);
+      const error = ok ? "" : redactSecrets(lastResult && (lastResult.stderr || lastResult.stdout) || "git \u9000\u51FA\u7801 " + (lastResult ? lastResult.exitCode : -1));
+      const failure = ok ? void 0 : {
+        source: "proposal",
+        code: lastResult?.timedOut === true ? "TIMEOUT" : "GIT_FAILED",
+        action: "execute",
+        command: failedStep?.command || proposal.command,
+        message: error,
+        stdout: redactSecrets(lastResult ? lastResult.stdout : ""),
+        stderr: redactSecrets(lastResult ? lastResult.stderr : ""),
+        diagnostics,
+        exitCode: lastResult ? lastResult.exitCode : null,
+        timedOut: lastResult?.timedOut === true,
+        mayHavePartialChanges: proposal.steps.some((step) => step !== failedStep && step.result?.ok === true),
+        occurredAt: Date.now()
+      };
+      proposal.failure = failure;
       const recovery = ok ? null : buildRecovery(proposal, failedStep, diagnostics);
-      if (recovery && recovery.command) {
-        const corrected = registerRecoveryProposal(proposal, recovery);
+      if (recovery && recovery.command && failure) {
+        const corrected = registerRecoveryProposal(proposal, recovery, failure);
         if (corrected) recovery.proposalId = corrected.proposalId;
+      } else if (!ok && failure) {
+        proposal.needsAgentAnalysis = true;
       }
       if (typeof persistStatus === "function") await persistStatus();
       return {
@@ -1347,14 +1574,19 @@ var require_plugin = __commonJS({
         stdout: redactSecrets(lastResult ? lastResult.stdout : ""),
         stderr: redactSecrets(lastResult ? lastResult.stderr : ""),
         diagnostics,
+        ...failure ? { failure } : {},
         recovery: recovery ? { suggestion: recovery.suggestion, command: recovery.command || "", proposalId: recovery.proposalId || null } : null,
-        error: ok ? "" : redactSecrets(lastResult && (lastResult.stderr || lastResult.stdout) || "git \u9000\u51FA\u7801 " + (lastResult ? lastResult.exitCode : -1))
+        ...!ok && failure && !recovery?.command ? { analysis: { proposalId: proposal.proposalId } } : {},
+        error
       };
     }
     function buildRecovery(_proposal, failedStep, diagnostics) {
       if (!failedStep || !failedStep.result) return null;
-      const text = String(((failedStep.result.stderr || "") + " " + (failedStep.result.stdout || "") + " " + (diagnostics || "")).trim());
       const cmd = String(failedStep.command || "");
+      const text = String(((failedStep.result.stderr || "") + " " + (failedStep.result.stdout || "") + " " + (diagnostics || "")).trim());
+      return buildRecoveryForCommand(cmd, text);
+    }
+    function buildRecoveryForCommand(cmd, text, reason = "") {
       if (/只读文件系统|read-only file system|EROFS|cannot lock ref|cannot create .*\.lock/i.test(text)) {
         return { suggestion: "\u6267\u884C\u73AF\u5883\u5BF9\u76EE\u6807\u76EE\u5F55\u53EA\u8BFB\uFF08\u6C99\u7BB1\u7B56\u7565\u6216\u6302\u8F7D\u95EE\u9898\uFF09\uFF1A\u8BF7\u5728\u7EC8\u7AEF\u624B\u52A8\u6267\u884C\u8BE5\u547D\u4EE4\uFF0C\u6216\u8C03\u6574\u6267\u884C\u73AF\u5883\u7684\u6C99\u7BB1\u6743\u9650\u3002", command: null };
       }
@@ -1362,11 +1594,13 @@ var require_plugin = __commonJS({
         const corrected = cmd.replace(/git\s+add\s+/, "git add -f ");
         if (corrected !== cmd) return { suggestion: "\u76EE\u6807\u6587\u4EF6\u88AB .gitignore \u5FFD\u7565\uFF1A\u6539\u7528 -f \u5F3A\u5236\u52A0\u5165\uFF08\u4EC5\u9488\u5BF9\u660E\u786E\u5217\u51FA\u7684\u6587\u4EF6\uFF09\u3002", command: corrected };
       }
-      if (/already exists|分支.*已存在|already exist/i.test(text)) {
-        const m = cmd.match(/git\s+(?:switch\s+-c|checkout\s+-b)\s+([^\s]+)/);
-        if (m) {
-          const corrected = cmd.replace(/switch\s+-c/, "switch").replace(/checkout\s+-b/, "checkout");
-          return { suggestion: "\u5206\u652F " + m[1] + " \u5DF2\u5B58\u5728\uFF1A\u6539\u4E3A\u5207\u6362\u5230\u73B0\u6709\u5206\u652F\uFF08\u6216\u6362\u4E00\u4E2A\u5206\u652F\u540D\uFF09\u3002", command: corrected };
+      if (reason === "BRANCH_EXISTS" || /already exist(?:s)?|分支.*已(?:经)?存在/i.test(text)) {
+        const parsed = parseCommand(cmd);
+        const createFlag = parsed.ok ? parsed.args.findIndex((argument) => argument === "-c" || argument === "-b") : -1;
+        const branch = parsed.ok && createFlag >= 2 ? parsed.args[createFlag + 1] : void 0;
+        if (branch) {
+          const corrected = "git switch " + quoteShellArg(branch);
+          return { suggestion: "\u5206\u652F " + branch + " \u5DF2\u5B58\u5728\uFF1A\u6539\u4E3A\u5207\u6362\u5230\u73B0\u6709\u5206\u652F\uFF08\u6216\u6362\u4E00\u4E2A\u5206\u652F\u540D\uFF09\u3002", command: corrected };
         }
       }
       if (/not a git repository|不是.*git 仓库|不是一个 git 仓库/i.test(text)) {
@@ -1389,7 +1623,51 @@ var require_plugin = __commonJS({
       }
       return null;
     }
-    function registerRecoveryProposal(failedProposal, recovery) {
+    async function recoverFailedCommand(activeShell, sessionId, workdir, operationId, action, command, message, errorOutput, errorCode, reason) {
+      const operationKey = workdir + "\0" + operationId;
+      const existing = proposalService.list(sessionId)?.find((proposal2) => proposal2.recoveryOperationKey === operationKey);
+      if (existing) {
+        if (!existing.failure) return null;
+        if (existing.needsAgentAnalysis === true) return { failure: existing.failure, analysis: { proposalId: existing.proposalId } };
+        if (existing.closed || existing.status !== "pending") return { failure: existing.failure };
+        return { failure: existing.failure, recovery: {
+          suggestion: String(existing.recoverySuggestion || existing.explanation),
+          command: existing.command,
+          proposalId: existing.proposalId
+        } };
+      }
+      const diagnostics = await captureDiagnostics(activeShell, workdir);
+      const failure = {
+        source: "workbench",
+        code: errorCode,
+        action,
+        command,
+        message,
+        stdout: "",
+        stderr: redactSecrets(errorOutput),
+        diagnostics,
+        exitCode: null,
+        timedOut: errorCode === "TIMEOUT",
+        mayHavePartialChanges: reason !== "BRANCH_EXISTS",
+        occurredAt: Date.now()
+      };
+      const recovery = buildRecoveryForCommand(command, message + "\n" + errorOutput + "\n" + diagnostics, reason);
+      if (!recovery?.command) {
+        const failed = registerFailureProposal(sessionId, workdir, command, failure);
+        if (failed) {
+          failed.recoveryOperationKey = operationKey;
+          await proposalService.flush(sessionId);
+        }
+        return { failure, ...failed ? { analysis: { proposalId: failed.proposalId } } : {} };
+      }
+      const proposal = registerRecoveryProposal({ sessionId, workdir }, recovery, failure);
+      if (!proposal) return { failure };
+      proposal.recoveryOperationKey = operationKey;
+      proposal.recoverySuggestion = recovery.suggestion;
+      await proposalService.flush(sessionId);
+      return { failure, recovery: { suggestion: recovery.suggestion, command: recovery.command, proposalId: proposal.proposalId } };
+    }
+    function registerRecoveryProposal(failedProposal, recovery, failure) {
       if (!recovery.command) return null;
       const v = validateCommand(recovery.command);
       if (!v.ok) return null;
@@ -1403,7 +1681,7 @@ var require_plugin = __commonJS({
         intent: "\u4FEE\u6B63\u5EFA\u8BAE\uFF1A" + recovery.suggestion,
         command: recovery.command.trim(),
         steps: [{ command: recovery.command.trim(), result: null }],
-        explanation: recovery.suggestion + "\uFF08\u7531\u6267\u884C\u5931\u8D25\u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u786E\u8BA4\u540E\u6267\u884C\uFF09",
+        explanation: failure ? "\u539F\u547D\u4EE4\uFF1A" + failure.command + "\n\u9519\u8BEF\uFF1A" + (failure.stderr || failure.message) + "\n\u4FEE\u6B63\u539F\u56E0\uFF1A" + recovery.suggestion : recovery.suggestion + "\uFF08\u7531\u6267\u884C\u5931\u8D25\u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u786E\u8BA4\u540E\u6267\u884C\uFF09",
         risk: risk.level,
         reasons: risk.reasons,
         confirmed: false,
@@ -1415,11 +1693,43 @@ var require_plugin = __commonJS({
         fingerprint: null,
         verified: false,
         status: "pending",
-        recovery: true
+        recovery: true,
+        recoverySuggestion: recovery.suggestion,
+        ...failure ? { failure } : {}
+      };
+      proposalService.closeOpen(sessionId);
+      storeProposal(sessionId, proposal);
+      console.log("easygit \u4FEE\u6B63\u5EFA\u8BAE\u767B\u8BB0", proposal.proposalId, "session=", sessionId, "risk=", risk.level);
+      return proposal;
+    }
+    function registerFailureProposal(sessionId, workdir, command, failure) {
+      if (proposalService.hasRunning(sessionId)) return null;
+      const risk = classifyRisk(command);
+      const proposal = {
+        proposalId: proposalService.newId(),
+        sessionId,
+        intent: "Git \u64CD\u4F5C\u5931\u8D25\uFF0C\u7B49\u5F85\u5206\u6790",
+        command,
+        steps: [{ command, result: { ok: false, stderr: failure.stderr, stdout: failure.stdout, exitCode: failure.exitCode } }],
+        explanation: "\u539F\u547D\u4EE4\uFF1A" + command + "\n\u9519\u8BEF\uFF1A" + (failure.stderr || failure.message),
+        risk: risk.level,
+        reasons: risk.reasons,
+        confirmed: false,
+        workdir,
+        createdAt: failure.occurredAt,
+        result: { ok: false, error: failure.message },
+        closed: false,
+        copied: false,
+        fingerprint: null,
+        verified: false,
+        status: "failed",
+        failure,
+        recovery: true,
+        needsAgentAnalysis: true
       };
       proposalService.closeOpen(sessionId);
       storeProposal(sessionId, proposal);
-      console.log("git-guide \u4FEE\u6B63\u5EFA\u8BAE\u767B\u8BB0", proposal.proposalId, "session=", sessionId, "risk=", risk.level);
+      console.log("easygit \u5931\u8D25\u4E0A\u4E0B\u6587\u767B\u8BB0", proposal.proposalId, "session=", sessionId);
       return proposal;
     }
     function storeProposal(sessionId, proposal) {
@@ -1447,7 +1757,7 @@ var require_plugin = __commonJS({
         const backend = storage.backend.get("json");
         if (!backend || !backend.kv || typeof backend.kv.open !== "function") throw new Error("JSON storage backend does not support key-value units");
         unit = await backend.kv.open({
-          name: "git_guide_proposals",
+          name: "easygit_proposals",
           version: 1,
           tables: ["proposals"],
           hasGlobal: false
@@ -1460,7 +1770,7 @@ var require_plugin = __commonJS({
       return ready;
     }
     var plugin2 = {
-      name: "git-guide",
+      name: "easygit",
       inject: ["shell", "tools"],
       apply(ctx) {
         const shell = ctx.get("shell");
@@ -1550,6 +1860,7 @@ var require_plugin = __commonJS({
               if (prev && prev.some((proposal2) => proposal2.status === "running")) {
                 return { ok: false, proposalId: "", intent: String(args.intent || ""), command: "", steps: [], explanation: String(args.explanation || ""), risk: risk.level, reasons: risk.reasons, workdir: workdir || "", error: "\u540C\u4E00\u4F1A\u8BDD\u5DF2\u6709\u63D0\u8BAE\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7B49\u5F85\u6267\u884C\u7ED3\u675F\u540E\u518D\u521B\u5EFA\u65B0\u63D0\u8BAE" };
               }
+              const analysisSource = prev?.find((candidate) => !candidate.closed && candidate.needsAgentAnalysis === true && typeof candidate.analysisRequestedAt === "number" && !!candidate.failure);
               proposalService.closeOpen(sessionId);
               const proposal = {
                 proposalId: proposalService.newId(),
@@ -1568,7 +1879,13 @@ var require_plugin = __commonJS({
                 copied: false,
                 fingerprint: null,
                 verified: false,
-                status: "pending"
+                status: "pending",
+                ...analysisSource?.failure ? {
+                  failure: analysisSource.failure,
+                  recovery: true,
+                  recoverySuggestion: String(args.explanation || ""),
+                  analyzedFailureProposalId: analysisSource.proposalId
+                } : {}
               };
               storeProposal(sessionId, proposal);
               await proposalService.flush(sessionId);
@@ -1645,7 +1962,7 @@ var require_plugin = __commonJS({
             }
           });
         }
-        const registerWebServer = (webServer) => registerGitGuideActions(webServer, {
+        const registerWebServer = (webServer) => registerEasyGitActions(webServer, {
           repository,
           proposalStorageReady,
           shell,
@@ -1658,6 +1975,18 @@ var require_plugin = __commonJS({
           runChecks,
           verifyProposal,
           executeProposal: (activeShell, proposal, policy, persist) => executeRegisteredProposal(activeShell, proposal, void 0, policy, persist),
+          recoverFailedCommand: (sessionId, workdir, operationId, action, command, message, errorOutput, errorCode, reason) => recoverFailedCommand(
+            shell,
+            sessionId,
+            workdir,
+            operationId,
+            action,
+            command,
+            message,
+            errorOutput,
+            errorCode,
+            reason
+          ),
           resolveExecutionPolicy: (sessionId) => {
             const agents = ctx.get("agents");
             const agent = agents ? agents.get(sessionId) : void 0;
@@ -1689,12 +2018,15 @@ var require_plugin = __commonJS({
       executeProposalSteps,
       executeRegisteredProposal,
       buildRecovery,
+      buildRecoveryForCommand,
+      recoverFailedCommand,
       registerRecoveryProposal,
       storeProposal,
       findProposal,
       proposalView,
       latestPending,
-      ProposalService
+      ProposalService,
+      GitRepositoryService
     };
     module2.exports = Object.assign(plugin2, { helpers });
   }

package/lib/types/client/index.d.ts

@@ -1,5 +1,5 @@
 import { createPanelController } from './panel-controller';
-import { appendCommandLog, beginTrackedRequest, buildFileTree, cancelTrackedRequest, clampWorkbenchRatio, commitFileTone, deriveCommitGraph, filterLocalBranches, isCurrentCommitRequest, isLatestRequest, isTrackedRequestCurrent, mutationCommand, nextCommitSelection, parseReviewRows, repositoryName, type AnyRecord } from './view-model';
+import { appendCommandLog, analysisProposalId, beginTrackedRequest, buildAgentRepairPrompt, canDismissFailedProposal, buildFileTree, cancelTrackedRequest, clampWorkbenchRatio, commitFileTone, deriveCommitGraph, filterLocalBranches, failureContext, isCurrentCommitRequest, isLatestRequest, isTrackedRequestCurrent, mutationCommand, nextCommitSelection, openRecoveryProposal, parseReviewRows, pendingProposalTransition, recoveryProposalId, repositoryName, shouldShowAnalysisBanner, type AnyRecord } from './view-model';
 type RefreshState = 'idle' | 'loading' | 'succeeded' | 'failed';
 declare function injectStyles(): () => void;
 declare function refreshButtonLabel(state: RefreshState): string;
@@ -22,6 +22,14 @@ declare const plugin: {
         mutationCommand: typeof mutationCommand;
         appendCommandLog: typeof appendCommandLog;
         refreshButtonLabel: typeof refreshButtonLabel;
+        recoveryProposalId: typeof recoveryProposalId;
+        openRecoveryProposal: typeof openRecoveryProposal;
+        analysisProposalId: typeof analysisProposalId;
+        failureContext: typeof failureContext;
+        buildAgentRepairPrompt: typeof buildAgentRepairPrompt;
+        shouldShowAnalysisBanner: typeof shouldShowAnalysisBanner;
+        canDismissFailedProposal: typeof canDismissFailedProposal;
+        pendingProposalTransition: typeof pendingProposalTransition;
         isCurrentCommitRequest: typeof isCurrentCommitRequest;
         nextCommitSelection: typeof nextCommitSelection;
         commitFileTone: typeof commitFileTone;