@linghun/tui 0.1.0

package/dist/chunk-4EIC5BCT.js

@@ -0,0 +1,475 @@
+import {
+  createGitRunner,
+  readGitStatus,
+  readWorktreeList
+} from "./chunk-AO4CXI37.js";
+
+// src/git-operation-runtime.ts
+import { mkdir } from "fs/promises";
+import { basename, dirname, isAbsolute, join } from "path";
+var GIT_MUTATION_TIMEOUT_MS = 2e4;
+var defaultMutatingRunner = createGitRunner(GIT_MUTATION_TIMEOUT_MS);
+var MAX_STABLE_POINT_MESSAGE_LENGTH = 200;
+var MAX_WORKTREE_NAME_LENGTH = 64;
+var MAX_GIT_REF_LENGTH = 200;
+var VALID_WORKTREE_NAME = /^[A-Za-z0-9._-]+$/u;
+var VALID_GIT_REF = /^[A-Za-z0-9._/-]+$/u;
+function hasControlChar(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 32 || code >= 127 && code <= 159) {
+      return true;
+    }
+  }
+  return false;
+}
+function validateStablePointMessage(message) {
+  const trimmed = message.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "stable point message \u4E0D\u80FD\u4E3A\u7A7A\u3002" };
+  }
+  if (trimmed.length > MAX_STABLE_POINT_MESSAGE_LENGTH) {
+    return {
+      ok: false,
+      reason: `stable point message \u8FC7\u957F\uFF08\u6700\u591A ${MAX_STABLE_POINT_MESSAGE_LENGTH} \u5B57\u7B26\uFF09\u3002`
+    };
+  }
+  if (hasControlChar(trimmed)) {
+    return { ok: false, reason: "stable point message \u4E0D\u80FD\u5305\u542B\u6362\u884C\u6216\u63A7\u5236\u5B57\u7B26\u3002" };
+  }
+  return { ok: true, message: trimmed };
+}
+function pad2(value) {
+  return value < 10 ? `0${value}` : String(value);
+}
+function defaultStablePointMessage(now = /* @__PURE__ */ new Date()) {
+  const date = `${now.getFullYear()}-${pad2(now.getMonth() + 1)}-${pad2(now.getDate())}`;
+  const time = `${pad2(now.getHours())}:${pad2(now.getMinutes())}`;
+  return `chore: stable point ${date} ${time}`;
+}
+function validateWorktreeName(name) {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "worktree \u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A\u3002" };
+  }
+  if (trimmed.length > MAX_WORKTREE_NAME_LENGTH) {
+    return {
+      ok: false,
+      reason: `worktree \u540D\u79F0\u8FC7\u957F\uFF08\u6700\u591A ${MAX_WORKTREE_NAME_LENGTH} \u5B57\u7B26\uFF09\u3002`
+    };
+  }
+  if (hasControlChar(trimmed)) {
+    return { ok: false, reason: "worktree \u540D\u79F0\u4E0D\u80FD\u5305\u542B\u63A7\u5236\u5B57\u7B26\u3002" };
+  }
+  if (trimmed === "." || trimmed === "..") {
+    return { ok: false, reason: 'worktree \u540D\u79F0\u4E0D\u80FD\u662F "." \u6216 ".."\u3002' };
+  }
+  if (/[\\/]/u.test(trimmed)) {
+    return { ok: false, reason: "worktree \u540D\u79F0\u4E0D\u80FD\u5305\u542B / \u6216 \\\u3002" };
+  }
+  if (/:/u.test(trimmed)) {
+    return { ok: false, reason: "worktree \u540D\u79F0\u4E0D\u80FD\u5305\u542B\u76D8\u7B26\u6216\u5192\u53F7\u3002" };
+  }
+  if (!VALID_WORKTREE_NAME.test(trimmed)) {
+    return {
+      ok: false,
+      reason: "worktree \u540D\u79F0\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u4E0B\u5212\u7EBF\u548C\u8FDE\u5B57\u7B26\u3002"
+    };
+  }
+  return { ok: true, slug: trimmed, displayName: trimmed };
+}
+function validateGitRef(ref) {
+  const trimmed = ref.trim();
+  if (trimmed.length === 0) {
+    return { ok: false, reason: "git ref \u4E0D\u80FD\u4E3A\u7A7A\u3002" };
+  }
+  if (trimmed.length > MAX_GIT_REF_LENGTH) {
+    return { ok: false, reason: "git ref \u8FC7\u957F\u3002" };
+  }
+  if (hasControlChar(trimmed) || /\s/u.test(trimmed)) {
+    return { ok: false, reason: "git ref \u4E0D\u80FD\u5305\u542B\u7A7A\u767D\u6216\u63A7\u5236\u5B57\u7B26\u3002" };
+  }
+  if (trimmed.startsWith("-")) {
+    return { ok: false, reason: "git ref \u4E0D\u80FD\u4EE5 - \u5F00\u5934\u3002" };
+  }
+  if (trimmed.includes("..")) {
+    return { ok: false, reason: 'git ref \u4E0D\u80FD\u5305\u542B ".."\u3002' };
+  }
+  if (trimmed.endsWith("/") || trimmed.endsWith(".lock")) {
+    return { ok: false, reason: "git ref \u5F62\u6001\u975E\u6CD5\u3002" };
+  }
+  if (!VALID_GIT_REF.test(trimmed)) {
+    return {
+      ok: false,
+      reason: "git ref \u542B\u975E\u6CD5\u5B57\u7B26\uFF1B\u53EA\u5141\u8BB8\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u4E0B\u5212\u7EBF\u3001\u659C\u6760\u548C\u8FDE\u5B57\u7B26\u3002"
+    };
+  }
+  return { ok: true, ref: trimmed };
+}
+var MANAGED_WORKTREE_DIRNAME = ".linghun-worktrees";
+function sanitizeRepoSlug(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9._-]/gu, "-").replace(/^-+|-+$/gu, "");
+  return cleaned.length > 0 ? cleaned : "repo";
+}
+function resolveManagedWorktreeRoot(repoRoot) {
+  const slug = sanitizeRepoSlug(basename(repoRoot.replace(/[\\/]+$/u, "")));
+  return join(dirname(repoRoot), MANAGED_WORKTREE_DIRNAME, slug);
+}
+function managedWorktreePath(repoRoot, slug) {
+  return join(resolveManagedWorktreeRoot(repoRoot), slug);
+}
+function normalizePath(value) {
+  return value.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
+}
+function isUnderManagedRoot(repoRoot, candidatePath) {
+  const root = normalizePath(resolveManagedWorktreeRoot(repoRoot));
+  const target = normalizePath(candidatePath);
+  return target === root || target.startsWith(`${root}/`);
+}
+function redactWorktreePath(absolutePath) {
+  const normalized = absolutePath.replace(/\\/gu, "/").replace(/\/+$/u, "");
+  const idx = normalized.lastIndexOf(`/${MANAGED_WORKTREE_DIRNAME}/`);
+  if (idx >= 0) {
+    return normalized.slice(idx + 1);
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.length <= 2) return normalized;
+  return `\u2026/${segments.slice(-2).join("/")}`;
+}
+var SENSITIVE_UNTRACKED_PATTERNS = [
+  /(?:^|\/)\.env(?:\.|$)/iu,
+  /\.env$/iu,
+  /(?:^|\/)provider\.env$/iu,
+  /key|token|secret|password|credential/iu,
+  /(?:^|\/)\.git(?:\/|$)/iu,
+  /(?:^|\/)node_modules(?:\/|$)/iu,
+  /(?:^|\/)dist(?:\/|$)/iu,
+  /\.pem$|\.key$|id_rsa/iu
+];
+function isSensitiveUntrackedPath(path) {
+  const normalized = path.replace(/\\/gu, "/");
+  return SENSITIVE_UNTRACKED_PATTERNS.some((re) => re.test(normalized));
+}
+function filterUntrackedForCommit(untracked) {
+  const included = [];
+  const rejected = [];
+  for (const path of untracked) {
+    if (isSensitiveUntrackedPath(path)) {
+      rejected.push(path);
+    } else {
+      included.push(path);
+    }
+  }
+  return { included, rejected };
+}
+function summarizeRejectedUntracked(rejected) {
+  return rejected.slice(0, 8).map((path) => {
+    const name = path.replace(/\\/gu, "/").split("/").pop() ?? path;
+    return `${name} (sensitive/ignored)`;
+  });
+}
+function uniquePaths(...lists) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const list of lists) {
+    for (const path of list) {
+      if (!seen.has(path)) {
+        seen.add(path);
+        out.push(path);
+      }
+    }
+  }
+  return out;
+}
+async function createGitStablePoint(cwd, options, runner = defaultMutatingRunner) {
+  const status = await readGitStatus(cwd, runner);
+  if (status.kind === "not_a_git_repo") {
+    return { kind: "not_a_git_repo" };
+  }
+  if (status.kind === "git_unavailable") {
+    return { kind: "git_unavailable", reason: status.error };
+  }
+  if (status.changedCount === 0 && status.untrackedCount === 0) {
+    return {
+      kind: "skipped",
+      reason: "\u5DE5\u4F5C\u533A\u5E72\u51C0\uFF0C\u6CA1\u6709\u53EF\u63D0\u4EA4\u7684\u6539\u52A8\uFF1B\u672A\u521B\u5EFA\u7A7A commit\u3002",
+      branch: status.branch,
+      head: status.headShort
+    };
+  }
+  const includeUntracked = options.includeUntracked === true;
+  const tracked = uniquePaths(status.staged, status.unstaged);
+  let included = [];
+  let rejected = [];
+  if (includeUntracked) {
+    const filtered = filterUntrackedForCommit(status.untracked);
+    included = filtered.included;
+    rejected = filtered.rejected;
+  }
+  const toCommit = uniquePaths(tracked, included);
+  if (toCommit.length === 0) {
+    return {
+      kind: "snapshot",
+      reason: includeUntracked ? "include_untracked_empty" : "untracked_only_not_included"
+    };
+  }
+  const toplevelResult = await runner(cwd, ["rev-parse", "--show-toplevel"]);
+  const repoRoot = toplevelResult.ok && toplevelResult.stdout.trim() ? toplevelResult.stdout.trim() : cwd;
+  const addResult = await runner(repoRoot, ["add", "--", ...toCommit]);
+  if (!addResult.ok) {
+    return { kind: "failed", reason: addResult.stderr || "git add \u5931\u8D25" };
+  }
+  const commitResult = await runner(repoRoot, ["commit", "-m", options.message, "--", ...toCommit]);
+  if (!commitResult.ok) {
+    return { kind: "failed", reason: commitResult.stderr || "git commit \u5931\u8D25" };
+  }
+  const headResult = await runner(repoRoot, ["log", "-1", "--format=%h	%s"]);
+  let sha = "";
+  let subject = options.message;
+  if (headResult.ok) {
+    const [shaPart, ...rest] = headResult.stdout.split("	");
+    if (shaPart) sha = shaPart.trim();
+    if (rest.length > 0) subject = rest.join("	");
+  }
+  return {
+    kind: "git_commit",
+    sha,
+    subject,
+    branch: status.branch,
+    changedCount: toCommit.length,
+    includedUntracked: included.length > 0,
+    rejectedUntracked: rejected
+  };
+}
+async function resolveRepoRoot(cwd, runner) {
+  const repoCheck = await runner(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (!repoCheck.ok) {
+    if (repoCheck.stderr.toLowerCase().includes("not a git repository")) {
+      return { ok: false, outcome: { kind: "not_a_git_repo" } };
+    }
+    return {
+      ok: false,
+      outcome: { kind: "git_unavailable", reason: repoCheck.stderr || "git rev-parse failed" }
+    };
+  }
+  const common = await runner(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]);
+  if (common.ok && common.stdout.trim()) {
+    const commonDir = common.stdout.trim();
+    const mainRoot = basename(commonDir) === ".git" ? dirname(commonDir) : null;
+    if (mainRoot) return { ok: true, repoRoot: mainRoot };
+  }
+  const toplevel = await runner(cwd, ["rev-parse", "--show-toplevel"]);
+  if (toplevel.ok && toplevel.stdout.trim()) {
+    return { ok: true, repoRoot: toplevel.stdout.trim() };
+  }
+  return {
+    ok: false,
+    outcome: { kind: "git_unavailable", reason: "\u65E0\u6CD5\u89E3\u6790 git \u4ED3\u5E93\u6839\u76EE\u5F55\u3002" }
+  };
+}
+async function createManagedWorktree(cwd, options, runner = defaultMutatingRunner, now = /* @__PURE__ */ new Date()) {
+  const nameCheck = validateWorktreeName(options.name);
+  if (!nameCheck.ok) {
+    return { kind: "invalid", reason: nameCheck.reason };
+  }
+  let branch;
+  if (options.branch !== void 0 && options.branch !== "") {
+    const branchCheck = validateGitRef(options.branch);
+    if (!branchCheck.ok) {
+      return { kind: "invalid", reason: `branch \u975E\u6CD5\uFF1A${branchCheck.reason}` };
+    }
+    branch = branchCheck.ref;
+  }
+  let fromRef = "HEAD";
+  if (options.fromRef !== void 0 && options.fromRef !== "") {
+    const refCheck = validateGitRef(options.fromRef);
+    if (!refCheck.ok) {
+      return { kind: "invalid", reason: `fromRef \u975E\u6CD5\uFF1A${refCheck.reason}` };
+    }
+    fromRef = refCheck.ref;
+  }
+  const rootResult = await resolveRepoRoot(cwd, runner);
+  if (!rootResult.ok) {
+    return rootResult.outcome;
+  }
+  const repoRoot = rootResult.repoRoot;
+  const managedRoot = resolveManagedWorktreeRoot(repoRoot);
+  const targetPath = managedWorktreePath(repoRoot, nameCheck.slug);
+  const list = await readWorktreeList(cwd, runner);
+  if (list.kind === "git_unavailable") {
+    return { kind: "git_unavailable", reason: list.error };
+  }
+  if (list.kind === "ok") {
+    const existing = list.entries.find(
+      (entry) => normalizePath(entry.path) === normalizePath(targetPath)
+    );
+    if (existing) {
+      return {
+        kind: "resumed",
+        path: targetPath,
+        name: nameCheck.displayName,
+        branch: existing.branch,
+        head: existing.head,
+        managedRoot
+      };
+    }
+  }
+  await mkdir(managedRoot, { recursive: true });
+  const addArgs = branch ? ["worktree", "add", "-b", branch, targetPath, fromRef] : ["worktree", "add", targetPath, fromRef];
+  const addResult = await runner(repoRoot, addArgs);
+  if (!addResult.ok) {
+    return { kind: "failed", reason: addResult.stderr || "git worktree add \u5931\u8D25" };
+  }
+  let head = null;
+  const headResult = await runner(targetPath, ["rev-parse", "--short", "HEAD"]);
+  if (headResult.ok && headResult.stdout.trim()) {
+    head = headResult.stdout.trim();
+  }
+  let resolvedBranch = branch ?? null;
+  if (!resolvedBranch) {
+    const branchResult = await runner(targetPath, ["branch", "--show-current"]);
+    if (branchResult.ok && branchResult.stdout.trim()) {
+      resolvedBranch = branchResult.stdout.trim();
+    }
+  }
+  return {
+    kind: "created",
+    path: targetPath,
+    name: nameCheck.displayName,
+    branch: resolvedBranch,
+    fromRef,
+    head,
+    managedRoot,
+    createdAt: now.toISOString()
+  };
+}
+async function planManagedWorktreeRemove(cwd, options, runner = defaultMutatingRunner) {
+  const nameCheck = validateWorktreeName(options.name);
+  if (!nameCheck.ok) {
+    return { kind: "invalid", reason: nameCheck.reason };
+  }
+  const rootResult = await resolveRepoRoot(cwd, runner);
+  if (!rootResult.ok) {
+    if (rootResult.outcome.kind === "not_a_git_repo") return { kind: "not_a_git_repo" };
+    return {
+      kind: "git_unavailable",
+      reason: rootResult.outcome.kind === "git_unavailable" ? rootResult.outcome.reason : "git unavailable"
+    };
+  }
+  const repoRoot = rootResult.repoRoot;
+  const targetPath = managedWorktreePath(repoRoot, nameCheck.slug);
+  const list = await readWorktreeList(cwd, runner);
+  if (list.kind === "git_unavailable") {
+    return { kind: "git_unavailable", reason: list.error };
+  }
+  if (list.kind !== "ok") {
+    return { kind: "not_a_git_repo" };
+  }
+  const entry = list.entries.find((item) => normalizePath(item.path) === normalizePath(targetPath));
+  if (!entry) {
+    const externalByName = list.entries.find(
+      (item) => basename(item.path.replace(/[\\/]+$/u, "")) === nameCheck.slug
+    );
+    if (externalByName && !isUnderManagedRoot(repoRoot, externalByName.path)) {
+      return {
+        kind: "not_managed",
+        reason: "\u8BE5 worktree \u4E0D\u5728 Linghun \u53D7\u63A7\u76EE\u5F55\u4E0B\uFF08external\uFF09\uFF0C\u4E0D\u5141\u8BB8\u901A\u8FC7 Linghun \u5220\u9664\u3002",
+        path: externalByName.path
+      };
+    }
+    return {
+      kind: "not_found",
+      reason: `\u672A\u627E\u5230\u53D7\u63A7 worktree\uFF1A${nameCheck.displayName}\u3002`
+    };
+  }
+  if (!isUnderManagedRoot(repoRoot, entry.path)) {
+    return {
+      kind: "not_managed",
+      reason: "\u8BE5 worktree \u4E0D\u5728 Linghun \u53D7\u63A7\u76EE\u5F55\u4E0B\uFF08external\uFF09\uFF0C\u4E0D\u5141\u8BB8\u901A\u8FC7 Linghun \u5220\u9664\u3002",
+      path: entry.path
+    };
+  }
+  const status = await readGitStatus(entry.path, runner);
+  const dirty = status.kind !== "ok" || status.changedCount > 0 || status.untrackedCount > 0;
+  if (!dirty) {
+    return { kind: "clean", path: entry.path, name: nameCheck.displayName, branch: entry.branch };
+  }
+  if (options.force === true) {
+    return {
+      kind: "dirty_force",
+      path: entry.path,
+      name: nameCheck.displayName,
+      branch: entry.branch
+    };
+  }
+  return { kind: "dirty_blocked", path: entry.path, name: nameCheck.displayName };
+}
+async function executeManagedWorktreeRemove(cwd, path, force, runner = defaultMutatingRunner) {
+  const rootResult = await resolveRepoRoot(cwd, runner);
+  const repoRoot = rootResult.ok ? rootResult.repoRoot : cwd;
+  const args = force ? ["worktree", "remove", "--force", path] : ["worktree", "remove", path];
+  const result = await runner(repoRoot, args);
+  if (!result.ok) {
+    return { kind: "failed", reason: result.stderr || "git worktree remove \u5931\u8D25" };
+  }
+  return { kind: "removed", path };
+}
+async function computeWorktreeContext(cwd, runner = defaultMutatingRunner) {
+  const repoCheck = await runner(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (!repoCheck.ok || repoCheck.stdout.trim() !== "true") {
+    return null;
+  }
+  const [topResult, gitDirResult, commonDirResult, branchResult] = await Promise.all([
+    runner(cwd, ["rev-parse", "--show-toplevel"]),
+    runner(cwd, ["rev-parse", "--absolute-git-dir"]),
+    runner(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"]),
+    runner(cwd, ["branch", "--show-current"])
+  ]);
+  const currentPath = topResult.ok && topResult.stdout.trim() ? topResult.stdout.trim() : cwd;
+  const gitDir = gitDirResult.ok ? gitDirResult.stdout.trim() : "";
+  const commonDir = commonDirResult.ok ? commonDirResult.stdout.trim() : "";
+  const isWorktree = gitDir !== "" && commonDir !== "" && normalizePath(gitDir) !== normalizePath(commonDir);
+  const mainRoot = commonDir && basename(commonDir) === ".git" ? dirname(commonDir) : currentPath;
+  const branch = branchResult.ok && branchResult.stdout.trim() ? branchResult.stdout.trim() : null;
+  let managedName = null;
+  let managedRoot = null;
+  if (isWorktree && isUnderManagedRoot(mainRoot, currentPath)) {
+    managedRoot = resolveManagedWorktreeRoot(mainRoot);
+    managedName = basename(currentPath.replace(/[\\/]+$/u, ""));
+  }
+  return {
+    isWorktree,
+    repoRoot: mainRoot,
+    currentPath,
+    branch,
+    managedName,
+    managedRoot,
+    redactedPath: redactWorktreePath(currentPath)
+  };
+}
+function isAbsoluteWorktreeInput(value) {
+  return isAbsolute(value);
+}
+
+export {
+  MAX_STABLE_POINT_MESSAGE_LENGTH,
+  MAX_WORKTREE_NAME_LENGTH,
+  MAX_GIT_REF_LENGTH,
+  validateStablePointMessage,
+  defaultStablePointMessage,
+  validateWorktreeName,
+  validateGitRef,
+  MANAGED_WORKTREE_DIRNAME,
+  resolveManagedWorktreeRoot,
+  managedWorktreePath,
+  redactWorktreePath,
+  isSensitiveUntrackedPath,
+  filterUntrackedForCommit,
+  summarizeRejectedUntracked,
+  createGitStablePoint,
+  createManagedWorktree,
+  planManagedWorktreeRemove,
+  executeManagedWorktreeRemove,
+  computeWorktreeContext,
+  isAbsoluteWorktreeInput
+};