dsh-git-ui 0.0.2 → 0.1.0

package/lib/host/actions.d.ts

@@ -1,11 +1,31 @@
-import { type GitStatusConfig, type SnapshotDeps } from './core.ts';
-import type { GitActionResult, GitActionRequest } from './types.ts';
+import { resolveWorkspace, type GitStatusConfig, type SnapshotDeps } from './core.ts';
+import type { GitAction, GitActionResult, GitActionRequest, GitOperationErrorCode } from './types.ts';
+/**
+ * A branch name is valid when it matches git's ref-name grammar at the level
+ * we care about: non-empty, ASCII ref chars only, no leading `-` (option
+ * injection guard, though argv never shells out), no `..` (path traversal of
+ * refs), no trailing `/`, and no double slashes.
+ */
+export declare function isValidBranchName(name: string): boolean;
 /**
  * A path is safe when it is repo-relative and stays inside the work tree:
  * reject absolute paths, drive letters / backslashes, and `..` escapes
  * (checked via path resolution against the realpath'd root).
  */
 export declare function isSafePath(path: string, root: string): boolean;
+/** Map a snapshot-flow failure (which may carry git-unavailable) onto the operation error shape. */
+export declare function operationError(failure: Extract<Awaited<ReturnType<typeof resolveWorkspace>>, {
+    ok: false;
+}>['error']): GitActionResult & {
+    ok: false;
+};
+/**
+ * 把 git 命令失败归类为可预期的业务错误（其余保持 git-error）。
+ * 切分支被工作区未提交变更阻止是最常见的可预期失败：git 输出
+ * "would be overwritten by checkout"（或中文本地化 "将被 checkout 覆盖"），
+ * 归一化为 local-changes-block，client 据此给友好提示 + 处理变更引导。
+ */
+export declare function classifyOperationError(kind: GitAction['kind'], message: string): GitOperationErrorCode;
 /**
  * Execute one management action against the session's repository and return
  * the refreshed snapshot on success (the caller re-renders from it, so the

package/lib/host/core.d.ts

@@ -71,7 +71,13 @@ export declare function resolveWorkspace(deps: SnapshotDeps, sessionId: string):
  *   1. `git rev-parse --show-toplevel`      — repo detection (exit 128 → not-a-git-repo)
  *   2. `git branch --show-current`          — null when detached
  *   3. `git rev-parse --short HEAD`         — null + unborn when the repo has no commits
- *   4. `git status --porcelain=v1 -z --branch`
+ *   4. `git status --porcelain=v1 -z --branch --untracked-files=all`
  *   5. `git log -n 5 --format=%H%x1f%h%x1f%s%x1f%an%x1f%aI`
+ *
+ * --untracked-files=all：git 默认 normal 模式会把整目录未跟踪折叠为单条
+ * `?? dir/`（尾斜杠）且不枚举其内部文件——隐藏目录（.agent/.tianqi 等）的
+ * 变更因此从不进入变更清单。`all` 强制逐文件枚举（与 IDEA / VSCode 一致），
+ * 内部文件得以展示；maxChanges 截断列表、maxStatusBytes spill 保计数精确，
+ * 超大未跟踪树（如未 gitignore 的构建产物）经此路径优雅降级。
  */
 export declare function snapshotForSession(deps: SnapshotDeps, config: GitStatusConfig, sessionId: string): Promise<GitSnapshotResult>;

package/lib/host/index.d.ts

