@linghun/tui 0.1.0

package/dist/chunk-JGDIO2NF.js

@@ -0,0 +1,74 @@
+import {
+  createShellTheme
+} from "./chunk-GC55DMZV.js";
+import {
+  messages
+} from "./chunk-RBOQJFIZ.js";
+import {
+  fitText
+} from "./chunk-APJIC2O5.js";
+
+// src/shell/components/TaskListView.tsx
+import { Box, Text } from "@linghun/ink-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+function TaskListView({
+  list,
+  width,
+  noColor,
+  language
+}) {
+  if (list.rows.length === 0) return null;
+  const theme = createShellTheme(noColor);
+  const innerWidth = Math.max(20, width - 2);
+  const text = messages[language];
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: theme.muted, bold: true, children: text.r3TasksTitle }),
+    list.rows.map((row) => {
+      const blocked = row.status === "blocked";
+      const inProgress = row.status === "in_progress";
+      const marker = taskMarker(row.status, noColor);
+      const hasBlockers = blocked && row.blockedBy && row.blockedBy.length > 0;
+      const blockedByLabel = language === "en-US" ? "blocked by" : "\u88AB\u963B\u585E";
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+          /* @__PURE__ */ jsxs(
+            Text,
+            {
+              color: inProgress ? theme.status.running : void 0,
+              bold: inProgress,
+              dimColor: blocked,
+              children: [
+                marker,
+                " ",
+                fitText(row.subject, Math.max(8, innerWidth - 4 - (row.owner ? row.owner.length + 3 : 0)))
+              ]
+            }
+          ),
+          row.owner ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, dimColor: true, children: [
+            " ",
+            "(@",
+            row.owner,
+            ")"
+          ] }) : null,
+          hasBlockers ? /* @__PURE__ */ jsxs(Text, { color: theme.muted, dimColor: true, children: [
+            " ",
+            "\u25B8 ",
+            blockedByLabel,
+            " ",
+            row.blockedBy.map((id) => `#${id}`).join(", ")
+          ] }) : null
+        ] }),
+        inProgress && !blocked && row.activity ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: /* @__PURE__ */ jsx(Text, { color: theme.muted, dimColor: true, children: fitText(`${row.activity}\u2026`, Math.max(8, innerWidth - 4)) }) }) : null
+      ] }, row.id);
+    }),
+    list.hiddenPending > 0 ? /* @__PURE__ */ jsx(Text, { color: theme.muted, dimColor: true, children: `\u2026 +${list.hiddenPending} ${text.r3PendingHiddenSuffix}` }) : null
+  ] });
+}
+function taskMarker(status, noColor) {
+  if (status === "in_progress") return "\u25A0";
+  return "\u25A1";
+}
+
+export {
+  TaskListView
+};

package/dist/chunk-JHGWGH2C.js

