gsd-pi 2.9.0 → 2.10.0

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

@@ -0,0 +1,105 @@
+/** A context line adjacent to a match. */
+export interface ContextLine {
+  /** 1-indexed line number. */
+  lineNumber: number;
+  /** Line content (trailing newline stripped). */
+  line: string;
+}
+
+/** A single match from in-memory content search. */
+export interface SearchMatch {
+  /** 1-indexed line number. */
+  lineNumber: number;
+  /** The matched line content. */
+  line: string;
+  /** Context lines before the match. */
+  contextBefore: ContextLine[];
+  /** Context lines after the match. */
+  contextAfter: ContextLine[];
+  /** Whether the line was truncated due to maxColumns. */
+  truncated: boolean;
+}
+
+/** Result of searching in-memory content. */
+export interface SearchResult {
+  /** All matches found. */
+  matches: SearchMatch[];
+  /** Total number of matches (may exceed matches.length due to limit). */
+  matchCount: number;
+  /** Whether the limit was reached. */
+  limitReached: boolean;
+}
+
+/** Options for in-memory content search. */
+export interface SearchOptions {
+  /** Regex pattern to search for. */
+  pattern: string;
+  /** Case-insensitive matching. */
+  ignoreCase?: boolean;
+  /** Enable multiline regex mode. */
+  multiline?: boolean;
+  /** Maximum number of matches to return. */
+  maxCount?: number;
+  /** Lines of context before matches. */
+  contextBefore?: number;
+  /** Lines of context after matches. */
+  contextAfter?: number;
+  /** Truncate lines longer than this (characters). */
+  maxColumns?: number;
+}
+
+/** A single match from filesystem search. */
+export interface GrepMatch {
+  /** File path (relative for directory searches). */
+  path: string;
+  /** 1-indexed line number. */
+  lineNumber: number;
+  /** The matched line content. */
+  line: string;
+  /** Context lines before the match. */
+  contextBefore: ContextLine[];
+  /** Context lines after the match. */
+  contextAfter: ContextLine[];
+  /** Whether the line was truncated. */
+  truncated: boolean;
+}
+
+/** Result of a filesystem search. */
+export interface GrepResult {
+  /** All matches found. */
+  matches: GrepMatch[];
+  /** Total matches across all files. */
+  totalMatches: number;
+  /** Number of files with at least one match. */
+  filesWithMatches: number;
+  /** Number of files searched. */
+  filesSearched: number;
+  /** Whether the limit stopped the search early. */
+  limitReached: boolean;
+}
+
+/** Options for filesystem search. */
+export interface GrepOptions {
+  /** Regex pattern to search for. */
+  pattern: string;
+  /** Directory or file to search. */
+  path: string;
+  /** Glob filter for filenames (e.g. "*.ts"). */
+  glob?: string;
+  /** Case-insensitive matching. */
+  ignoreCase?: boolean;
+  /** Enable multiline regex mode. */
+  multiline?: boolean;
+  /** Include hidden files (default: false). */
+  hidden?: boolean;
+  /** Respect .gitignore files (default: true). */
+  gitignore?: boolean;
+  /** Maximum number of matches to return. */
+  maxCount?: number;
+  /** Lines of context before matches. */
+  contextBefore?: number;
+  /** Lines of context after matches. */
+  contextAfter?: number;
+  /** Truncate lines longer than this (characters). */
+  maxColumns?: number;
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Syntect-based syntax highlighting via N-API.
+ *
+ * Provides ANSI-colored output for code blocks using semantic scope matching
+ * across 11 token categories.
+ */
+
+import { native } from "../native.js";
+import type { HighlightColors } from "./types.js";
+
+export type { HighlightColors };
+
+/**
+ * Highlight source code and return ANSI-colored output.
+ *
+ * @param code - The source code to highlight
+ * @param lang - Language identifier (e.g., "rust", "typescript", "python"), or null for plain text
+ * @param colors - Theme colors as ANSI escape sequences
+ * @returns Highlighted code with ANSI color codes
+ */
+export function highlightCode(
+  code: string,
+  lang: string | null,
+  colors: HighlightColors,
+): string {
+  return native.highlightCode(code, lang, colors) as string;
+}
+
+/**
+ * Check if a language is supported for highlighting.
+ *
+ * Returns true if the language has either direct syntect support or a
+ * fallback alias mapping.
+ */
+export function supportsLanguage(lang: string): boolean {
+  return native.supportsLanguage(lang) as boolean;
+}
+
+/**
+ * Get list of all supported language names from syntect's default syntax set.
+ */
+export function getSupportedLanguages(): string[] {
+  return native.getSupportedLanguages() as string[];
+}

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

@@ -0,0 +1,25 @@
+/** Theme colors for syntax highlighting as ANSI escape sequences. */
+export interface HighlightColors {
+  /** ANSI color for comments. */
+  comment: string;
+  /** ANSI color for keywords. */
+  keyword: string;
+  /** ANSI color for function names. */
+  function: string;
+  /** ANSI color for variables and identifiers. */
+  variable: string;
+  /** ANSI color for string literals. */
+  string: string;
+  /** ANSI color for numeric literals. */
+  number: string;
+  /** ANSI color for type identifiers. */
+  type: string;
+  /** ANSI color for operators. */
+  operator: string;
+  /** ANSI color for punctuation tokens. */
+  punctuation: string;
+  /** ANSI color for diff inserted lines. */
+  inserted?: string;
+  /** ANSI color for diff deleted lines. */
+  deleted?: string;
+}

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

@@ -0,0 +1,24 @@
+/**
+ * HTML to Markdown conversion via native Rust bindings.
+ *
+ * Uses `html-to-markdown-rs` under the hood for high-performance
+ * conversion with optional content cleaning (stripping nav, forms, etc.).
+ */
+
+import { native } from "../native.js";
+import type { HtmlToMarkdownOptions } from "./types.js";
+
+export type { HtmlToMarkdownOptions };
+
+/**
+ * Convert an HTML string to Markdown.
+ *
+ * When `cleanContent` is true, boilerplate elements (nav, forms, headers,
+ * footers) are stripped before conversion.
+ */
+export function htmlToMarkdown(
+  html: string,
+  options?: HtmlToMarkdownOptions,
+): string {
+  return native.htmlToMarkdown(html, options ?? {}) as string;
+}

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

@@ -0,0 +1,7 @@
+/** Options for HTML to Markdown conversion. */
+export interface HtmlToMarkdownOptions {
+  /** Remove navigation elements, forms, headers, footers. */
+  cleanContent?: boolean;
+  /** Skip images during conversion. */
+  skipImages?: boolean;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Native image processing module using N-API.
+ *
+ * High-performance image decode/encode/resize backed by the Rust `image` crate.
+ */
+
+import { native } from "../native.js";
+import type { NativeImageHandle } from "./types.js";
+import { ImageFormat, SamplingFilter } from "./types.js";
+
+export { ImageFormat, SamplingFilter };
+export type { NativeImageHandle };
+
+const NativeImageClass = (native as Record<string, unknown>)
+  .NativeImage as NativeImageConstructor;
+
+interface NativeImageConstructor {
+  parse(bytes: Uint8Array): Promise<NativeImageHandle>;
+}
+
+/**
+ * Decode image bytes (PNG, JPEG, WebP, GIF) into a NativeImage handle.
+ *
+ * Format is auto-detected from the byte content.
+ */
+export function parseImage(bytes: Uint8Array): Promise<NativeImageHandle> {
+  return NativeImageClass.parse(bytes);
+}

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

@@ -0,0 +1,41 @@
+/** Sampling filter for resize operations. */
+export enum SamplingFilter {
+  /** Nearest-neighbor sampling (fast, low quality). */
+  Nearest = 1,
+  /** Triangle filter (linear interpolation). */
+  Triangle = 2,
+  /** Catmull-Rom filter with sharper edges. */
+  CatmullRom = 3,
+  /** Gaussian filter for smoother results. */
+  Gaussian = 4,
+  /** Lanczos3 filter for high-quality downscaling. */
+  Lanczos3 = 5,
+}
+
+/** Output image format for encoding. */
+export enum ImageFormat {
+  /** PNG (lossless, quality ignored). */
+  PNG = 0,
+  /** JPEG (lossy, quality 0-100). */
+  JPEG = 1,
+  /** WebP (lossless, quality ignored). */
+  WebP = 2,
+  /** GIF (quality ignored). */
+  GIF = 3,
+}
+
+/** Native image handle returned from parse(). */
+export interface NativeImageHandle {
+  /** Image width in pixels. */
+  readonly width: number;
+  /** Image height in pixels. */
+  readonly height: number;
+  /** Encode to bytes in the specified format. Returns a Promise. */
+  encode(format: number, quality: number): Promise<number[]>;
+  /** Resize to the specified dimensions. Returns a new NativeImage Promise. */
+  resize(
+    width: number,
+    height: number,
+    filter: SamplingFilter,
+  ): Promise<NativeImageHandle>;
+}

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

@@ -0,0 +1,88 @@
+/**
+ * @gsd/native — High-performance Rust modules exposed via N-API.
+ *
+ * Modules:
+ * - clipboard: native clipboard access (text + image)
+ * - grep: ripgrep-backed regex search (content + filesystem)
+ * - ps: cross-platform process tree management
+ * - glob: gitignore-respecting filesystem discovery with scan caching
+ * - highlight: syntect-based syntax highlighting
+ * - html: HTML to Markdown conversion
+ * - text: ANSI-aware text measurement and slicing
+ * - fd: fuzzy file path discovery
+ * - image: decode, encode, and resize images
+ for autocomplete and @-mention resolution
+ */
+
+export {
+  copyToClipboard,
+  readTextFromClipboard,
+  readImageFromClipboard,
+} from "./clipboard/index.js";
+export type { ClipboardImage } from "./clipboard/index.js";
+
+export {
+  highlightCode,
+  supportsLanguage,
+  getSupportedLanguages,
+} from "./highlight/index.js";
+export type { HighlightColors } from "./highlight/index.js";
+
+export { searchContent, grep } from "./grep/index.js";
+export type {
+  ContextLine,
+  GrepMatch,
+  GrepOptions,
+  GrepResult,
+  SearchMatch,
+  SearchOptions,
+  SearchResult,
+} from "./grep/index.js";
+
+export {
+  killTree,
+  listDescendants,
+  processGroupId,
+  killProcessGroup,
+} from "./ps/index.js";
+
+export { glob, invalidateFsScanCache } from "./glob/index.js";
+export type {
+  FileType,
+  GlobMatch,
+  GlobOptions,
+  GlobResult,
+} from "./glob/index.js";
+
+export { astGrep, astEdit } from "./ast/index.js";
+export type {
+  AstFindMatch, AstFindOptions, AstFindResult,
+  AstReplaceChange, AstReplaceFileChange, AstReplaceOptions, AstReplaceResult,
+} from "./ast/index.js";
+
+export { htmlToMarkdown } from "./html/index.js";
+export type { HtmlToMarkdownOptions } from "./html/index.js";
+
+export {
+  wrapTextWithAnsi,
+  truncateToWidth,
+  sliceWithWidth,
+  extractSegments,
+  sanitizeText,
+  visibleWidth,
+  EllipsisKind,
+} from "./text/index.js";
+export type { SliceResult, ExtractSegmentsResult } from "./text/index.js";
+
+export { fuzzyFind } from "./fd/index.js";
+export type {
+  FuzzyFindMatch,
+  FuzzyFindOptions,
+  FuzzyFindResult,
+} from "./fd/index.js";
+
+export { parseImage, ImageFormat, SamplingFilter } from "./image/index.js";
+export type { NativeImageHandle } from "./image/index.js";
+
+export { ttsrCompileRules, ttsrCheckBuffer, ttsrFreeRules } from "./ttsr/index.js";
+export type { TtsrHandle, TtsrRuleInput } from "./ttsr/index.js";

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

@@ -0,0 +1,94 @@
+/**
+ * Native addon loader.
+ *
+ * Locates and loads the compiled Rust N-API addon (`.node` file).
+ * Tries platform-tagged release builds first, then falls back to dev builds.
+ */
+
+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);
+
+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"),
+];
+
+function loadNative(): Record<string, unknown> {
+  const errors: string[] = [];
+
+  for (const candidate of candidates) {
+    try {
+      return require(candidate) as Record<string, unknown>;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errors.push(`${candidate}: ${message}`);
+    }
+  }
+
+  const details = errors.map((e) => `  - ${e}`).join("\n");
+  throw new Error(
+    `Failed to load gsd_engine native addon for ${platformTag}.\n\n` +
+      `Tried:\n${details}\n\n` +
+      `Build with: npm run build:native -w @gsd/native`,
+  );
+}
+
+export const native = loadNative() as {
+  search: (content: Buffer | Uint8Array, options: unknown) => unknown;
+  grep: (options: unknown) => unknown;
+  killTree: (pid: number, signal: number) => number;
+  listDescendants: (pid: number) => number[];
+  processGroupId: (pid: number) => number | null;
+  killProcessGroup: (pgid: number, signal: number) => boolean;
+  glob: (
+    options: unknown,
+    onMatch?: ((match: unknown) => void) | undefined | null,
+  ) => Promise<unknown>;
+  invalidateFsScanCache: (path?: string) => void;
+  highlightCode: (code: string, lang: string | null, colors: unknown) => unknown;
+  supportsLanguage: (lang: string) => unknown;
+  getSupportedLanguages: () => unknown;
+  copyToClipboard: (text: string) => void;
+  readTextFromClipboard: () => string | null;
+  readImageFromClipboard: () => Promise<unknown>;
+  astGrep: (options: unknown) => unknown;
+  astEdit: (options: unknown) => unknown;
+  htmlToMarkdown: (html: string, options: unknown) => unknown;
+  wrapTextWithAnsi: (text: string, width: number, tabWidth?: number) => string[];
+  truncateToWidth: (
+    text: string,
+    maxWidth: number,
+    ellipsisKind: number,
+    pad: boolean,
+    tabWidth?: number,
+  ) => string;
+  sliceWithWidth: (
+    line: string,
+    startCol: number,
+    length: number,
+    strict: boolean,
+    tabWidth?: number,
+  ) => unknown;
+  extractSegments: (
+    line: string,
+    beforeEnd: number,
+    afterStart: number,
+    afterLen: number,
+    strictAfter: boolean,
+    tabWidth?: number,
+  ) => unknown;
+  sanitizeText: (text: string) => string;
+  visibleWidth: (text: string, tabWidth?: number) => number;
+  fuzzyFind: (options: unknown) => unknown;
+  NativeImage: unknown;
+  ttsrCompileRules: (rules: unknown[]) => number;
+  ttsrCheckBuffer: (handle: number, buffer: string) => string[];
+  ttsrFreeRules: (handle: number) => void;
+};

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

