@wrongstack/core 0.32.0 → 0.41.0

package/dist/utils/index.d.ts

@@ -53,6 +53,112 @@ declare const color: {
 };
 declare function stripAnsi(s: string): string;
 
+/**
+ * TTY detection helpers — the single source of truth for "is this process
+ * running against a real terminal?". Replaces ad-hoc `process.stdin.isTTY`
+ * / `process.stdout.isTTY` checks scattered across the codebase so that:
+ *
+ *   1. test code can mock a single module instead of stubbing `isTTY` on
+ *      every ReadStream/WriteStream the test happens to touch;
+ *   2. a future TTY-detection source (an env var override, a Windows
+ *      ConPTY workaround, …) lands in one place;
+ *   3. `isInteractive()` encodes the rule the project already used inline
+ *      ("both streams are TTYs AND we're not running under CI") in one
+ *      testable helper instead of the same 3-condition check in two
+ *      different files.
+ *
+ * Scope: detection only. Raw-mode control (`setRawMode`), resize
+ * subscriptions, and write-injection belong to a future, larger TTY
+ * abstraction; this module is the smallest pull that gives us a
+ * testable seam and dedups 20+ call sites.
+ */
+/** True when `process.stdout` is attached to a terminal (not a pipe/file). */
+declare function isStdoutTTY(): boolean;
+/** True when `process.stdin` is attached to a terminal (not a pipe/file). */
+declare function isStdinTTY(): boolean;
+/**
+ * True when the current process is an interactive session: both stdin and
+ * stdout are TTYs. Callers that also need a "not a single-shot invocation"
+ * or "not under CI" check should layer that on top — keeping this helper
+ * minimal preserves the original inline checks it replaces.
+ */
+declare function isInteractive(): boolean;
+/** Current terminal size in characters, with a 24×80 fallback for non-TTYs. */
+declare function getTermSize(): {
+    rows: number;
+    cols: number;
+};
+/**
+ * Subscribe to terminal resize events. `cb` is called with the new size each
+ * time the underlying stream emits `resize`. Returns a cleanup function the
+ * caller MUST call on dispose to remove the listener — leaving a stale
+ * `resize` listener on a disposed component leaks the closure (and the
+ * component itself, transitively) until the process exits.
+ *
+ * The stream argument defaults to `process.stdout`. Pass an explicit
+ * `NodeJS.WriteStream` when the caller already owns one (e.g. a status line
+ * that targets an injected `out` for testability). For non-TTY streams no
+ * listener is registered and the returned cleanup is a no-op.
+ */
+declare function onResize(cb: (size: {
+    rows: number;
+    cols: number;
+}) => void, stream?: NodeJS.WriteStream): () => void;
+/**
+ * Toggle raw mode on a TTY stdin stream. Returns `true` when the toggle was
+ * applied, `false` when the stream is null, not a TTY, or doesn't expose
+ * `setRawMode` (pipes, file descriptors, Windows ConPTY edge cases). Callers
+ * that need to restore the previous mode should snapshot `input.isRaw`
+ * BEFORE the call and pass the value to a second call to flip back.
+ *
+ * Use this helper to drop the now-redundant
+ * `if (input.isTTY) input.setRawMode(...)` ceremony at every call site.
+ */
+declare function setRawMode(input: NodeJS.ReadStream, mode: boolean): boolean;
+/**
+ * Write `s` to `stream` (defaults to `process.stdout`). Returns `false`
+ * when the stream is missing or doesn't expose `write` so callers can
+ * degrade silently under hostile host environments (closed pipe, mock
+ * injects `null`, test replaces the stream with a stub).
+ *
+ * Why a helper:
+ *   1. **Single seam for output capture in tests** — stub `writeOut` once
+ *      and assert on what the rest of the codebase intended to print,
+ *      without spying on `process.stdout.write` (which is brittle and
+ *      leaks across parallel test files).
+ *   2. **Stream swap without grep** — routing the CLI's output to a
+ *      logger or `out.log` becomes a one-line change at process boot.
+ *   3. **Defensive default** — closes the "what if `process.stdout` is
+ *      `null`" gap that currently exists at ~50 call sites that just
+ *      call `process.stdout.write(s)` and crash on certain Windows
+ *      redirect invocations.
+ *
+ * Call-site migration is staged: this commit introduces the helper, a
+ * follow-up commit replaces the 50+ `process.stdout.write(...)` sites
+ * with `writeOut(...)`. Until that migration lands, both forms coexist
+ * and `writeOut` is the preferred form for new code.
+ */
+declare function writeOut(s: string, stream?: NodeJS.WriteStream): boolean;
+/**
+ * Symmetric partner of `writeOut` for the standard error stream. Same shape,
+ * same defensive contract, same single-seam-for-tests story — just defaults to
+ * `process.stderr` instead of `process.stdout`.
+ *
+ * Use this in code paths that emit error/diagnostic/warning text. Keeping
+ * these two helpers split (rather than a single `writeTo(s, stream)`) means
+ * the call site reads as a clear intent signal: "I am writing an error" vs.
+ * "I am writing a result" — which matters for callers that decide between
+ * stdout/stderr routing (e.g. `--quiet` flags, log-level filtering,
+ * structured-log rewriters that fork on stream).
+ *
+ * Stderr writes from the core logger (see `infrastructure/logger.ts`) and from
+ * the TUI guard (see `tui/run-tui.ts`) used to call `process.stderr.write`
+ * directly. Routing them through this helper lets tests stub the stream at
+ * one boundary and lets future logging middleware (e.g. a JSON-line rewriter)
+ * swap the destination for the entire process in one place.
+ */
+declare function writeErr(s: string, stream?: NodeJS.WriteStream): boolean;
+
 /**
  * Canonical text rendering of the live todo list, shared by the CLI's
  * `/todos` slash command and the TUI's auto-echo (which prints the same
@@ -371,4 +477,4 @@ declare function completePartialObject(s: string): string;
  */
 declare function mergeModelsPayload(base: ModelsDevPayload, overlay: ModelsDevPayload): ModelsDevPayload;
 
