gsd-pi 2.8.3 → 2.10.0

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

@@ -0,0 +1,31 @@
+/** Options for fuzzy file path search. */
+export interface FuzzyFindOptions {
+  /** Fuzzy query to match against file paths (case-insensitive). */
+  query: string;
+  /** Directory to search. */
+  path: string;
+  /** Include hidden files (default: false). */
+  hidden?: boolean;
+  /** Respect .gitignore (default: true). */
+  gitignore?: boolean;
+  /** Maximum number of matches to return (default: 100). */
+  maxResults?: number;
+}
+
+/** A single match in fuzzy find results. */
+export interface FuzzyFindMatch {
+  /** Relative path from the search root (uses `/` separators). Directories have a trailing `/`. */
+  path: string;
+  /** Whether this entry is a directory. */
+  isDirectory: boolean;
+  /** Match quality score (higher is better). */
+  score: number;
+}
+
+/** Result of fuzzy file path search. */
+export interface FuzzyFindResult {
+  /** Matched entries (up to `maxResults`), sorted by score descending. */
+  matches: FuzzyFindMatch[];
+  /** Total number of matches found (may exceed `matches.length`). */
+  totalMatches: number;
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Native glob module using N-API.
+ *
+ * Gitignore-respecting filesystem discovery backed by Rust's `ignore` and
+ * `globset` crates, with an optional TTL-based scan cache for repeated queries.
+ */
+
+import { native } from "../native.js";
+import type {
+  GlobMatch,
+  GlobOptions,
+  GlobResult,
+} from "./types.js";
+
+export type { FileType, GlobMatch, GlobOptions, GlobResult } from "./types.js";
+
+/**
+ * Find filesystem entries matching a glob pattern.
+ *
+ * Respects .gitignore by default. Skips `.git` and `node_modules` unless
+ * the pattern explicitly mentions them.
+ *
+ * @param options - Glob search options (pattern, path, filters, etc.)
+ * @param onMatch - Optional streaming callback invoked for each match.
+ * @returns Promise resolving to matched entries.
+ */
+export function glob(
+  options: GlobOptions,
+  onMatch?: (match: GlobMatch) => void,
+): Promise<GlobResult> {
+  return native.glob(options, onMatch as ((match: unknown) => void) | undefined) as Promise<GlobResult>;
+}
+
+/**
+ * Invalidate the filesystem scan cache.
+ *
+ * Call after file mutations (write, edit, rename, delete) to ensure
+ * subsequent glob queries see fresh data.
+ *
+ * @param path - Specific path to invalidate, or omit to clear all.
+ */
+export function invalidateFsScanCache(path?: string): void {
+  native.invalidateFsScanCache(path);
+}

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

@@ -0,0 +1,53 @@
+/** File type classification for filesystem entries. */
+export const enum FileType {
+  /** Regular file. */
+  File = 1,
+  /** Directory. */
+  Dir = 2,
+  /** Symbolic link. */
+  Symlink = 3,
+}
+
+/** A single filesystem entry matched by a glob operation. */
+export interface GlobMatch {
+  /** Relative path from the search root, using forward slashes. */
+  path: string;
+  /** Resolved filesystem type for the match. */
+  fileType: FileType;
+  /** Modification time in milliseconds since Unix epoch. */
+  mtime: number | null;
+}
+
+/** Options for the glob operation. */
+export interface GlobOptions {
+  /** Glob pattern to match (e.g., "*.ts"). */
+  pattern: string;
+  /** Directory to search. */
+  path: string;
+  /** Filter by file type: File (1), Dir (2), or Symlink (3). */
+  fileType?: FileType;
+  /** Match simple patterns recursively by default (default: true). */
+  recursive?: boolean;
+  /** Include hidden files (default: false). */
+  hidden?: boolean;
+  /** Maximum number of results to return. */
+  maxResults?: number;
+  /** Respect .gitignore files (default: true). */
+  gitignore?: boolean;
+  /** Enable shared filesystem scan cache (default: false). */
+  cache?: boolean;
+  /** Sort results by mtime (most recent first) before applying limit. */
+  sortByMtime?: boolean;
+  /** Include node_modules entries (default: false, unless pattern mentions it). */
+  includeNodeModules?: boolean;
+  /** Timeout in milliseconds for the operation. */
+  timeoutMs?: number;
+}
+
+/** Result payload returned by a glob operation. */
+export interface GlobResult {
+  /** Matched filesystem entries. */
+  matches: GlobMatch[];
+  /** Number of returned matches. */
+  totalMatches: number;
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Native ripgrep wrapper using N-API.
+ *
+ * High-performance regex search backed by Rust's grep-* crates
+ * (the same internals as ripgrep).
+ */
+
+import { native } from "../native.js";
+import type {
+  ContextLine,
+  GrepMatch,
+  GrepOptions,
+  GrepResult,
+  SearchMatch,
+  SearchOptions,
+  SearchResult,
+} from "./types.js";
+
+export type {
+  ContextLine,
+  GrepMatch,
+  GrepOptions,
+  GrepResult,
+  SearchMatch,
+  SearchOptions,
+  SearchResult,
+};
+
+/**
+ * Search in-memory content for a regex pattern.
+ *
+ * Accepts a Buffer/Uint8Array of UTF-8 encoded content.
+ */
+export function searchContent(
+  content: Buffer | Uint8Array,
+  options: SearchOptions,
+): SearchResult {
+  return native.search(content, options) as SearchResult;
+}
+
+/**
+ * Search files on disk for a regex pattern.
+ *
+ * Walks the directory tree respecting .gitignore and optional glob filters.
+ */
+export function grep(options: GrepOptions): GrepResult {
+  return native.grep(options) as GrepResult;
+}

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);
+}