@pi-unipi/core 2.1.3 → 2.3.0

package/constants.ts

@@ -39,6 +39,7 @@ export const MODULES = {
   UPDATER: "@pi-unipi/updater",
   INPUT_SHORTCUTS: "@pi-unipi/input-shortcuts",
   COCOINDEX: "@pi-unipi/cocoindex",
+  IMAGE: "@pi-unipi/image",
 } as const;
 
 /** Workflow command names */
@@ -192,6 +193,23 @@ export const ASK_USER_TOOLS = {
   ASK: "ask_user",
 } as const;
 
+/** Image tool names */
+export const IMAGE_TOOLS = {
+  GENERATE: "image_generate",
+  RECOGNIZE: "image_recognize",
+} as const;
+
+/** Image command names */
+export const IMAGE_COMMANDS = {
+  SETTINGS: "image-settings",
+} as const;
+
+/** Image directory paths */
+export const IMAGE_DIRS = {
+  CONFIG: "~/.unipi/config/image",
+  OUTPUT: "~/.unipi/images",
+} as const;
+
 /** MCP directory paths */
 export const MCP_DIRS = {
   GLOBAL_CONFIG: "~/.unipi/config/mcp",

package/index.ts

@@ -9,3 +9,4 @@ export * from "./events.js";
 export * from "./sandbox.js";
 export * from "./utils.js";
 export * from "./model-cache.js";
+export * from "./tui-width.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/core",
-  "version": "2.1.3",
+  "version": "2.3.0",
   "description": "Shared utilities, event types, and constants for Unipi extension suite",
   "type": "module",
   "license": "MIT",

package/tui-width.ts

@@ -0,0 +1,127 @@
+/**
+ * @pi-unipi/core — TUI width helpers
+ *
+ * pi-tui's differential renderer throws when a rendered line is wider than the
+ * terminal (see `TUI.render` in @earendil-works/pi-tui — it writes
+ * `~/.pi/agent/pi-crash.log`, stops the TUI and rethrows). That makes any
+ * "minimum width" floor a crash waiting to happen on a narrow terminal:
+ *
+ *     const innerWidth = Math.max(40, width - 2);   // ← 42-col lines at width=20
+ *
+ * The invariant every component must hold is:
+ *
+ *     for every returned line:  visibleWidth(line) <= width
+ *
+ * These helpers make that invariant easy to satisfy. They are pure arithmetic
+ * so this module stays free of a pi-tui dependency.
+ */
+
+/**
+ * Terminals narrower than this cannot usefully show a bordered box: two
+ * columns go to the border, leaving too little for content. Below the
+ * threshold, callers should render borderless (see {@link shouldRenderBorder}).
+ */
+export const MIN_BORDERED_WIDTH = 12;
+
+/** Smallest width any layout is asked to cope with. */
+export const MIN_RENDER_WIDTH = 1;
+
+/**
+ * Normalize an incoming render width. Guards against `0`, negative, `NaN`
+ * and fractional widths, all of which have been observed during terminal
+ * resize races.
+ */
+export function normalizeWidth(width: number): number {
+  if (!Number.isFinite(width)) return MIN_RENDER_WIDTH;
+  return Math.max(MIN_RENDER_WIDTH, Math.floor(width));
+}
+
+/**
+ * Whether a bordered box fits at this width. When false, render the content
+ * without `│` side borders so the full width is usable.
+ */
+export function shouldRenderBorder(width: number): boolean {
+  return normalizeWidth(width) >= MIN_BORDERED_WIDTH;
+}
+
+/**
+ * Content width inside a bordered box, i.e. the terminal width minus the two
+ * border columns, so that `│ + content + │` is `<= width`.
+ *
+ * Use this for components that always draw a border. Components that can drop
+ * the border on narrow terminals should branch on {@link shouldRenderBorder}
+ * and use {@link adaptiveInnerWidth} instead.
+ */
+export function boxInnerWidth(width: number): number {
+  return Math.max(1, normalizeWidth(width) - 2);
+}
+
+/**
+ * Content width for components that drop their border on narrow terminals:
+ * the box inner width when a border fits, otherwise the full width.
+ *
+ * Pair with {@link shouldRenderBorder} to decide whether to emit the border
+ * characters. Together they guarantee every emitted line is `<= width` at any
+ * width down to 1.
+ */
+export function adaptiveInnerWidth(width: number): number {
+  const w = normalizeWidth(width);
+  return shouldRenderBorder(w) ? boxInnerWidth(w) : w;
+}
+
+/**
+ * Width remaining after reserving `reserved` columns for a prefix, indent or
+ * gutter. Never returns less than 1, so it is safe to pass to wrapping and
+ * truncation helpers (which throw or misbehave on non-positive widths).
+ */
+export function contentWidth(available: number, reserved: number): number {
+  return Math.max(1, normalizeWidth(available) - Math.max(0, Math.floor(reserved)));
+}
+
+/**
+ * Clamp a repeat count to a non-negative integer.
+ *
+ * `String.prototype.repeat` throws `RangeError: Invalid count value` for
+ * negative counts, which crashes the render pass.
+ */
+export function safeRepeatCount(count: number): number {
+  if (!Number.isFinite(count)) return 0;
+  return Math.max(0, Math.floor(count));
+}
+
+/** `" ".repeat(n)` that cannot throw. */
+export function safeRepeat(char: string, count: number): string {
+  return char.repeat(safeRepeatCount(count));
+}
+
+/**
+ * Width-keyed render cache.
+ *
+ * Components that cache their rendered lines must invalidate on width change.
+ * pi-tui's `requestRender()` does *not* call `invalidate()`, so a component
+ * that caches `string[]` without keying on width will return stale, over-wide
+ * lines after the terminal is made narrower — and the next differential frame
+ * throws.
+ */
+export class WidthKeyedCache {
+  private lines: string[] | null = null;
+  private width = -1;
+
+  /** Cached lines for this width, or `null` on miss. */
+  get(width: number): string[] | null {
+    return this.lines !== null && this.width === normalizeWidth(width) ? this.lines : null;
+  }
+
+  /** Store lines for this width. Returns the lines for convenient chaining. */
+  set(width: number, lines: string[]): string[] {
+    this.lines = lines;
+    this.width = normalizeWidth(width);
+    return lines;
+  }
+
+  /** Drop the cache — call from `invalidate()` and on any state change. */
+  clear(): void {
+    this.lines = null;
+    this.width = -1;
+  }
+}

package/utils.ts

@@ -187,6 +187,43 @@ export function getInstalledPackageVersion(startDir: string, packageName: string
   return getPackageVersion(root);
 }
 
+/** Cached pi version — resolved at most once per process. */
+let cachedPiVersion: string | null = null;
+
+/**
+ * Get the running Pi agent's version.
+ *
+ * Resolves by walking up from Pi's own entry point (`process.argv[1]`), which
+ * must be `realpath`'d first: the executable on PATH is typically a symlink
+ * (e.g. mise shims `~/.local/share/mise/installs/node/lts/bin/pi`), and the
+ * package.json lives next to the *real* `dist/cli.js`, not the link.
+ *
+ * Never spawns a subprocess. A previous implementation fell back to
+ * `execSync("pi --version")`, which cost ~350ms per call and still returned
+ * "unknown" because it matched against a `v` prefix that Pi no longer emits.
+ */
+export function getPiVersion(): string {
+  if (cachedPiVersion !== null) return cachedPiVersion;
+
+  const PI_PACKAGE = "@earendil-works/pi-coding-agent";
+  const entry = process.argv[1];
+  if (entry) {
+    try {
+      const realEntry = fs.realpathSync(entry);
+      const root = findPackageRoot(path.dirname(realEntry), PI_PACKAGE);
+      if (root) {
+        cachedPiVersion = getPackageVersion(root);
+        return cachedPiVersion;
+      }
+    } catch {
+      // Fall through to "unknown".
+    }
+  }
+
+  cachedPiVersion = "unknown";
+  return cachedPiVersion;
+}
+
 /**
  * Check if a module is available in node_modules.
  */