gsd-pi 2.8.3 → 2.10.0

package/node_modules/@gsd/native/src/__tests__/image.test.mjs

@@ -0,0 +1,137 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { deflateSync } from "node:zlib";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error("Native addon not found. Run 'npm run build:native -w @gsd/native' first.");
+  process.exit(1);
+}
+
+function crc32(buf) {
+  let crc = 0xffffffff;
+  const table = [];
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    table[n] = c;
+  }
+  for (let i = 0; i < buf.length; i++) crc = table[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function createTestPng() {
+  const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  const ihdrData = Buffer.alloc(13);
+  ihdrData.writeUInt32BE(2, 0);
+  ihdrData.writeUInt32BE(2, 4);
+  ihdrData[8] = 8;
+  ihdrData[9] = 2;
+  const ihdrType = Buffer.from("IHDR");
+  const ihdrCrc = Buffer.alloc(4);
+  ihdrCrc.writeUInt32BE(crc32(Buffer.concat([ihdrType, ihdrData])));
+  const ihdr = Buffer.concat([Buffer.from([0, 0, 0, 13]), ihdrType, ihdrData, ihdrCrc]);
+
+  const raw = Buffer.from([
+    0, 255, 0, 0, 255, 0, 0,
+    0, 255, 0, 0, 255, 0, 0,
+  ]);
+  const compressed = deflateSync(raw);
+  const idatType = Buffer.from("IDAT");
+  const idatLen = Buffer.alloc(4);
+  idatLen.writeUInt32BE(compressed.length);
+  const idatCrc = Buffer.alloc(4);
+  idatCrc.writeUInt32BE(crc32(Buffer.concat([idatType, compressed])));
+  const idat = Buffer.concat([idatLen, idatType, compressed, idatCrc]);
+
+  const iendType = Buffer.from("IEND");
+  const iendCrc = Buffer.alloc(4);
+  iendCrc.writeUInt32BE(crc32(iendType));
+  const iend = Buffer.concat([Buffer.from([0, 0, 0, 0]), iendType, iendCrc]);
+
+  return Buffer.concat([signature, ihdr, idat, iend]);
+}
+
+const NativeImage = native.NativeImage;
+
+describe("native image: NativeImage", () => {
+  test("NativeImage class exists with parse method", () => {
+    assert.ok(NativeImage, "NativeImage should be exported");
+    assert.equal(typeof NativeImage.parse, "function");
+  });
+
+  test("parse decodes PNG with correct dimensions", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    assert.equal(img.width, 2);
+    assert.equal(img.height, 2);
+  });
+
+  test("encode to PNG produces valid PNG", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    const encoded = await img.encode(0, 100);
+    assert.ok(encoded.length > 0);
+    assert.equal(encoded[0], 0x89);
+    assert.equal(encoded[1], 0x50);
+    assert.equal(encoded[2], 0x4e);
+    assert.equal(encoded[3], 0x47);
+  });
+
+  test("encode to JPEG produces valid JPEG", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    const encoded = await img.encode(1, 80);
+    assert.ok(encoded.length > 0);
+    assert.equal(encoded[0], 0xff);
+    assert.equal(encoded[1], 0xd8);
+  });
+
+  test("resize returns correct dimensions", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    const resized = await img.resize(10, 20, 5);
+    assert.equal(resized.width, 10);
+    assert.equal(resized.height, 20);
+  });
+
+  test("resize + encode round-trip", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    const resized = await img.resize(4, 4, 1);
+    const encoded = await resized.encode(0, 100);
+    assert.ok(encoded.length > 0);
+    const reparsed = await NativeImage.parse(new Uint8Array(encoded));
+    assert.equal(reparsed.width, 4);
+    assert.equal(reparsed.height, 4);
+  });
+
+  test("rejects invalid image data", async () => {
+    await assert.rejects(
+      () => NativeImage.parse(new Uint8Array([0, 1, 2, 3, 4, 5])),
+      /Failed to (detect|decode) image/,
+    );
+  });
+
+  test("rejects invalid format number", async () => {
+    const img = await NativeImage.parse(createTestPng());
+    await assert.rejects(() => img.encode(99, 100), /Invalid image format/);
+  });
+});

package/node_modules/@gsd/native/src/__tests__/ps.test.mjs