@@ -1,20 +1,21 @@
 /**
  * dsh-git-ui host half: the `gitInfo` Remote service.
  *
- * Cordis shell only — every behavior lives in `core.ts`/`actions.ts` behind
- * injected structural faces, so tests never need a cordis runtime. The class
- * is a plugin in its own right (class form), mounted by the bundle patch row
- * with the package name; the gateway exposes `gitInfo/snapshot` and
- * `gitInfo/run` through SRC discovery (`typertRemote` binding + `@Remote`
- * marker).
+ * Cordis shell only — every behavior lives in `core.ts`/`actions.ts`/
+ * `queries.ts` behind injected structural faces, so tests never need a
+ * cordis runtime. The class is a plugin in its own right (class form),
+ * mounted by the bundle patch row with the package name; the gateway exposes
+ * `gitInfo/snapshot`, `gitInfo/run` and `gitInfo/query` through SRC
+ * discovery (`typertRemote` binding + `@Remote` marker).
  */
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { Context } from '@deepseek-ai/cordis';
-import type { GitActionResult, GitActionRequest, GitSnapshotRequest, GitSnapshotResult } from './types.ts';
-export type { GitSnapshot, GitSnapshotResult, GitSnapshotFailure, GitSnapshotRequest, GitCommit, GitChange, GitAction, GitActionResult, GitActionRequest } from './types.ts';
+import type { GitActionResult, GitActionRequest, GitQueryRequest, GitQueryResponse, GitSnapshotRequest, GitSnapshotResult } from './types.ts';
+export type { GitSnapshot, GitSnapshotResult, GitSnapshotFailure, GitSnapshotRequest, GitCommit, GitChange, GitAction, GitActionResult, GitActionRequest, GitQuery, GitQueryResult, GitQueryRequest, GitQueryResponse, GitBranch, GitFileStat, GitRef } from './types.ts';
 export { normalizeConfig, DEFAULT_CONFIG } from './core.ts';
