dsh-git-ui 0.0.2 → 0.1.1

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,72 +532,311 @@ 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/contracts/host-endpoints.ts
+function createHostEndpoints(deps, config) {
+  return {
+    snapshot(request, signal) {
+      const merged = mergeSignals(deps.signal, signal);
+      const effectiveDeps = merged === deps.signal ? deps : { ...deps, signal: merged };
+      return snapshotForSession(effectiveDeps, config, request.sessionId);
+    },
+    run(request, signal) {
+      const merged = mergeSignals(deps.signal, signal);
+      const effectiveDeps = merged === deps.signal ? deps : { ...deps, signal: merged };
+      return runAction(effectiveDeps, config, request);
+    },
+    query(request, signal) {
+      const merged = mergeSignals(deps.signal, signal);
+      const effectiveDeps = merged === deps.signal ? deps : { ...deps, signal: merged };
+      return runQuery(effectiveDeps, config, request);
+    }
+  };
+}
+function mergeSignals(a, b) {
+  if (a === void 0) return b;
+  if (b === void 0) return a;
+  return AbortSignal.any([a, b]);
+}
+
 // 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);
-    __publicField(this, "config");
-    this.config = normalizeConfig(config);
+    __publicField(this, "endpoints");
+    const normalizedConfig = normalizeConfig(config);
+    const deps = this.buildDeps(ctx, normalizedConfig);
+    this.endpoints = createHostEndpoints(deps, normalizedConfig);
   }
-  /** Adapter face shared by both endpoints (injected services + runner). */
-  deps(signal) {
-    const subprocess = this.ctx.get("subprocess");
+  /** 将 Cordis 服务适配为结构化 SnapshotDeps。 */
+  buildDeps(ctx, config) {
+    const subprocess = ctx.get("subprocess");
     if (subprocess === void 0) {
-      return { failure: { code: "git-unavailable", detail: "subprocess service unavailable" } };
+      return {
+        run: { run: async () => {
+          throw new Error("subprocess service unavailable");
+        } },
+        fs: { realpath, stat },
+        sessions: { liveCwd: () => void 0, persistedMeta: async () => void 0 }
+      };
     }
-    const sessions = this.ctx.get("sessions");
-    const persistence = this.ctx.get("sessionPersistence");
-    const runner = createGitRunner(subprocess, this.config.timeoutMs, this.config.maxStatusBytes);
+    const sessions = ctx.get("sessions");
+    const persistence = ctx.get("sessionPersistence");
     return {
-      deps: {
-        run: runner,
-        fs: { realpath, stat },
-        sessions: {
-          liveCwd: (id) => sessions?.get(id)?.header?.cwd,
-          persistedMeta: async (id) => {
-            if (persistence === void 0) return void 0;
-            try {
-              const inspection = await persistence.inspect(id);
-              return { cwd: inspection.meta.cwd };
-            } catch {
-              return void 0;
-            }
+      run: createGitRunner(subprocess, config.timeoutMs, config.maxStatusBytes),
+      fs: { realpath, stat },
+      sessions: {
+        liveCwd: (id) => sessions?.get(id)?.header?.cwd,
+        persistedMeta: async (id) => {
+          if (persistence === void 0) return void 0;
+          try {
+            const inspection = await persistence.inspect(id);
+            return { cwd: inspection.meta.cwd };
+          } catch {
+            return void 0;
           }
-        },
-        signal
+        }
       }
     };
   }
   async snapshot(request, signal) {
-    const adapted = this.deps(signal);
-    if ("failure" in adapted) return { ok: false, error: adapted.failure };
-    return snapshotForSession(adapted.deps, this.config, request.sessionId);
+    return this.endpoints.snapshot(request, signal);
   }
   async run(request, signal) {
-    const adapted = this.deps(signal);
-    if ("failure" in adapted) {
-      return { ok: false, error: { code: "git-error", message: adapted.failure.detail } };
-    }
-    return runAction(adapted.deps, this.config, request);
+    return this.endpoints.run(request, signal);
+  }
+  async query(request, signal) {
+    return this.endpoints.query(request, signal);
   }
 };
 _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;
 export {
   DEFAULT_CONFIG,
   GitStatusService,
+  createHostEndpoints,
   index_default as default,
   isSafePath,
+  isValidBranchName,
   normalizeConfig,
   parseBranchOutput,
   parseLogOutput,
+  parseNameStatusOutput,
   parseStatusOutput,
-  runAction
+  runAction,
+  runQuery
 };
 //# sourceMappingURL=index.js.map