@@ -0,0 +1,109 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// Load the native addon directly
+const addonDir = path.resolve(__dirname, "..", "..", "..", "..", "native", "addon");
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error("Native addon not found. Run `npm run build:native -w @gsd/native` first.");
+  process.exit(1);
+}
+
+describe("native ps: listDescendants()", () => {
+  test("returns an array for the current process", () => {
+    const descendants = native.listDescendants(process.pid);
+    assert.ok(Array.isArray(descendants));
+  });
+
+  test("returns empty array for non-existent PID", () => {
+    // PID 2147483647 is extremely unlikely to exist
+    const descendants = native.listDescendants(2147483647);
+    assert.ok(Array.isArray(descendants));
+    assert.equal(descendants.length, 0);
+  });
+
+  test("finds child processes", { skip: "proc_listchildpids unreliable on macOS — needs sysctl KERN_PROC implementation" }, async () => {
+    const child = spawn("sh", ["-c", "sleep 30 & sleep 30 & wait"], {
+      stdio: "ignore",
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    try {
+      const descendants = native.listDescendants(child.pid);
+      assert.ok(descendants.length > 0, `expected descendants of sh (pid ${child.pid}), got: ${JSON.stringify(descendants)}`);
+    } finally {
+      native.killTree(child.pid, 9);
+    }
+  });
+});
+
+describe("native ps: killTree()", () => {
+  test("kills a process and its children", async () => {
+    // Spawn a shell that spawns a sleep subprocess
+    const child = spawn("sh", ["-c", "sleep 60"], { stdio: "ignore" });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    const killed = native.killTree(child.pid, 9);
+    assert.ok(killed >= 1, `should kill at least 1 process, killed: ${killed}`);
+
+    // Verify the child is actually dead
+    await new Promise((resolve) => {
+      child.on("exit", resolve);
+      // Timeout safety — if already exited, resolve immediately
+      setTimeout(resolve, 500);
+    });
+  });
+
+  test("returns 0 for non-existent PID", () => {
+    const killed = native.killTree(2147483647, 9);
+    assert.equal(killed, 0);
+  });
+});
+
+describe("native ps: processGroupId()", () => {
+  test("returns a number for the current process", () => {
+    const pgid = native.processGroupId(process.pid);
+    if (process.platform === "win32") {
+      assert.equal(pgid, null);
+    } else {
+      assert.equal(typeof pgid, "number");
+      assert.ok(pgid > 0);
+    }
+  });
+
+  test("returns null for non-existent PID", () => {
+    const pgid = native.processGroupId(2147483647);
+    assert.equal(pgid, null);
+  });
+});
+
+describe("native ps: killProcessGroup()", () => {
+  test("returns false for non-existent process group", () => {
+    const result = native.killProcessGroup(2147483647, 15);
+    assert.equal(result, false);
+  });
+});

package/node_modules/@gsd/native/src/__tests__/text.test.mjs

@@ -0,0 +1,262 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+
+// Load the native addon directly
+const addonDir = path.resolve(
+  __dirname,
+  "..",
+  "..",
+  "..",
+  "..",
+  "native",
+  "addon",
+);
+const platformTag = `${process.platform}-${process.arch}`;
+const candidates = [
+  path.join(addonDir, `gsd_engine.${platformTag}.node`),
+  path.join(addonDir, "gsd_engine.dev.node"),
+];
+
+let native;
+for (const candidate of candidates) {
+  try {
+    native = require(candidate);
+    break;
+  } catch {
+    // try next
+  }
+}
+
+if (!native) {
+  console.error(
+    "Native addon not found. Run `npm run build:native -w @gsd/native` first.",
+  );
+  process.exit(1);
+}
+
+// ── visibleWidth ───────────────────────────────────────────────────────
+
+describe("visibleWidth", () => {
+  test("plain ASCII text", () => {
+    assert.equal(native.visibleWidth("hello"), 5);
+  });
+
+  test("empty string", () => {
+    assert.equal(native.visibleWidth(""), 0);
+  });
+
+  test("ignores ANSI SGR codes", () => {
+    assert.equal(native.visibleWidth("\x1b[31mhello\x1b[0m"), 5);
+  });
+
+  test("ignores 256-color ANSI", () => {
+    assert.equal(native.visibleWidth("\x1b[38;5;196mred\x1b[0m"), 3);
+  });
+
+  test("ignores RGB ANSI", () => {
+    assert.equal(
+      native.visibleWidth("\x1b[38;2;255;128;0morange\x1b[0m"),
+      6,
+    );
+  });
+
+  test("counts tabs with default width", () => {
+    // default tab width = 3
+    assert.equal(native.visibleWidth("a\tb"), 1 + 3 + 1);
+  });
+
+  test("counts tabs with custom width", () => {
+    assert.equal(native.visibleWidth("a\tb", 4), 1 + 4 + 1);
+  });
+
+  test("CJK double-width characters", () => {
+    assert.equal(native.visibleWidth("\u4e16\u754c"), 4); // 世界
+  });
+
+  test("mixed ASCII and CJK", () => {
+    assert.equal(native.visibleWidth("a\u4e16b"), 4); // a + 2 + 1
+  });
+});
+
+// ── wrapTextWithAnsi ───────────────────────────────────────────────────
+
+describe("wrapTextWithAnsi", () => {
+  test("wraps plain text at word boundary", () => {
+    const lines = native.wrapTextWithAnsi("hello world", 5);
+    assert.equal(lines.length, 2);
+    assert.equal(lines[0], "hello");
+    assert.equal(lines[1], "world");
+  });
+
+  test("no wrap needed", () => {
+    const lines = native.wrapTextWithAnsi("hi", 10);
+    assert.equal(lines.length, 1);
+    assert.equal(lines[0], "hi");
+  });
+
+  test("empty string produces one empty line", () => {
+    const lines = native.wrapTextWithAnsi("", 10);
+    assert.equal(lines.length, 1);
+    assert.equal(lines[0], "");
+  });
+
+  test("preserves ANSI color across wrap", () => {
+    const lines = native.wrapTextWithAnsi(
+      "\x1b[38;2;156;163;176mhello world\x1b[0m",
+      5,
+    );
+    assert.equal(lines.length, 2);
+    assert.ok(lines[0].startsWith("\x1b[38;2;156;163;176m"));
+    assert.ok(lines[1].startsWith("\x1b[38;2;156;163;176m"));
+    assert.ok(lines[1].includes("world"));
+  });
+
+  test("handles multiline input (newlines)", () => {
+    const lines = native.wrapTextWithAnsi("line one\nline two", 20);
+    assert.equal(lines.length, 2);
+    assert.equal(lines[0], "line one");
+    assert.equal(lines[1], "line two");
+  });
+
+  test("breaks long words", () => {
+    const lines = native.wrapTextWithAnsi("abcdefghij", 5);
+    assert.equal(lines.length, 2);
+    assert.equal(lines[0], "abcde");
+    assert.equal(lines[1], "fghij");
+  });
+});
+
+// ── truncateToWidth ────────────────────────────────────────────────────
+
+describe("truncateToWidth", () => {
+  test("returns original when fits", () => {
+    const result = native.truncateToWidth("hello", 10, 0, false);
+    assert.equal(result, "hello");
+  });
+
+  test("truncates with unicode ellipsis", () => {
+    const result = native.truncateToWidth("hello world", 6, 0, false);
+    assert.equal(native.visibleWidth(result), 6);
+    assert.ok(result.includes("\u2026"));
+  });
+
+  test("truncates with ASCII ellipsis", () => {
+    const result = native.truncateToWidth("hello world", 8, 1, false);
+    assert.ok(result.includes("..."));
+  });
+
+  test("truncates with no ellipsis", () => {
+    const result = native.truncateToWidth("hello world", 5, 2, false);
+    assert.equal(native.visibleWidth(result), 5);
+    assert.ok(!result.includes("\u2026"));
+    assert.ok(!result.includes("..."));
+  });
+
+  test("pads to width", () => {
+    const result = native.truncateToWidth("hi", 10, 0, true);
+    assert.equal(native.visibleWidth(result), 10);
+  });
+
+  test("preserves ANSI codes and resets on truncation", () => {
+    const input = "\x1b[31mhello world\x1b[0m";
+    const result = native.truncateToWidth(input, 6, 0, false);
+    // Should contain the red code and a reset before ellipsis
+    assert.ok(result.includes("\x1b[31m"));
+    assert.ok(result.includes("\x1b[0m"));
+  });
+});
+
+// ── sliceWithWidth ─────────────────────────────────────────────────────
+
+describe("sliceWithWidth", () => {
+  test("slices from start", () => {
+    const result = native.sliceWithWidth("hello world", 0, 5, false);
+    assert.equal(result.text, "hello");
+    assert.equal(result.width, 5);
+  });
+
+  test("slices from middle", () => {
+    const result = native.sliceWithWidth("hello world", 6, 5, false);
+    assert.equal(result.text, "world");
+    assert.equal(result.width, 5);
+  });
+
+  test("preserves ANSI codes in slice", () => {
+    const result = native.sliceWithWidth(
+      "\x1b[31mhello\x1b[0m world",
+      0,
+      5,
+      false,
+    );
+    assert.equal(result.text, "\x1b[31mhello\x1b[0m");
+    assert.equal(result.width, 5);
+  });
+
+  test("empty slice", () => {
+    const result = native.sliceWithWidth("hello", 0, 0, false);
+    assert.equal(result.text, "");
+    assert.equal(result.width, 0);
+  });
+
+  test("beyond string length", () => {
+    const result = native.sliceWithWidth("hi", 0, 100, false);
+    assert.equal(result.text, "hi");
+    assert.equal(result.width, 2);
+  });
+});
+
+// ── extractSegments ────────────────────────────────────────────────────
+
+describe("extractSegments", () => {
+  test("extracts before and after segments", () => {
+    const result = native.extractSegments(
+      "hello world test",
+      5,
+      6,
+      5,
+      false,
+    );
+    assert.equal(result.before, "hello");
+    assert.equal(result.beforeWidth, 5);
+    assert.equal(result.after, "world");
+    assert.equal(result.afterWidth, 5);
+  });
+
+  test("handles no after segment", () => {
+    const result = native.extractSegments("hello world", 5, 0, 0, false);
+    assert.equal(result.before, "hello");
+    assert.equal(result.beforeWidth, 5);
+    assert.equal(result.after, "");
+    assert.equal(result.afterWidth, 0);
+  });
+});
+
+// ── sanitizeText ───────────────────────────────────────────────────────
+
+describe("sanitizeText", () => {
+  test("strips ANSI codes", () => {
+    assert.equal(native.sanitizeText("\x1b[31mhello\x1b[0m"), "hello");
+  });
+
+  test("returns original when clean", () => {
+    assert.equal(native.sanitizeText("hello"), "hello");
+  });
+
+  test("removes control characters", () => {
+    assert.equal(native.sanitizeText("he\x01llo"), "hello");
+  });
+
+  test("preserves tabs and newlines", () => {
+    assert.equal(native.sanitizeText("a\tb\nc"), "a\tb\nc");
+  });
+
+  test("normalizes CR", () => {
+    assert.equal(native.sanitizeText("hello\r\nworld"), "hello\nworld");
+  });
+});

package/node_modules/@gsd/native/src/ast/index.ts

@@ -0,0 +1,12 @@
+import { native } from "../native.js";
+import type { AstFindOptions, AstFindResult, AstReplaceOptions, AstReplaceResult, AstFindMatch, AstReplaceChange, AstReplaceFileChange } from "./types.js";
+
+export type { AstFindMatch, AstFindOptions, AstFindResult, AstReplaceChange, AstReplaceFileChange, AstReplaceOptions, AstReplaceResult };
+
+export function astGrep(options: AstFindOptions): AstFindResult {
+  return (native as Record<string, Function>).astGrep(options) as AstFindResult;
+}
+
+export function astEdit(options: AstReplaceOptions): AstReplaceResult {
+  return (native as Record<string, Function>).astEdit(options) as AstReplaceResult;
+}

package/node_modules/@gsd/native/src/ast/types.ts

@@ -0,0 +1,75 @@
+export interface AstFindOptions {
+  patterns: string[];
+  lang?: string;
+  path?: string;
+  glob?: string;
+  selector?: string;
+  strictness?: string;
+  limit?: number;
+  offset?: number;
+  includeMeta?: boolean;
+  context?: number;
+}
+
+export interface AstFindMatch {
+  path: string;
+  text: string;
+  byteStart: number;
+  byteEnd: number;
+  startLine: number;
+  startColumn: number;
+  endLine: number;
+  endColumn: number;
+  metaVariables?: Record<string, string>;
+}
+
+export interface AstFindResult {
+  matches: AstFindMatch[];
+  totalMatches: number;
+  filesWithMatches: number;
+  filesSearched: number;
+  limitReached: boolean;
+  parseErrors?: string[];
+}
+
+export interface AstReplaceOptions {
+  rewrites: Record<string, string>;
+  lang?: string;
+  path?: string;
+  glob?: string;
+  selector?: string;
+  strictness?: string;
+  dryRun?: boolean;
+  maxReplacements?: number;
+  maxFiles?: number;
+  failOnParseError?: boolean;
+}
+
+export interface AstReplaceChange {
+  path: string;
+  before: string;
+  after: string;
+  byteStart: number;
+  byteEnd: number;
+  deletedLength: number;
+  startLine: number;
+  startColumn: number;
+  endLine: number;
+  endColumn: number;
+}
+
+export interface AstReplaceFileChange {
+  path: string;
+  count: number;
+}
+
+export interface AstReplaceResult {
+  changes: AstReplaceChange[];
+  fileChanges: AstReplaceFileChange[];
+  totalReplacements: number;
+  filesTouched: number;
+  filesSearched: number;
+  applied: boolean;
+  limitReached: boolean;
+  parseErrors?: string[];
+}

package/node_modules/@gsd/native/src/clipboard/index.ts

@@ -0,0 +1,40 @@
+/**
+ * Native clipboard access using N-API.
+ *
+ * Cross-platform clipboard read/write backed by the `arboard` Rust crate.
+ * No external tools (pbcopy, xclip, etc.) required.
+ */
+
+import { native } from "../native.js";
+import type { ClipboardImage } from "./types.js";
+
+export type { ClipboardImage };
+
+/**
+ * Copy plain text to the system clipboard.
+ *
+ * Runs synchronously to avoid macOS AppKit pasteboard warnings
+ * when writing from worker threads.
+ */
+export function copyToClipboard(text: string): void {
+  native.copyToClipboard(text);
+}
+
+/**
+ * Read plain text from the system clipboard.
+ *
+ * Returns `null` when no text data is available.
+ */
+export function readTextFromClipboard(): string | null {
+  return native.readTextFromClipboard() as string | null;
+}
+
+/**
+ * Read an image from the system clipboard.
+ *
+ * Returns a Promise that resolves to a `ClipboardImage` (PNG-encoded bytes)
+ * or `null` when no image data is available.
+ */
+export function readImageFromClipboard(): Promise<ClipboardImage | null> {
+  return native.readImageFromClipboard() as Promise<ClipboardImage | null>;
+}

package/node_modules/@gsd/native/src/clipboard/types.ts

@@ -0,0 +1,7 @@
+/** Clipboard image payload encoded as PNG bytes. */
+export interface ClipboardImage {
+  /** PNG-encoded image bytes. */
+  data: Uint8Array;
+  /** MIME type for the encoded image payload (always "image/png"). */
+  mimeType: string;
+}

package/node_modules/@gsd/native/src/fd/index.ts

@@ -0,0 +1,35 @@
+/**
+ * Native fuzzy file path discovery using N-API.
+ *
+ * High-performance fuzzy file search for autocomplete and @-mention resolution.
+ * Backed by Rust's `ignore` crate for directory walking with subsequence scoring.
+ */
+
+import { native } from "../native.js";
+import type {
+  FuzzyFindMatch,
+  FuzzyFindOptions,
+  FuzzyFindResult,
+} from "./types.js";
+
+export type { FuzzyFindMatch, FuzzyFindOptions, FuzzyFindResult };
+
+/**
+ * Fuzzy file path search.
+ *
+ * Searches for files and directories whose paths match the query string.
+ * Results are sorted by match quality (higher score = better match).
+ *
+ * Scoring tiers (highest to lowest):
+ * - 120: exact filename match
+ * - 100: filename starts with query
+ * - 80: filename contains query
+ * - 60: full path contains query
+ * - 50-90: fuzzy subsequence match on filename
+ * - 30-70: fuzzy subsequence match on full path
+ *
+ * Directories receive a +10 score bonus.
+ */
+export function fuzzyFind(options: FuzzyFindOptions): FuzzyFindResult {
+  return native.fuzzyFind(options) as FuzzyFindResult;
+}