@@ -0,0 +1,182 @@
+// src/process-guard.ts
+import { spawn } from "child_process";
+var ProcessGuardRegistry = class {
+  tracked = /* @__PURE__ */ new Map();
+  track(child, options = {}) {
+    const pid = child.pid;
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) {
+      return false;
+    }
+    if (child.exitCode !== void 0 && child.exitCode !== null) {
+      return false;
+    }
+    if (child.signalCode !== void 0 && child.signalCode !== null) {
+      return false;
+    }
+    this.tracked.set(pid, {
+      child,
+      pid,
+      detached: options.detached === true,
+      label: options.label
+    });
+    const cleanup = () => this.untrack(pid);
+    child.once("exit", cleanup);
+    child.once("close", cleanup);
+    return true;
+  }
+  untrack(pid) {
+    if (!pid) {
+      return;
+    }
+    this.tracked.delete(pid);
+  }
+  snapshot() {
+    return Array.from(this.tracked.values()).map((entry) => ({
+      pid: entry.pid,
+      detached: entry.detached,
+      label: entry.label
+    }));
+  }
+  stopAll(kind, force, deps, allowAsyncWindowsTreeKill, onlyPids) {
+    const result = {
+      kind,
+      force,
+      attempted: 0,
+      skipped: 0,
+      failures: []
+    };
+    for (const entry of this.tracked.values()) {
+      if (onlyPids && !onlyPids.has(entry.pid)) {
+        continue;
+      }
+      stopEntry(entry, force, deps, allowAsyncWindowsTreeKill, result);
+    }
+    return result;
+  }
+};
+var PROCESS_GUARD_EXIT_CLEANUP_NOTE = "process.on('exit') cleanup is synchronous best-effort only; it cannot guarantee async taskkill completion or parent hard-kill/crash cleanup.";
+var defaultRegistry = new ProcessGuardRegistry();
+var recentStopResults = [];
+var hooksInstalled = false;
+function resolveDeps(deps = {}) {
+  return {
+    platform: deps.platform ?? process.platform,
+    spawn: deps.spawn ?? spawn,
+    kill: deps.kill ?? process.kill.bind(process)
+  };
+}
+function createProcessGuard(registry = defaultRegistry, deps = {}) {
+  const resolvedDeps = resolveDeps(deps);
+  const localPids = /* @__PURE__ */ new Set();
+  return {
+    track: (child, options) => {
+      const tracked = registry.track(child, options);
+      if (tracked && child.pid) {
+        localPids.add(child.pid);
+      }
+      return tracked;
+    },
+    requestStop: (force) => recordStopResult(
+      registry.stopAll(force ? "force" : "graceful", force, resolvedDeps, true, localPids)
+    ),
+    cleanupForExit: () => recordStopResult(registry.stopAll("exit-cleanup", true, resolvedDeps, false, localPids)),
+    snapshot: () => registry.snapshot().filter((entry) => localPids.has(entry.pid))
+  };
+}
+function trackChildProcess(child, options = {}) {
+  return defaultRegistry.track(child, options);
+}
+function requestTrackedProcessStop(force) {
+  return recordStopResult(
+    defaultRegistry.stopAll(force ? "force" : "graceful", force, resolveDeps(), true)
+  );
+}
+function cleanupTrackedProcessesForExit() {
+  return recordStopResult(defaultRegistry.stopAll("exit-cleanup", true, resolveDeps(), false));
+}
+function consumeProcessGuardStopResultsForTest() {
+  return recentStopResults.splice(0, recentStopResults.length);
+}
+function getTrackedProcessSnapshot() {
+  return defaultRegistry.snapshot();
+}
+function installProcessGuardExitHandlers() {
+  if (hooksInstalled) {
+    return;
+  }
+  hooksInstalled = true;
+  process.once("beforeExit", () => {
+    requestTrackedProcessStop(false);
+  });
+  process.once("exit", () => {
+    cleanupTrackedProcessesForExit();
+  });
+  process.once("SIGTERM", () => {
+    requestTrackedProcessStop(false);
+    process.exitCode = 143;
+    process.exit(143);
+  });
+}
+function recordStopResult(result) {
+  recentStopResults.push(result);
+  if (recentStopResults.length > 20) {
+    recentStopResults.shift();
+  }
+  return result;
+}
+function stopEntry(entry, force, deps, allowAsyncWindowsTreeKill, result) {
+  if (entry.stopState === "force" || entry.stopState === "graceful" && !force) {
+    result.skipped += 1;
+    return;
+  }
+  entry.stopState = force ? "force" : "graceful";
+  result.attempted += 1;
+  if (deps.platform === "win32" && allowAsyncWindowsTreeKill) {
+    stopWindowsTree(entry, force, deps, result);
+    return;
+  }
+  stopWithSignal(entry, force, deps, result);
+}
+function stopWindowsTree(entry, force, deps, result) {
+  const args = ["/pid", String(entry.pid), "/t"];
+  if (force) {
+    args.push("/f");
+  }
+  try {
+    const killer = deps.spawn("taskkill", args, { windowsHide: true });
+    killer.once("error", (error) => {
+      result.failures.push({ pid: entry.pid, message: formatError(error) });
+      stopWithSignal(entry, force, deps, result);
+    });
+  } catch (error) {
+    result.failures.push({ pid: entry.pid, message: formatError(error) });
+    stopWithSignal(entry, force, deps, result);
+  }
+}
+function stopWithSignal(entry, force, deps, result) {
+  const signal = force ? "SIGKILL" : "SIGTERM";
+  try {
+    if (deps.platform !== "win32" && entry.detached) {
+      deps.kill(-entry.pid, signal);
+      return;
+    }
+    entry.child.kill(signal);
+  } catch (error) {
+    result.failures.push({ pid: entry.pid, message: formatError(error) });
+  }
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  ProcessGuardRegistry,
+  PROCESS_GUARD_EXIT_CLEANUP_NOTE,
+  createProcessGuard,
+  trackChildProcess,
+  requestTrackedProcessStop,
+  cleanupTrackedProcessesForExit,
+  consumeProcessGuardStopResultsForTest,
+  getTrackedProcessSnapshot,
+  installProcessGuardExitHandlers
+};

package/dist/chunk-JLCPHVBN.js

@@ -0,0 +1,42 @@
+// src/shell/components/NotificationStack.tsx
+import { Box, Text } from "@linghun/ink-runtime";
+import { jsx } from "react/jsx-runtime";
+function NotificationStack({
+  notifications,
+  theme
+}) {
+  if (!notifications || notifications.length === 0) return null;
+  const sorted = [...notifications].sort(comparePriority);
+  const top = sorted[0];
+  if (!top) return null;
+  return /* @__PURE__ */ jsx(Box, { justifyContent: "flex-end", paddingX: 2, children: /* @__PURE__ */ jsx(Text, { color: pickToneColor(theme, top.tone), dimColor: isDim(top.tone), children: top.text }) });
+}
+function comparePriority(a, b) {
+  const order = {
+    immediate: 0,
+    medium: 1,
+    low: 2
+  };
+  return order[a.priority] - order[b.priority];
+}
+function pickToneColor(theme, tone) {
+  switch (tone) {
+    case "error":
+      return theme.error ?? theme.status.fail;
+    case "warning":
+      return theme.warning ?? theme.status.partial;
+    case "success":
+      return theme.success ?? theme.status.pass;
+    case "default":
+      return theme.notification ?? theme.muted;
+    default:
+      return theme.dim ?? theme.muted;
+  }
+}
+function isDim(tone) {
+  return !tone || tone === "dim";
+}
+
+export {
+  NotificationStack
+};