@@ -0,0 +1,52 @@
+/**
+ * Cross-platform process tree management via N-API.
+ *
+ * Provides efficient process tree enumeration and termination
+ * using platform-native APIs (libproc on macOS, /proc on Linux,
+ * Toolhelp32 on Windows).
+ */
+
+import { native } from "../native.js";
+
+/**
+ * Kill a process tree (the process and all its descendants).
+ *
+ * Kills children first (bottom-up) to prevent orphan re-parenting issues.
+ * @param pid - Root process ID
+ * @param signal - Signal to send (e.g. 9 for SIGKILL, 15 for SIGTERM). Ignored on Windows.
+ * @returns Number of processes successfully killed.
+ */
+export function killTree(pid: number, signal: number): number {
+  return native.killTree(pid, signal);
+}
+
+/**
+ * List all descendant PIDs of a process.
+ *
+ * @param pid - Parent process ID
+ * @returns Array of descendant PIDs (empty if no children or process doesn't exist).
+ */
+export function listDescendants(pid: number): number[] {
+  return native.listDescendants(pid);
+}
+
+/**
+ * Get the process group ID for a process.
+ *
+ * @param pid - Process ID
+ * @returns Process group ID, or null if the process doesn't exist or on Windows.
+ */
+export function processGroupId(pid: number): number | null {
+  return native.processGroupId(pid);
+}
+
+/**
+ * Kill an entire process group.
+ *
+ * @param pgid - Process group ID
+ * @param signal - Signal to send
+ * @returns true if the signal was delivered, false on failure or Windows.
+ */
+export function killProcessGroup(pgid: number, signal: number): boolean {
+  return native.killProcessGroup(pgid, signal);
+}

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