-export { parseStatusOutput, parseLogOutput, parseBranchOutput } from './parser.ts';
-export { isSafePath, runAction } from './actions.ts';
+export { parseStatusOutput, parseLogOutput, parseBranchOutput, parseNameStatusOutput } from './parser.ts';
+export { isSafePath, isValidBranchName, runAction } from './actions.ts';
+export { runQuery } from './queries.ts';
 /** The `gitInfo` service: `snapshot` (read) and `run` (management) endpoints. */
 export declare class GitStatusService extends TypertRemoteService {
     static inject: string[];
@@ -24,5 +25,6 @@ export declare class GitStatusService extends TypertRemoteService {
     private deps;
     snapshot(request: GitSnapshotRequest, signal?: AbortSignal): Promise<GitSnapshotResult>;
     run(request: GitActionRequest, signal?: AbortSignal): Promise<GitActionResult>;
+    query(request: GitQueryRequest, signal?: AbortSignal): Promise<GitQueryResponse>;
 }
 export default GitStatusService;

package/lib/host/index.js

@@ -136,10 +136,8 @@ function parseStatusHeader(line) {
   const branch = core.split("...", 1)[0] ?? core;
   return { branch: branch === "" ? null : branch, unborn: false, ahead, behind };
 }
-function changeStatus(x, y) {
-  if (x === "?" && y === "?") return "untracked";
-  if (x === "U" || y === "U" || x !== " " && y !== " ") return "conflicted";
-  switch (x) {
+function singleStatus(code) {
+  switch (code) {
     case "A":
       return "added";
     case "M":
@@ -156,6 +154,9 @@ function changeStatus(x, y) {
       return "modified";
   }
 }
+function isConflicted(x, y) {
+  return x === "U" || y === "U" || x === "A" && y === "A" || x === "D" && y === "D";
+}
 function parseStatusOutput(output, maxChanges) {
   const raw = output.split(NUL);
   const segments = raw[raw.length - 1] === "" ? raw.slice(0, -1) : raw;
@@ -165,6 +166,13 @@ function parseStatusOutput(output, maxChanges) {
   let untracked = 0;
   const changes = [];
   let truncated = false;
+  const pushChange = (path, status, isStaged) => {
+    if (changes.length < maxChanges) {
+      changes.push({ path, status, staged: isStaged, isDirectory: path.endsWith("/") });
+    } else {
+      truncated = true;
+    }
+  };
   for (let index = 1; index < segments.length; index += 1) {
     const entry = segments[index] ?? "";
     const x = entry[0] ?? " ";
@@ -176,14 +184,19 @@ function parseStatusOutput(output, maxChanges) {
     }
     if (x === "?" && y === "?") {
       untracked += 1;
-    } else {
-      if (x !== " " && x !== "?") staged += 1;
-      if (y !== " " && y !== "?") modified += 1;
+      pushChange(path, "untracked", false);
+      continue;
     }
-    if (changes.length < maxChanges) {
-      changes.push({ path, status: changeStatus(x, y), staged: x !== " " && x !== "?" });
+    if (x !== " " && x !== "?") staged += 1;
+    if (y !== " " && y !== "?") modified += 1;
+    if (isConflicted(x, y)) {
+      pushChange(path, "conflicted", true);
+    } else if (x !== " " && y !== " ") {
+      pushChange(path, singleStatus(x), true);
+      pushChange(path, singleStatus(y), false);
     } else {
-      truncated = true;
+      const isStaged = x !== " ";
+      pushChange(path, singleStatus(isStaged ? x : y), isStaged);
     }
   }
   return {
@@ -214,6 +227,92 @@ function parseLogOutput(output) {
   }
   return commits;
 }
+function parseGraphLogOutput(output, remotes = []) {
+  const commits = [];
+  for (const line of output.split("\n")) {
+    if (line === "") continue;
+    const [hash, shortHash, subject, author, dateIso, parentField, decoField] = line.split(LOG_SEP);
+    if (hash === void 0 || hash === "") continue;
+    const parents = (parentField ?? "").split(" ").filter((p) => p !== "");
+    commits.push({
+      hash,
+      shortHash: shortHash ?? "",
+      subject: subject ?? "",
+      author: author ?? "",
+      dateIso: dateIso ?? "",
+      parents,
+      refs: parseDecorations(decoField ?? "", remotes)
+    });
+  }
+  return commits;
+}
+function parseDecorations(decorations, remotes) {
+  const trimmed = decorations.trim();
+  if (trimmed === "") return [];
+  const refs = [];
+  for (const token of trimmed.split(", ")) {
+    if (token.startsWith("HEAD -> ")) {
+      refs.push({ kind: "branch", name: token.slice(8), head: true });
+    } else if (token.startsWith("tag: ")) {
+      refs.push({ kind: "tag", name: token.slice(5), head: false });
+    } else if (remotes.some((remote) => token === remote || token.startsWith(`${remote}/`))) {
+      refs.push({ kind: "remote", name: token, head: false });
+    } else {
+      refs.push({ kind: "branch", name: token, head: false });
+    }
+  }
+  return refs;
+}
+function parseShowMeta(output) {
+  const trimmed = output.trimEnd();
+  if (trimmed === "") return null;
+  const [hash, shortHash, subject, author, dateIso, ...bodyParts] = trimmed.split(LOG_SEP);
+  if (hash === void 0 || hash === "") return null;
+  return {
+    commit: {
+      hash,
+      shortHash: shortHash ?? "",
+      subject: subject ?? "",
+      author: author ?? "",
+      dateIso: dateIso ?? ""
+    },
+    body: bodyParts.join(LOG_SEP).trimEnd()
+  };
+}
+function nameStatusCode(code) {
+  switch (code) {
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "T":
+      return "typechange";
+    case "U":
+      return "conflicted";
+    default:
+      return "modified";
+  }
+}
+function parseNameStatusOutput(output) {
+  const raw = output.split(NUL);
+  const segments = raw[raw.length - 1] === "" ? raw.slice(0, -1) : raw;
+  const rows = [];
+  for (let i = 0; i < segments.length; i += 1) {
+    const entry = segments[i] ?? "";
+    if (entry === "") continue;
+    const code = entry[0] ?? " ";
+    if (code === "R" || code === "C") {
+      rows.push({ path: segments[i + 2] ?? "", status: nameStatusCode(code) });
+      i += 2;
+    } else {
+      rows.push({ path: segments[i + 1] ?? "", status: nameStatusCode(code) });
+      i += 1;
+    }
+  }
+  return rows;
+}
 function parseBranchOutput(output) {
   const trimmed = output.trim();
   return trimmed === "" ? null : trimmed;
@@ -296,7 +395,7 @@ async function snapshotForSession(deps, config, sessionId) {
   if ("failure" in headRun) return { ok: false, error: headRun.failure };
   if (headRun.run.timedOut) return { ok: false, error: { code: "timeout" } };
   const head = headRun.run.exitCode === 0 ? headRun.run.stdout.trim() || null : null;
-  const status = await runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--branch"], root, "status", deps.signal);
+  const status = await runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--branch", "--untracked-files=all"], root, "status", deps.signal);
   if ("failure" in status) return { ok: false, error: status.failure };
   if (status.run.timedOut) return { ok: false, error: { code: "timeout" } };
   if (status.run.exitCode !== 0) {
@@ -334,15 +433,15 @@ import { resolve, sep } from "node:path";
 function buildArgv(action, root) {
   switch (action.kind) {
     case "stage":
-      return withPaths(["git", "add", "--"], action.paths, root);
+      return withPaths([["git", "add", "--"]], action.paths, root);
     case "stage-all":
       return { argv: [["git", "add", "-A"]] };
     case "unstage":
-      return withPaths(["git", "restore", "--staged", "--"], action.paths, root);
+      return withPaths([["git", "restore", "--staged", "--"]], action.paths, root);
     case "unstage-all":
       return { argv: [["git", "restore", "--staged", "--", "."]] };
     case "discard":
-      return withPaths(["git", "restore", "--"], action.paths, root);
+      return withPaths([["git", "restore", "--"]], action.paths, root);
     case "discard-all":
       return { argv: [["git", "restore", "--staged", "--", "."], ["git", "restore", "--", "."]] };
     case "commit": {
@@ -350,16 +449,30 @@ function buildArgv(action, root) {
       if (action.paths === void 0 || action.paths.length === 0) {
         return { argv: [["git", "commit", "-m", message]] };
       }
-      return withPaths(["git", "commit", "-m", message, "--"], action.paths, root);
+      return withPaths([["git", "add", "--"], ["git", "commit", "-m", message, "--"]], action.paths, root);
+    }
+    case "branch-create": {
+      const from = action.from === void 0 || action.from === "" ? [] : [action.from];
+      return { argv: [["git", "branch", action.name, ...from]] };
     }
+    case "branch-checkout":
+      return { argv: [["git", "checkout", action.name]] };
+    case "branch-delete":
+      return { argv: [["git", "branch", action.force === true ? "-D" : "-d", action.name]] };
+    case "fetch":
+      return { argv: [["git", "fetch", "--all", "--prune"]] };
   }
 }
-function withPaths(prefix, paths, root) {
+function isValidBranchName(name) {
+  if (name === "" || name.startsWith("-") || name.includes("..") || name.endsWith("/") || name.includes("//")) return false;
+  return /^[A-Za-z0-9._/-]+$/.test(name);
+}
+function withPaths(prefixes, paths, root) {
   if (paths.length === 0) return { error: "no paths given" };
   for (const path of paths) {
     if (!isSafePath(path, root)) return { error: `unsafe path: ${path}` };
   }
-  return { argv: [[...prefix, ...paths]] };
+  return { argv: prefixes.map((prefix) => [...prefix, ...paths]) };
 }
 function isSafePath(path, root) {
   if (path === "") return false;
@@ -374,6 +487,12 @@ function operationError(failure) {
   }
   return { ok: false, error: failure };
 }
+function classifyOperationError(kind, message) {
+  if (kind === "branch-checkout" && /would be overwritten by checkout|将被 checkout 覆盖|有未跟踪工作区文件将会被 checkout 覆盖/i.test(message)) {
+    return "local-changes-block";
+  }
+  return "git-error";
+}
 async function runAction(deps, config, request) {
   const workspace = await resolveWorkspace(deps, request.sessionId);
   if (!workspace.ok) return operationError(workspace.error);
@@ -381,6 +500,13 @@ async function runAction(deps, config, request) {
   if (request.action.kind === "commit" && request.action.message.trim() === "") {
     return { ok: false, error: { code: "git-error", message: "commit message is empty" } };
   }
+  const kind = request.action.kind;
+  if (kind === "branch-create" || kind === "branch-checkout" || kind === "branch-delete") {
+    const name = request.action.name;
+    if (!isValidBranchName(name)) {
+      return { ok: false, error: { code: "invalid-name", message: `invalid branch name: ${name}` } };
+    }
+  }
   const built = buildArgv(request.action, root);
   if ("error" in built) return { ok: false, error: { code: "invalid-path", message: built.error } };
   let lastStdout = "";
@@ -390,10 +516,11 @@ async function runAction(deps, config, request) {
     if (outcome.run.timedOut) return { ok: false, error: { code: "timeout" } };
     if (outcome.run.exitCode !== 0) {
       const message = outcome.run.stderr.trim() || outcome.run.stdout.trim();
+      const code = classifyOperationError(request.action.kind, message);
       return {
         ok: false,
         error: {
-          code: "git-error",
+          code,
           message: message !== "" ? message : `git ${request.action.kind} exited ${String(outcome.run.exitCode)}`
         }
       };
@@ -405,9 +532,216 @@ async function runAction(deps, config, request) {
   return { ok: true, snapshot: snapshot.value, ...lastStdout === "" ? {} : { output: lastStdout } };
 }
 
+// src/host/queries.ts
+var LOG_FORMAT = "%H%x1f%h%x1f%s%x1f%an%x1f%aI";
+var GRAPH_FORMAT = "%H%x1f%h%x1f%s%x1f%an%x1f%aI%x1f%P%x1f%D";
+var MAX_HISTORY_LIMIT = 1e3;
+function isValidRef(ref) {
+  return ref !== "" && !/\s/.test(ref);
+}
+async function runQuery(deps, config, request) {
+  void config;
+  const workspace = await resolveWorkspace(deps, request.sessionId);
+  if (!workspace.ok) return { ok: false, error: operationError(workspace.error).error };
+  const root = workspace.root;
+  const query = request.query;
+  switch (query.kind) {
+    case "history":
+      return historyQuery(deps, root, query);
+    case "diff":
+      return diffQuery(deps, root, query.path, query.base);
+    case "show":
+      return showQuery(deps, root, query.ref);
+    case "branches":
+      return branchesQuery(deps, root);
+    case "tags":
+      return tagsQuery(deps, root);
+    case "authors":
+      return authorsQuery(deps, root);
+  }
+}
+async function historyQuery(deps, root, query) {
+  const safeLimit = Math.min(Math.max(Math.floor(query.limit), 0), MAX_HISTORY_LIMIT);
+  const safeSkip = Math.max(Math.floor(query.skip), 0);
+  if (query.ref !== void 0 && !isValidRef(query.ref)) {
+    return { ok: false, error: { code: "invalid-name", message: `invalid ref: ${query.ref}` } };
+  }
+  const search = query.search?.trim() ?? "";
+  const hexLike = /^[0-9a-f]{7,40}$/i.test(search);
+  const scope = hexLike ? [] : query.ref === void 0 ? ["--all"] : [query.ref];
+  const noWalk = hexLike ? ["--no-walk", search] : [];
+  const filters = [];
+  if (search !== "" && !hexLike) filters.push("--regexp-ignore-case", "--extended-regexp", `--grep=${search}`);
+  const author = query.author?.trim() ?? "";
+  if (author !== "") filters.push(`--author=${author}`);
+  const since = query.since?.trim() ?? "";
+  if (since !== "") filters.push(`--since=${since}`);
+  const log = await runCommand(
+    deps.run,
+    // -n/--skip 前置：git 的 `-n N` 出现在 `--no-walk` 之后会重置 no-walk
+    // （hexLike 会错误列出全部祖先），前置则 `-n 1000 --no-walk x` 恒返回单条。
+    ["git", "log", ...filters, `--skip=${String(safeSkip)}`, "-n", String(safeLimit), ...noWalk, ...scope, `--format=${GRAPH_FORMAT}`],
+    root,
+    "log",
+    deps.signal
+  );
+  if ("failure" in log) return { ok: false, error: operationError(log.failure).error };
+  if (log.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (log.run.exitCode !== 0) {
+    if (log.run.stderr.includes("does not have any commits")) {
+      return { ok: true, value: { kind: "history", commits: [], total: 0 } };
+    }
+    if (hexLike && /unknown revision|bad revision|ambiguous/i.test(log.run.stderr)) {
+      return { ok: true, value: { kind: "history", commits: [], total: 0 } };
+    }
+    return gitError("log", log.run.stderr, log.run.stdout);
+  }
+  let total = 0;
+  const count = await runCommand(deps.run, ["git", "rev-list", "--count", ...noWalk, ...scope, ...filters], root, "rev-list", deps.signal);
+  if ("run" in count && count.run.exitCode === 0) {
+    const parsed = Number(count.run.stdout.trim());
+    if (Number.isFinite(parsed) && parsed >= 0) total = parsed;
+  }
+  let remotes = [];
+  const remoteRun = await runCommand(deps.run, ["git", "remote"], root, "remote", deps.signal);
+  if ("run" in remoteRun && remoteRun.run.exitCode === 0) {
+    remotes = remoteRun.run.stdout.split("\n").map((s) => s.trim()).filter((s) => s !== "");
+  }
+  return { ok: true, value: { kind: "history", commits: parseGraphLogOutput(log.run.stdout, remotes), total } };
+}
+async function diffQuery(deps, root, path, base) {
+  if (!isSafePath(path, root)) return { ok: false, error: { code: "invalid-path", message: `unsafe path: ${path}` } };
+  const argv = base === "staged" ? ["git", "diff", "--cached", "-U999999", "--", path] : ["git", "diff", "-U999999", "--", path];
+  const run = await runCommand(deps.run, argv, root, "diff", deps.signal);
+  if ("failure" in run) return { ok: false, error: operationError(run.failure).error };
+  if (run.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (run.run.exitCode !== 0) return gitError("diff", run.run.stderr, run.run.stdout);
+  if (run.run.stdout !== "" || base === "staged") {
+    return { ok: true, value: { kind: "diff", path, text: run.run.stdout } };
+  }
+  const ni = await runCommand(deps.run, ["git", "diff", "--no-index", "-U999999", "--", "/dev/null", path], root, "diff --no-index", deps.signal);
+  if ("failure" in ni) return { ok: false, error: operationError(ni.failure).error };
+  if (ni.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (ni.run.exitCode !== 0 && ni.run.exitCode !== 1) return gitError("diff", ni.run.stderr, ni.run.stdout);
+  return { ok: true, value: { kind: "diff", path, text: ni.run.stdout } };
+}
+async function showQuery(deps, root, ref) {
+  if (!isValidRef(ref)) return { ok: false, error: { code: "invalid-name", message: `invalid ref: ${ref}` } };
+  const meta = await runCommand(
+    deps.run,
+    ["git", "show", "-s", `--format=${LOG_FORMAT}%x1f%b`, ref],
+    root,
+    "show",
+    deps.signal
+  );
+  if ("failure" in meta) return { ok: false, error: operationError(meta.failure).error };
+  if (meta.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (meta.run.exitCode !== 0) return gitError("show", meta.run.stderr, meta.run.stdout);
+  const stat2 = await runCommand(
+    deps.run,
+    ["git", "-c", "core.quotePath=false", "show", "--format=", "--name-status", "-z", ref],
+    root,
+    "show --name-status",
+    deps.signal
+  );
+  if ("failure" in stat2) return { ok: false, error: operationError(stat2.failure).error };
+  if (stat2.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (stat2.run.exitCode !== 0) return gitError("show", stat2.run.stderr, stat2.run.stdout);
+  const parsed = parseShowMeta(meta.run.stdout);
+  return {
+    ok: true,
+    value: {
+      kind: "show",
+      ref,
+      commit: parsed?.commit ?? null,
+      body: parsed?.body ?? "",
+      stats: parseNameStatusOutput(stat2.run.stdout)
+    }
+  };
+}
+async function authorsQuery(deps, root) {
+  const run = await runCommand(deps.run, ["git", "log", "--all", "-n", "1000", "--format=%an"], root, "log authors", deps.signal);
+  if ("failure" in run) return { ok: false, error: operationError(run.failure).error };
+  if (run.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (run.run.exitCode !== 0) return { ok: true, value: { kind: "authors", authors: [] } };
+  const authors = [...new Set(run.run.stdout.split("\n").map((s) => s.trim()).filter((s) => s !== ""))].sort().slice(0, 100);
+  return { ok: true, value: { kind: "authors", authors } };
+}
+async function tagsQuery(deps, root) {
+  const FORMAT = "--format=%(refname:short)%09%(objectname:short)";
+  const run = await runCommand(deps.run, ["git", "tag", FORMAT], root, "tag", deps.signal);
+  if ("failure" in run) return { ok: false, error: operationError(run.failure).error };
+  if (run.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (run.run.exitCode !== 0) return gitError("tag", run.run.stderr, run.run.stdout);
+  return { ok: true, value: { kind: "tags", tags: parseBranchList(run.run.stdout) } };
+}
+async function branchesQuery(deps, root) {
+  const LOCAL_FORMAT = "--format=%(refname:short)%09%(objectname:short)%09%(upstream:short)%09%(upstream:track)";
+  const REMOTE_FORMAT = "--format=%(refname:short)%09%(objectname:short)";
+  const local = await runCommand(deps.run, ["git", "branch", LOCAL_FORMAT], root, "branch", deps.signal);
+  if ("failure" in local) return { ok: false, error: operationError(local.failure).error };
+  if (local.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (local.run.exitCode !== 0) return gitError("branch", local.run.stderr, local.run.stdout);
+  const remote = await runCommand(deps.run, ["git", "branch", "-r", REMOTE_FORMAT], root, "branch -r", deps.signal);
+  if ("failure" in remote) return { ok: false, error: operationError(remote.failure).error };
+  if (remote.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (remote.run.exitCode !== 0) return gitError("branch -r", remote.run.stderr, remote.run.stdout);
+  const current = await runCommand(deps.run, ["git", "branch", "--show-current"], root, "branch", deps.signal);
+  const currentName = "run" in current && current.run.exitCode === 0 ? parseBranchOutput(current.run.stdout) : null;
+  let defaultBranch = null;
+  const def = await runCommand(deps.run, ["git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], root, "symbolic-ref", deps.signal);
+  if ("run" in def && def.run.exitCode === 0) {
+    const value = def.run.stdout.trim();
+    const slash = value.indexOf("/");
+    defaultBranch = value === "" ? null : slash === -1 ? value : value.slice(slash + 1);
+  }
+  return {
+    ok: true,
+    value: {
+      kind: "branches",
+      current: currentName,
+      defaultBranch,
+      local: parseBranchList(local.run.stdout),
+      remote: parseBranchList(remote.run.stdout).filter((branch) => !branch.name.endsWith("/HEAD"))
+    }
+  };
+}
+function parseBranchList(output) {
+  const branches = [];
+  for (const line of output.split("\n")) {
+    if (line === "") continue;
+    const parts = line.split("	");
+    const name = parts[0];
+    const hash = parts[1];
+    if (name === void 0 || name === "") continue;
+    const track = parts[3] ?? "";
+    const aheadMatch = /ahead (\d+)/.exec(track);
+    const behindMatch = /behind (\d+)/.exec(track);
+    const ahead = aheadMatch ? Number(aheadMatch[1]) : 0;
+    const behind = behindMatch ? Number(behindMatch[1]) : 0;
+    branches.push({
+      name,
+      shortHash: hash === void 0 || hash === "" ? null : hash,
+      ...ahead > 0 ? { ahead } : {},
+      ...behind > 0 ? { behind } : {}
+    });
+  }
+  return branches;
+}
+function gitError(label, stderr, stdout) {
+  const message = stderr.trim() || stdout.trim();
+  return {
+    ok: false,
+    error: {
+      code: "git-error",
+      message: message !== "" ? message : `git ${label} failed`
+    }
+  };
+}
+
 // src/host/index.ts
-var _run_dec, _snapshot_dec, _a, _init;
-var GitStatusService = class extends (_a = TypertRemoteService, _snapshot_dec = [Remote("snapshot")], _run_dec = [Remote("run")], _a) {
+var _query_dec, _run_dec, _snapshot_dec, _a, _init;
+var GitStatusService = class extends (_a = TypertRemoteService, _snapshot_dec = [Remote("snapshot")], _run_dec = [Remote("run")], _query_dec = [Remote("query")], _a) {
   constructor(ctx, config) {
     super(ctx, "gitInfo");
     __runInitializers(_init, 5, this);
@@ -455,10 +789,18 @@ var GitStatusService = class extends (_a = TypertRemoteService, _snapshot_dec =
     }
     return runAction(adapted.deps, this.config, request);
   }
+  async query(request, signal) {
+    const adapted = this.deps(signal);
+    if ("failure" in adapted) {
+      return { ok: false, error: { code: "git-error", message: adapted.failure.detail } };
+    }
+    return runQuery(adapted.deps, this.config, request);
+  }
 };
 _init = __decoratorStart(_a);
 __decorateElement(_init, 1, "snapshot", _snapshot_dec, GitStatusService);
 __decorateElement(_init, 1, "run", _run_dec, GitStatusService);
+__decorateElement(_init, 1, "query", _query_dec, GitStatusService);
 __decoratorMetadata(_init, GitStatusService);
 __publicField(GitStatusService, "inject", ["subprocess", "sessions", "sessionPersistence"]);
 var index_default = GitStatusService;
@@ -467,10 +809,13 @@ export {
   GitStatusService,
   index_default as default,
   isSafePath,
+  isValidBranchName,
   normalizeConfig,
   parseBranchOutput,
   parseLogOutput,
+  parseNameStatusOutput,
   parseStatusOutput,
-  runAction
+  runAction,
+  runQuery
 };
 //# sourceMappingURL=index.js.map