@linghun/tui 0.1.0

package/dist/chunk-AO4CXI37.js

@@ -0,0 +1,284 @@
+// src/git-runtime.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 5e3;
+function createGitRunner(timeoutMs) {
+  return async (cwd, args) => {
+    try {
+      const { stdout, stderr } = await execFileAsync("git", args, {
+        cwd,
+        timeout: timeoutMs,
+        maxBuffer: 4 * 1024 * 1024,
+        env: {
+          ...process.env,
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: ""
+        }
+      });
+      return { stdout: stdout.toString().trimEnd(), ok: true, stderr: stderr.toString() };
+    } catch (error) {
+      const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr ?? "") : "";
+      return { stdout: "", ok: false, stderr };
+    }
+  };
+}
+var defaultRunGit = createGitRunner(GIT_TIMEOUT_MS);
+async function isGitRepository(cwd, runner = defaultRunGit) {
+  const result = await runner(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  return result.ok && result.stdout.trim() === "true";
+}
+async function readGitStatus(cwd, runner = defaultRunGit) {
+  const repoCheck = await runner(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (!repoCheck.ok) {
+    if (repoCheck.stderr.toLowerCase().includes("not a git repository")) {
+      return { kind: "not_a_git_repo" };
+    }
+    return { kind: "git_unavailable", error: repoCheck.stderr || "git rev-parse failed" };
+  }
+  if (repoCheck.stdout.trim() !== "true") {
+    return {
+      kind: "git_unavailable",
+      error: `unexpected rev-parse stdout: ${repoCheck.stdout.slice(0, 80)}`
+    };
+  }
+  const [statusResult, logResult, branchResult] = await Promise.all([
+    runner(cwd, ["status", "--porcelain=v1", "-b"]),
+    runner(cwd, ["log", "-1", "--format=%h	%s"]),
+    runner(cwd, ["branch", "--show-current"])
+  ]);
+  if (!statusResult.ok) {
+    return {
+      kind: "git_unavailable",
+      error: statusResult.stderr || "git status --porcelain failed"
+    };
+  }
+  const branch = branchResult.ok && branchResult.stdout.trim().length > 0 ? branchResult.stdout.trim() : null;
+  let headShort = null;
+  let headSubject = null;
+  if (logResult.ok) {
+    const [shaPart, ...rest] = logResult.stdout.split("	");
+    if (shaPart) headShort = shaPart;
+    if (rest.length > 0) headSubject = rest.join("	");
+  }
+  const staged = [];
+  const unstaged = [];
+  const untracked = [];
+  let ahead = 0;
+  let behind = 0;
+  let upstream = null;
+  const lines = statusResult.stdout.split("\n");
+  for (const rawLine of lines) {
+    if (!rawLine) continue;
+    if (rawLine.startsWith("##")) {
+      const match = rawLine.match(/^##\s+(.+?)(?:\.{2,3}([^\s]+))?(?:\s*\[([^\]]+)\])?$/u);
+      if (match) {
+        if (match[2]) upstream = match[2];
+        const tag = match[3] ?? "";
+        const aheadMatch = tag.match(/ahead (\d+)/);
+        const behindMatch = tag.match(/behind (\d+)/);
+        if (aheadMatch?.[1]) ahead = Number.parseInt(aheadMatch[1], 10);
+        if (behindMatch?.[1]) behind = Number.parseInt(behindMatch[1], 10);
+      }
+      continue;
+    }
+    const code = rawLine.slice(0, 2);
+    const path = rawLine.slice(3);
+    if (code === "??") {
+      untracked.push(path);
+      continue;
+    }
+    const [indexFlag, worktreeFlag] = [code[0] ?? " ", code[1] ?? " "];
+    if (indexFlag !== " " && indexFlag !== "?") staged.push(path);
+    if (worktreeFlag !== " " && worktreeFlag !== "?") unstaged.push(path);
+  }
+  return {
+    kind: "ok",
+    branch,
+    headShort,
+    headSubject,
+    changedCount: staged.length + unstaged.length,
+    untrackedCount: untracked.length,
+    staged,
+    unstaged,
+    untracked,
+    ahead,
+    behind,
+    upstream
+  };
+}
+async function readWorktreeList(cwd, runner = defaultRunGit) {
+  const repoCheck = await runner(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (!repoCheck.ok) {
+    if (repoCheck.stderr.toLowerCase().includes("not a git repository")) {
+      return { kind: "not_a_git_repo" };
+    }
+    return { kind: "git_unavailable", error: repoCheck.stderr || "git rev-parse failed" };
+  }
+  if (repoCheck.stdout.trim() !== "true") {
+    return {
+      kind: "git_unavailable",
+      error: `unexpected rev-parse stdout: ${repoCheck.stdout.slice(0, 80)}`
+    };
+  }
+  const [topLevelResult, listResult] = await Promise.all([
+    runner(cwd, ["rev-parse", "--show-toplevel"]),
+    runner(cwd, ["worktree", "list", "--porcelain"])
+  ]);
+  if (!listResult.ok) {
+    return {
+      kind: "git_unavailable",
+      error: listResult.stderr || "git worktree list failed"
+    };
+  }
+  const currentTop = topLevelResult.ok ? topLevelResult.stdout.trim() : "";
+  const entries = [];
+  let pending = {};
+  const flush = () => {
+    if (!pending.path) return;
+    entries.push({
+      path: pending.path,
+      branch: pending.branch ?? null,
+      head: pending.head ?? null,
+      isCurrent: false,
+      bare: pending.bare ?? false,
+      detached: pending.detached ?? false
+    });
+    pending = {};
+  };
+  for (const rawLine of listResult.stdout.split("\n")) {
+    const line = rawLine.trim();
+    if (line === "") {
+      flush();
+      continue;
+    }
+    if (line.startsWith("worktree ")) {
+      flush();
+      pending.path = line.slice("worktree ".length);
+      continue;
+    }
+    if (line.startsWith("HEAD ")) {
+      pending.head = line.slice("HEAD ".length);
+      continue;
+    }
+    if (line.startsWith("branch ")) {
+      pending.branch = line.slice("branch ".length).replace(/^refs\/heads\//u, "");
+      continue;
+    }
+    if (line === "bare") pending.bare = true;
+    if (line === "detached") pending.detached = true;
+  }
+  flush();
+  if (currentTop) {
+    for (const entry of entries) {
+      if (normalizePath(entry.path) === normalizePath(currentTop)) {
+        entry.isCurrent = true;
+      }
+    }
+  }
+  return { kind: "ok", entries };
+}
+function normalizePath(value) {
+  return value.replace(/\\/gu, "/").replace(/\/+$/u, "").toLowerCase();
+}
+function suggestStablePoint(status) {
+  if (status.kind !== "ok") {
+    const reason = status.kind === "not_a_git_repo" ? "\u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF0C\u8DF3\u8FC7 stable point\u3002" : `git \u4E0D\u53EF\u7528\uFF1A${status.error}`;
+    return {
+      recommended: false,
+      reason,
+      suggestedSubject: "",
+      changedCount: 0,
+      staged: [],
+      unstaged: [],
+      untracked: []
+    };
+  }
+  const staged = status.staged.slice(0, 5);
+  const unstaged = status.unstaged.slice(0, 5);
+  const untracked = status.untracked.slice(0, 5);
+  if (status.changedCount === 0 && status.untrackedCount === 0) {
+    return {
+      recommended: false,
+      reason: "\u5DE5\u4F5C\u533A\u5E72\u51C0\uFF0C\u6CA1\u6709\u53EF\u63D0\u4EA4\u7684\u6539\u52A8\u3002",
+      suggestedSubject: "",
+      changedCount: 0,
+      staged,
+      unstaged,
+      untracked
+    };
+  }
+  if (status.changedCount === 0 && status.untrackedCount > 0) {
+    return {
+      recommended: false,
+      reason: `\u4EC5\u6709 ${status.untrackedCount} \u4E2A\u672A\u8DDF\u8E2A\u6587\u4EF6\uFF1B\u5148 review \u672A\u8DDF\u8E2A\u5185\u5BB9\u518D\u51B3\u5B9A\u662F\u5426\u7EB3\u5165\u63D0\u4EA4\u3002`,
+      suggestedSubject: "",
+      changedCount: 0,
+      staged,
+      unstaged,
+      untracked
+    };
+  }
+  const subject = `wip: ${status.changedCount} file${status.changedCount === 1 ? "" : "s"} updated`;
+  return {
+    recommended: true,
+    reason: "\u5DE5\u4F5C\u533A\u6709\u6539\u52A8\uFF0C\u53EF\u4EE5\u63D0\u4EA4\u4E00\u4E2A\u7A33\u5B9A\u70B9\uFF1B\u5EFA\u8BAE review \u540E\u7528 feat/fix/chore \u7B49\u524D\u7F00\u66FF\u6362 wip\u3002",
+    suggestedSubject: subject,
+    changedCount: status.changedCount,
+    staged,
+    unstaged,
+    untracked
+  };
+}
+function formatGitStatusDetails(status, worktrees) {
+  if (status.kind === "not_a_git_repo") {
+    return "Not a git repository.";
+  }
+  if (status.kind === "git_unavailable") {
+    return `git unavailable: ${status.error || "unknown error"}`;
+  }
+  const lines = [];
+  lines.push(`branch: ${status.branch ?? "(detached)"}`);
+  if (status.upstream) {
+    lines.push(`upstream: ${status.upstream} ahead=${status.ahead} behind=${status.behind}`);
+  }
+  if (status.headShort) {
+    lines.push(`HEAD: ${status.headShort}${status.headSubject ? `  ${status.headSubject}` : ""}`);
+  }
+  lines.push(`changed: ${status.changedCount}; untracked: ${status.untrackedCount}`);
+  if (status.staged.length > 0) {
+    lines.push("");
+    lines.push("staged:");
+    for (const path of status.staged) lines.push(`  + ${path}`);
+  }
+  if (status.unstaged.length > 0) {
+    lines.push("");
+    lines.push("unstaged:");
+    for (const path of status.unstaged) lines.push(`  M ${path}`);
+  }
+  if (status.untracked.length > 0) {
+    lines.push("");
+    lines.push("untracked:");
+    for (const path of status.untracked) lines.push(`  ? ${path}`);
+  }
+  if (worktrees.kind === "ok" && worktrees.entries.length > 0) {
+    lines.push("");
+    lines.push("worktrees:");
+    for (const entry of worktrees.entries) {
+      const marker = entry.isCurrent ? "*" : " ";
+      const branchLabel = entry.branch ?? (entry.detached ? "(detached)" : entry.bare ? "(bare)" : "(no branch)");
+      const head = entry.head ? entry.head.slice(0, 7) : "-";
+      lines.push(`  ${marker} ${entry.path}  ${branchLabel}  ${head}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+export {
+  createGitRunner,
+  isGitRepository,
+  readGitStatus,
+  readWorktreeList,
+  suggestStablePoint,
+  formatGitStatusDetails
+};

package/dist/chunk-APJIC2O5.js

@@ -0,0 +1,150 @@
+// src/shell/text-utils.ts
+function fitText(value, max) {
+  if (max <= 0) return "";
+  const chars = Array.from(value.replace(/\s+/gu, " ").trim());
+  let width = 0;
+  let result = "";
+  for (const char of chars) {
+    const next = width + charWidth(char);
+    if (next > max) return `${result}...`;
+    result += char;
+    width = next;
+  }
+  return result;
+}
+function wrapText(value, max) {
+  if (max <= 0) return [""];
+  const normalized = value.replace(/\r/g, "");
+  const out = [];
+  for (const rawLine of normalized.split("\n")) {
+    if (rawLine.length === 0) {
+      out.push("");
+      continue;
+    }
+    let line = "";
+    let width = 0;
+    for (const char of Array.from(rawLine)) {
+      const nextWidth = charWidth(char);
+      if (width > 0 && width + nextWidth > max) {
+        out.push(line);
+        line = char;
+        width = nextWidth;
+        continue;
+      }
+      line += char;
+      width += nextWidth;
+    }
+    out.push(line);
+  }
+  return out.length > 0 ? out : [""];
+}
+var CJK_WIDE_CHAR_RE = /[\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe10-\ufe19\ufe30-\ufe6f\uff00-\uff60\uffe0-\uffe6]/u;
+function charWidth(char) {
+  return CJK_WIDE_CHAR_RE.test(char) ? 2 : 1;
+}
+function displayWidth(value) {
+  let width = 0;
+  for (const char of value) width += charWidth(char);
+  return width;
+}
+function truncateDisplay(value, max) {
+  const normalized = String(value || "").replace(/\s+/gu, " ").trim();
+  if (displayWidth(normalized) <= max) return normalized;
+  if (max <= 0) return "";
+  const chars = Array.from(normalized);
+  let width = 0;
+  let result = "";
+  for (const char of chars) {
+    const next = width + charWidth(char);
+    if (next > max) return `${result}\u2026`;
+    result += char;
+    width = next;
+  }
+  return result;
+}
+function truncateMiddle(value, max, fallback = "") {
+  const normalized = String(value || fallback).replace(/\s+/gu, " ").trim();
+  if (displayWidth(normalized) <= max) return normalized;
+  if (max <= 1) return "\u2026";
+  const head = Math.max(1, Math.floor((max - 1) / 2));
+  const tail = Math.max(1, max - head - 1);
+  return `${sliceDisplayFront(normalized, head)}\u2026${sliceDisplayBack(normalized, tail)}`;
+}
+function sliceDisplayFront(value, max) {
+  let width = 0;
+  let result = "";
+  for (const char of value) {
+    const next = width + charWidth(char);
+    if (next > max) break;
+    result += char;
+    width = next;
+  }
+  return result;
+}
+function sliceDisplayBack(value, max) {
+  const chars = Array.from(value);
+  let width = 0;
+  let result = "";
+  for (let i = chars.length - 1; i >= 0; i -= 1) {
+    const char = chars[i] ?? "";
+    const next = width + charWidth(char);
+    if (next > max) break;
+    result = `${char}${result}`;
+    width = next;
+  }
+  return result;
+}
+function composerMaxWidth(viewWidth) {
+  return Math.min(80, Math.max(40, viewWidth - 6));
+}
+function taskComposerMaxWidth(viewWidth) {
+  return Math.max(40, viewWidth - 4);
+}
+function lineChar(noColor, capability) {
+  if (noColor) return "-";
+  if (capability && !capability.unicodeBox) return "-";
+  return "\u2500";
+}
+function brandWordmark(noColor, width = 80, capability) {
+  void noColor;
+  void width;
+  void capability;
+  return ["LingHun"];
+}
+function formatBriefTimestamp(ms, language) {
+  const d = new Date(ms);
+  if (Number.isNaN(d.getTime())) return "";
+  const now = /* @__PURE__ */ new Date();
+  const dayDiff = startOfDay(now) - startOfDay(d);
+  const daysAgo = Math.round(dayDiff / 864e5);
+  const pad2 = (n) => String(n).padStart(2, "0");
+  const time = `${pad2(d.getHours())}:${pad2(d.getMinutes())}`;
+  if (daysAgo === 0) return time;
+  if (daysAgo > 0 && daysAgo < 7) {
+    if (language === "zh-CN") {
+      return `${ZH_WEEKDAY[d.getDay()]} ${time}`;
+    }
+    return `${EN_WEEKDAY[d.getDay()]} ${time}`;
+  }
+  const date = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+  return `${date} ${time}`;
+}
+function startOfDay(d) {
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+}
+var ZH_WEEKDAY = ["\u5468\u65E5", "\u5468\u4E00", "\u5468\u4E8C", "\u5468\u4E09", "\u5468\u56DB", "\u5468\u4E94", "\u5468\u516D"];
+var EN_WEEKDAY = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+
+export {
+  fitText,
+  wrapText,
+  charWidth,
+  displayWidth,
+  truncateDisplay,
+  truncateMiddle,
+  composerMaxWidth,
+  taskComposerMaxWidth,
+  lineChar,
+  brandWordmark,
+  formatBriefTimestamp
+};