@@ -0,0 +1,5 @@
+/** Result of a process tree kill operation. */
+export interface KillTreeResult {
+  /** Number of processes successfully killed. */
+  killed: number;
+}

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

@@ -0,0 +1,125 @@
+/**
+ * ANSI-aware text measurement and slicing.
+ *
+ * High-performance UTF-16 native implementation with ASCII fast-paths,
+ * single-pass ANSI scanning, and proper Unicode grapheme cluster support.
+ */
+
+import { native } from "../native.js";
+import type { ExtractSegmentsResult, SliceResult } from "./types.js";
+
+export type { ExtractSegmentsResult, SliceResult };
+export { EllipsisKind } from "./types.js";
+
+/**
+ * Word-wrap text to a visible width, preserving ANSI escape codes across
+ * line breaks.
+ *
+ * Active SGR codes (colors, bold, etc.) are carried to continuation lines.
+ * Underline and strikethrough are reset at line ends and restored on the
+ * next line.
+ */
+export function wrapTextWithAnsi(
+  text: string,
+  width: number,
+  tabWidth?: number,
+): string[] {
+  return (native as Record<string, Function>).wrapTextWithAnsi(
+    text,
+    width,
+    tabWidth,
+  ) as string[];
+}
+
+/**
+ * Truncate text to a visible width with an optional ellipsis.
+ *
+ * @param text       Input string (may contain ANSI codes).
+ * @param maxWidth   Maximum visible width in terminal cells.
+ * @param ellipsisKind  0 = "\u2026", 1 = "...", 2 = none.
+ * @param pad        When true, pad with spaces to exactly `maxWidth`.
+ * @param tabWidth   Tab stop width (default 3, range 1-16).
+ */
+export function truncateToWidth(
+  text: string,
+  maxWidth: number,
+  ellipsisKind: number,
+  pad: boolean,
+  tabWidth?: number,
+): string {
+  return (native as Record<string, Function>).truncateToWidth(
+    text,
+    maxWidth,
+    ellipsisKind,
+    pad,
+    tabWidth,
+  ) as string;
+}
+
+/**
+ * Slice a range of visible columns from a line.
+ *
+ * Counts terminal cells (skipping ANSI escapes). When `strict` is true,
+ * wide characters that would exceed the range are excluded.
+ */
+export function sliceWithWidth(
+  line: string,
+  startCol: number,
+  length: number,
+  strict: boolean,
+  tabWidth?: number,
+): SliceResult {
+  return (native as Record<string, Function>).sliceWithWidth(
+    line,
+    startCol,
+    length,
+    strict,
+    tabWidth,
+  ) as SliceResult;
+}
+
+/**
+ * Extract the before/after segments around an overlay region.
+ *
+ * ANSI state is tracked so the `after` segment renders correctly even when
+ * the overlay truncates styled text.
+ */
+export function extractSegments(
+  line: string,
+  beforeEnd: number,
+  afterStart: number,
+  afterLen: number,
+  strictAfter: boolean,
+  tabWidth?: number,
+): ExtractSegmentsResult {
+  return (native as Record<string, Function>).extractSegments(
+    line,
+    beforeEnd,
+    afterStart,
+    afterLen,
+    strictAfter,
+    tabWidth,
+  ) as ExtractSegmentsResult;
+}
+
+/**
+ * Strip ANSI escape sequences, remove control characters and lone
+ * surrogates, and normalize line endings (CR removed).
+ *
+ * Returns the original string when no changes are needed (zero-copy).
+ */
+export function sanitizeText(text: string): string {
+  return (native as Record<string, Function>).sanitizeText(text) as string;
+}
+
+/**
+ * Calculate visible width of text excluding ANSI escape sequences.
+ *
+ * Tabs count as `tabWidth` cells (default 3).
+ */
+export function visibleWidth(text: string, tabWidth?: number): number {
+  return (native as Record<string, Function>).visibleWidth(
+    text,
+    tabWidth,
+  ) as number;
+}

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

@@ -0,0 +1,29 @@
+/** Result of slicing a line by visible column range. */
+export interface SliceResult {
+  /** The extracted text (may include ANSI codes). */
+  text: string;
+  /** Visible width of the extracted slice in terminal cells. */
+  width: number;
+}
+
+/** Result of extracting before/after segments around an overlay. */
+export interface ExtractSegmentsResult {
+  /** Text content before the overlay region. */
+  before: string;
+  /** Visible width of the `before` segment. */
+  beforeWidth: number;
+  /** Text content after the overlay region. */
+  after: string;
+  /** Visible width of the `after` segment. */
+  afterWidth: number;
+}
+
+/** Ellipsis style for truncation. */
+export enum EllipsisKind {
+  /** Unicode ellipsis character: \u2026 (width 1) */
+  Unicode = 0,
+  /** ASCII ellipsis: "..." (width 3) */
+  Ascii = 1,
+  /** No ellipsis (hard truncate) */
+  None = 2,
+}