-export { type AtomicWriteOptions, type BuildChildEnvOptions, type CompileFail, type CompileResult, type MessageRepairReport, type MessageRepairResult, type NewlineStyle, type RequestTokenBreakdown, type SafeParseResult, type ToolOutputSerializerOptions, type UnifiedDiffOptions, type ValidationError, type ValidationResult, atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, createToolOutputSerializer, detectNewlineStyle, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, formatTodosList, getCalibrationState, matchAny, matchGlob, mergeModelsPayload, normalizeToLf, recordActualUsage, repairToolUseAdjacency, resetCalibration, safeParse, safeStringify, sanitizeJsonString, stripAnsi, toStyle, unifiedDiff, validateAgainstSchema };
+export { type AtomicWriteOptions, type BuildChildEnvOptions, type CompileFail, type CompileResult, type MessageRepairReport, type MessageRepairResult, type NewlineStyle, type RequestTokenBreakdown, type SafeParseResult, type ToolOutputSerializerOptions, type UnifiedDiffOptions, type ValidationError, type ValidationResult, atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, createToolOutputSerializer, detectNewlineStyle, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, formatTodosList, getCalibrationState, getTermSize, isInteractive, isStdinTTY, isStdoutTTY, matchAny, matchGlob, mergeModelsPayload, normalizeToLf, onResize, recordActualUsage, repairToolUseAdjacency, resetCalibration, safeParse, safeStringify, sanitizeJsonString, setRawMode, stripAnsi, toStyle, unifiedDiff, validateAgainstSchema, writeErr, writeOut };

package/dist/utils/index.js

@@ -205,11 +205,62 @@ function normalizeToLf(text) {
   return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
 
+// src/utils/term.ts
+var hasStdout = () => typeof process !== "undefined" && !!process.stdout;
+var hasStdin = () => typeof process !== "undefined" && !!process.stdin;
+function isStdoutTTY() {
+  return hasStdout() && Boolean(process.stdout.isTTY);
+}
+function isStdinTTY() {
+  return hasStdin() && Boolean(process.stdin.isTTY);
+}
+function isInteractive() {
+  return isStdinTTY() && isStdoutTTY();
+}
+function getTermSize() {
+  if (!hasStdout()) return { rows: 24, cols: 80 };
+  return {
+    rows: process.stdout.rows ?? 24,
+    cols: process.stdout.columns ?? 80
+  };
+}
+function onResize(cb, stream = process.stdout) {
+  if (!stream || typeof stream.on !== "function") return () => {
+  };
+  const handler = () => {
+    cb({
+      rows: stream.rows ?? 24,
+      cols: stream.columns ?? 80
+    });
+  };
+  stream.on("resize", handler);
+  return () => {
+    stream.off("resize", handler);
+  };
+}
+function setRawMode(input, mode) {
+  if (!input || input.isTTY !== true) return false;
+  if (typeof input.setRawMode !== "function") return false;
+  input.setRawMode(mode);
+  return true;
+}
+function writeTo(s, stream) {
+  if (!stream || typeof stream.write !== "function") return false;
+  stream.write(s);
+  return true;
+}
+function writeOut(s, stream = process.stdout) {
+  return writeTo(s, stream);
+}
+function writeErr(s, stream = process.stderr) {
+  return writeTo(s, stream);
+}
+
 // src/utils/color.ts
 var isColorTty = () => {
   if (process.env.NO_COLOR) return false;
   if (process.env.FORCE_COLOR) return true;
-  return Boolean(process.stdout?.isTTY);
+  return isStdoutTTY();
 };
 var COLOR = isColorTty();
 var wrap = (open2, close) => (s) => COLOR ? `\x1B[${open2}m${s}\x1B[${close}m` : s;
@@ -1277,6 +1328,6 @@ function stripUndefined(obj) {
   return out;
 }
 
-export { atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, createToolOutputSerializer, detectNewlineStyle, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, formatTodosList, getCalibrationState, matchAny, matchGlob, mergeModelsPayload, normalizeToLf, projectHash, recordActualUsage, repairToolUseAdjacency, resetCalibration, resolveWstackPaths, safeParse, safeStringify, sanitizeJsonString, stripAnsi, toStyle, unifiedDiff, validateAgainstSchema };
+export { atomicWrite, buildChildEnv, color, compileGlob, compileUserRegex, completePartialObject, createToolOutputSerializer, detectNewlineStyle, ensureDir, estimateRequestTokens, estimateRequestTokensCalibrated, estimateTextTokens, estimateToolDefTokens, estimateToolInputTokens, estimateToolResultTokens, expandGlob, formatTodosList, getCalibrationState, getTermSize, isInteractive, isStdinTTY, isStdoutTTY, matchAny, matchGlob, mergeModelsPayload, normalizeToLf, onResize, projectHash, recordActualUsage, repairToolUseAdjacency, resetCalibration, resolveWstackPaths, safeParse, safeStringify, sanitizeJsonString, setRawMode, stripAnsi, toStyle, unifiedDiff, validateAgainstSchema, writeErr, writeOut };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map