gsd-pi 2.10.0 → 2.10.2

package/packages/native/dist/ttsr/index.js

@@ -0,0 +1,32 @@
+/**
+ * Native TTSR regex engine.
+ *
+ * Pre-compiles all rule condition patterns into a single Rust RegexSet for
+ * O(1)-style matching per buffer check, replacing per-rule JS regex iteration.
+ */
+import { native } from "../native.js";
+/**
+ * Compile TTSR rules into an optimized native regex engine.
+ *
+ * Returns an opaque handle for use with `ttsrCheckBuffer` and `ttsrFreeRules`.
+ */
+export function ttsrCompileRules(rules) {
+    return native.ttsrCompileRules(rules);
+}
+/**
+ * Check a buffer against compiled TTSR rules.
+ *
+ * Returns an array of unique rule names whose conditions matched.
+ * All patterns are tested in a single pass via Rust's RegexSet.
+ */
+export function ttsrCheckBuffer(handle, buffer) {
+    return native.ttsrCheckBuffer(handle, buffer);
+}
+/**
+ * Free a compiled TTSR rule set, releasing native memory.
+ *
+ * Call when rules are no longer needed (e.g., session end).
+ */
+export function ttsrFreeRules(handle) {
+    native.ttsrFreeRules(handle);
+}

package/packages/native/dist/ttsr/types.d.ts

@@ -0,0 +1,9 @@
+/** Input rule for TTSR regex compilation. */
+export interface TtsrRuleInput {
+    /** Unique rule name. */
+    name: string;
+    /** Regex condition patterns (any match triggers the rule). */
+    conditions: string[];
+}
+/** Opaque handle to a compiled TTSR rule set. */
+export type TtsrHandle = number;

package/packages/native/dist/ttsr/types.js

@@ -0,0 +1 @@
+export {};

package/packages/native/package.json

@@ -3,57 +3,58 @@
   "version": "0.1.0",
   "description": "Native Rust bindings for GSD \u2014 high-performance native modules via N-API",
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
+    "build": "tsc -p tsconfig.json",
     "build:native": "node ../../native/scripts/build.js",
     "build:native:dev": "node ../../native/scripts/build.js --dev",
     "test": "node --test src/__tests__/grep.test.mjs src/__tests__/ps.test.mjs src/__tests__/glob.test.mjs src/__tests__/clipboard.test.mjs src/__tests__/highlight.test.mjs src/__tests__/html.test.mjs src/__tests__/text.test.mjs src/__tests__/fd.test.mjs src/__tests__/image.test.mjs"
   },
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./grep": {
-      "types": "./src/grep/index.ts",
-      "import": "./src/grep/index.ts"
+      "types": "./dist/grep/index.d.ts",
+      "import": "./dist/grep/index.js"
     },
     "./ps": {
-      "types": "./src/ps/index.ts",
-      "import": "./src/ps/index.ts"
+      "types": "./dist/ps/index.d.ts",
+      "import": "./dist/ps/index.js"
     },
     "./glob": {
-      "types": "./src/glob/index.ts",
-      "import": "./src/glob/index.ts"
+      "types": "./dist/glob/index.d.ts",
+      "import": "./dist/glob/index.js"
     },
     "./clipboard": {
-      "types": "./src/clipboard/index.ts",
-      "import": "./src/clipboard/index.ts"
+      "types": "./dist/clipboard/index.d.ts",
+      "import": "./dist/clipboard/index.js"
     },
     "./ast": {
-      "types": "./src/ast/index.ts",
-      "import": "./src/ast/index.ts"
+      "types": "./dist/ast/index.d.ts",
+      "import": "./dist/ast/index.js"
     },
     "./html": {
-      "types": "./src/html/index.ts",
-      "import": "./src/html/index.ts"
+      "types": "./dist/html/index.d.ts",
+      "import": "./dist/html/index.js"
     },
     "./text": {
-      "types": "./src/text/index.ts",
-      "import": "./src/text/index.ts"
+      "types": "./dist/text/index.d.ts",
+      "import": "./dist/text/index.js"
     },
     "./fd": {
-      "types": "./src/fd/index.ts",
-      "import": "./src/fd/index.ts"
+      "types": "./dist/fd/index.d.ts",
+      "import": "./dist/fd/index.js"
     },
     "./image": {
-      "types": "./src/image/index.ts",
-      "import": "./src/image/index.ts"
+      "types": "./dist/image/index.d.ts",
+      "import": "./dist/image/index.js"
     }
   },
   "files": [
-    "src"
+    "dist"
   ],
   "license": "MIT"
 }

package/packages/native/src/__tests__/diff.test.mjs

@@ -0,0 +1,189 @@
+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);
+}
+
+// ── normalizeForFuzzyMatch ──────────────────────────────────────────────
+
+describe("normalizeForFuzzyMatch", () => {
+  test("strips trailing whitespace per line", () => {
+    assert.equal(native.normalizeForFuzzyMatch("hello   \nworld  "), "hello\nworld");
+  });
+
+  test("normalizes smart quotes to ASCII", () => {
+    assert.equal(
+      native.normalizeForFuzzyMatch("\u201Chello\u201D \u2018world\u2019"),
+      '"hello" \'world\'',
+    );
+  });
+
+  test("normalizes dashes to ASCII hyphen", () => {
+    assert.equal(native.normalizeForFuzzyMatch("a\u2013b\u2014c"), "a-b-c");
+  });
+
+  test("normalizes special spaces to regular space", () => {
+    assert.equal(native.normalizeForFuzzyMatch("a\u00A0b\u3000c"), "a b c");
+  });
+
+  test("handles empty string", () => {
+    assert.equal(native.normalizeForFuzzyMatch(""), "");
+  });
+
+  test("preserves leading whitespace", () => {
+    assert.equal(native.normalizeForFuzzyMatch("  hello  "), "  hello");
+  });
+});
+
+// ── fuzzyFindText ───────────────────────────────────────────────────────
+
+describe("fuzzyFindText", () => {
+  test("finds exact match", () => {
+    const result = native.fuzzyFindText("hello world", "world");
+    assert.equal(result.found, true);
+    assert.equal(result.index, 6);
+    assert.equal(result.matchLength, 5);
+    assert.equal(result.usedFuzzyMatch, false);
+    assert.equal(result.contentForReplacement, "hello world");
+  });
+
+  test("finds fuzzy match with smart quotes", () => {
+    const content = 'let x = \u201Chello\u201D;';
+    const oldText = 'let x = "hello";';
+    const result = native.fuzzyFindText(content, oldText);
+    assert.equal(result.found, true);
+    assert.equal(result.usedFuzzyMatch, true);
+  });
+
+  test("returns not found for missing text", () => {
+    const result = native.fuzzyFindText("hello world", "xyz");
+    assert.equal(result.found, false);
+    assert.equal(result.index, -1);
+    assert.equal(result.matchLength, 0);
+  });
+
+  test("returns correct UTF-16 index for non-ASCII content", () => {
+    // Emoji U+1F600 is 2 UTF-16 code units (surrogate pair), 4 UTF-8 bytes
+    const content = "\u{1F600}hello";
+    const result = native.fuzzyFindText(content, "hello");
+    assert.equal(result.found, true);
+    // Emoji is 2 UTF-16 code units, so "hello" starts at index 2
+    assert.equal(result.index, 2);
+    assert.equal(result.matchLength, 5);
+  });
+
+  test("index is compatible with JS substring()", () => {
+    const content = "abc\u{1F600}def";
+    const result = native.fuzzyFindText(content, "def");
+    assert.equal(result.found, true);
+    // "abc" = 3, emoji = 2 UTF-16 code units → index 5
+    assert.equal(result.index, 5);
+    // Verify substring works correctly with the returned index
+    const extracted = result.contentForReplacement.substring(
+      result.index,
+      result.index + result.matchLength,
+    );
+    assert.equal(extracted, "def");
+  });
+
+  test("fuzzy match with trailing whitespace differences", () => {
+    const content = "hello   \nworld  ";
+    const oldText = "hello\nworld";
+    const result = native.fuzzyFindText(content, oldText);
+    assert.equal(result.found, true);
+    assert.equal(result.usedFuzzyMatch, true);
+  });
+});
+
+// ── generateDiff ────────────────────────────────────────────────────────
+
+describe("generateDiff", () => {
+  test("generates diff for a line change", () => {
+    const old = "line1\nline2\nline3";
+    const newText = "line1\nmodified\nline3";
+    const result = native.generateDiff(old, newText);
+    assert.ok(result.diff.includes("line2"));
+    assert.ok(result.diff.includes("modified"));
+    assert.ok(result.diff.includes("-"));
+    assert.ok(result.diff.includes("+"));
+    assert.notEqual(result.firstChangedLine, null);
+  });
+
+  test("generates diff for an addition", () => {
+    const old = "line1\nline3";
+    const newText = "line1\nline2\nline3";
+    const result = native.generateDiff(old, newText);
+    assert.ok(result.diff.includes("+"));
+    assert.ok(result.diff.includes("line2"));
+  });
+
+  test("generates diff for a deletion", () => {
+    const old = "line1\nline2\nline3";
+    const newText = "line1\nline3";
+    const result = native.generateDiff(old, newText);
+    assert.ok(result.diff.includes("-"));
+    assert.ok(result.diff.includes("line2"));
+  });
+
+  test("returns empty diff for identical content", () => {
+    const result = native.generateDiff("same", "same");
+    assert.equal(result.diff, "");
+    // napi-rs maps Option::None to undefined (not null)
+    assert.equal(result.firstChangedLine, undefined);
+  });
+
+  test("respects context lines parameter", () => {
+    const lines = Array.from({ length: 20 }, (_, i) => `line${i + 1}`);
+    const old = lines.join("\n");
+    lines[10] = "modified";
+    const newText = lines.join("\n");
+    const result = native.generateDiff(old, newText, 2);
+    assert.ok(result.diff.includes("..."));
+  });
+
+  test("default context is 4 lines", () => {
+    const lines = Array.from({ length: 20 }, (_, i) => `line${i + 1}`);
+    const old = lines.join("\n");
+    lines[10] = "modified";
+    const newText = lines.join("\n");
+    const result = native.generateDiff(old, newText);
+    // Should show 4 context lines before and after
+    assert.ok(result.diff.length > 0);
+  });
+});

package/packages/native/src/__tests__/ttsr.test.mjs

@@ -0,0 +1,135 @@
+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);
+}
+
+describe("native ttsr: ttsrCompileRules()", () => {
+  test("compiles rules and returns a numeric handle", () => {
+    const handle = native.ttsrCompileRules([
+      { name: "rule1", conditions: ["foo", "bar"] },
+    ]);
+    assert.equal(typeof handle, "number");
+    assert.ok(handle > 0);
+    native.ttsrFreeRules(handle);
+  });
+
+  test("rejects empty conditions", () => {
+    assert.throws(() => {
+      native.ttsrCompileRules([]);
+    });
+  });
+
+  test("rejects invalid regex patterns", () => {
+    assert.throws(() => {
+      native.ttsrCompileRules([
+        { name: "bad", conditions: ["(unclosed"] },
+      ]);
+    });
+  });
+});
+
+describe("native ttsr: ttsrCheckBuffer()", () => {
+  test("returns matching rule names", () => {
+    const handle = native.ttsrCompileRules([
+      { name: "greet", conditions: ["hello\\s+world"] },
+      { name: "farewell", conditions: ["goodbye"] },
+    ]);
+
+    const matches = native.ttsrCheckBuffer(handle, "say hello world please");
+    assert.deepEqual(matches, ["greet"]);
+
+    native.ttsrFreeRules(handle);
+  });
+
+  test("returns multiple matching rules", () => {
+    const handle = native.ttsrCompileRules([
+      { name: "a", conditions: ["alpha"] },
+      { name: "b", conditions: ["beta"] },
+      { name: "c", conditions: ["gamma"] },
+    ]);
+
+    const matches = native.ttsrCheckBuffer(handle, "alpha and beta together");
+    assert.ok(matches.includes("a"));
+    assert.ok(matches.includes("b"));
+    assert.ok(!matches.includes("c"));
+
+    native.ttsrFreeRules(handle);
+  });
+
+  test("returns empty array on no match", () => {
+    const handle = native.ttsrCompileRules([
+      { name: "x", conditions: ["zzz_no_match"] },
+    ]);
+
+    const matches = native.ttsrCheckBuffer(handle, "nothing here");
+    assert.deepEqual(matches, []);
+
+    native.ttsrFreeRules(handle);
+  });
+
+  test("deduplicates when multiple conditions of same rule match", () => {
+    const handle = native.ttsrCompileRules([
+      { name: "multi", conditions: ["foo", "bar"] },
+    ]);
+
+    const matches = native.ttsrCheckBuffer(handle, "foo and bar");
+    assert.deepEqual(matches, ["multi"]);
+
+    native.ttsrFreeRules(handle);
+  });
+
+  test("handles large buffers efficiently", () => {
+    const handle = native.ttsrCompileRules([
+      { name: "needle", conditions: ["NEEDLE_PATTERN_XYZ"] },
+    ]);
+
+    // 1MB buffer with the needle near the end
+    const bigBuffer = "x".repeat(1024 * 1024) + "NEEDLE_PATTERN_XYZ";
+    const matches = native.ttsrCheckBuffer(handle, bigBuffer);
+    assert.deepEqual(matches, ["needle"]);
+
+    native.ttsrFreeRules(handle);
+  });
+});
+
+describe("native ttsr: ttsrFreeRules()", () => {
+  test("frees handle without error", () => {
+    const handle = native.ttsrCompileRules([
+      { name: "temp", conditions: ["tmp"] },
+    ]);
+    native.ttsrFreeRules(handle);
+  });
+
+  test("rejects invalid handle on check", () => {
+    assert.throws(() => {
+      native.ttsrCheckBuffer(99999, "test");
+    });
+  });
+});

package/packages/native/src/diff/index.ts

@@ -0,0 +1,61 @@
+/**
+ * Native fuzzy text matching and diff generation for the edit tool.
+ *
+ * Uses the `similar` Rust crate (Myers' algorithm) for O(n+d) diffing,
+ * and single-pass Unicode normalization for fuzzy matching.
+ */
+
+import { native } from "../native.js";
+import type { DiffResult, FuzzyMatchResult } from "./types.js";
+
+export type { DiffResult, FuzzyMatchResult };
+
+/**
+ * Normalize text for fuzzy matching:
+ * - Strip trailing whitespace from each line
+ * - Smart quotes to ASCII equivalents
+ * - Unicode dashes/hyphens to ASCII hyphen
+ * - Special Unicode spaces to regular space
+ */
+export function normalizeForFuzzyMatch(text: string): string {
+  return (native as Record<string, Function>).normalizeForFuzzyMatch(
+    text,
+  ) as string;
+}
+
+/**
+ * Find `oldText` in `content`, trying exact match first, then fuzzy match.
+ *
+ * When fuzzy matching is used, `contentForReplacement` is the normalized
+ * version of `content`.
+ */
+export function fuzzyFindText(
+  content: string,
+  oldText: string,
+): FuzzyMatchResult {
+  return (native as Record<string, Function>).fuzzyFindText(
+    content,
+    oldText,
+  ) as FuzzyMatchResult;
+}
+
+/**
+ * Generate a unified diff string with line numbers and context.
+ *
+ * Uses Myers' diff algorithm via the `similar` Rust crate.
+ *
+ * @param oldContent  Original text
+ * @param newContent  Modified text
+ * @param contextLines  Number of context lines around changes (default: 4)
+ */
+export function generateDiff(
+  oldContent: string,
+  newContent: string,
+  contextLines?: number,
+): DiffResult {
+  return (native as Record<string, Function>).generateDiff(
+    oldContent,
+    newContent,
+    contextLines,
+  ) as DiffResult;
+}

package/packages/native/src/diff/types.ts

@@ -0,0 +1,24 @@
+/** Result of fuzzy text matching (exact match tried first, then normalized). */
+export interface FuzzyMatchResult {
+  /** Whether a match was found. */
+  found: boolean;
+  /** UTF-16 code unit index where the match starts (-1 if not found). */
+  index: number;
+  /** Length of the matched text in UTF-16 code units (0 if not found). */
+  matchLength: number;
+  /** Whether fuzzy (normalized) matching was used instead of exact. */
+  usedFuzzyMatch: boolean;
+  /**
+   * Content to use for replacement operations.
+   * Original content when exact match; normalized content when fuzzy match.
+   */
+  contentForReplacement: string;
+}
+
+/** Result of unified diff generation. */
+export interface DiffResult {
+  /** The unified diff string with line numbers. */
+  diff: string;
+  /** Line number of the first change in the new file (undefined if no changes). */
+  firstChangedLine: number | undefined;
+}

package/packages/native/src/gsd-parser/index.ts

@@ -0,0 +1,98 @@
+/**
+ * GSD file parser — native Rust implementation.
+ *
+ * Parses `.gsd/` directory markdown files containing YAML-like frontmatter
+ * and structured sections. Replaces the JS regex-based parser for
+ * performance-critical batch operations.
+ */
+
+import { native } from "../native.js";
+import type {
+  BatchParseResult,
+  FrontmatterResult,
+  NativeRoadmap,
+  SectionResult,
+} from "./types.js";
+
+export type {
+  BatchParseResult,
+  FrontmatterResult,
+  NativeBoundaryMapEntry,
+  NativeRoadmap,
+  NativeRoadmapSlice,
+  ParsedGsdFile,
+  SectionResult,
+} from "./types.js";
+
+/**
+ * Parse YAML-like frontmatter from markdown content.
+ *
+ * Returns `{ metadata, body }` where `metadata` is a JSON string
+ * of the parsed frontmatter key-value pairs. Parse it with `JSON.parse()`.
+ */
+export function parseFrontmatter(content: string): FrontmatterResult {
+  return (native as Record<string, Function>).parseFrontmatter(
+    content,
+  ) as FrontmatterResult;
+}
+
+/**
+ * Extract a section from markdown content by heading name.
+ *
+ * @param content  Markdown content to search.
+ * @param heading  Heading text to match (without the `#` prefix).
+ * @param level    Heading level (default 2 for `##`).
+ */
+export function extractSection(
+  content: string,
+  heading: string,
+  level?: number,
+): SectionResult {
+  return (native as Record<string, Function>).extractSection(
+    content,
+    heading,
+    level,
+  ) as SectionResult;
+}
+
+/**
+ * Extract all sections at a given heading level.
+ *
+ * Returns a JSON string mapping heading names to their content.
+ * Parse with `JSON.parse()`.
+ */
+export function extractAllSections(
+  content: string,
+  level?: number,
+): string {
+  return (native as Record<string, Function>).extractAllSections(
+    content,
+    level,
+  ) as string;
+}
+
+/**
+ * Batch-parse all `.md` files in a `.gsd/` directory tree.
+ *
+ * Reads and parses all markdown files under the given directory.
+ * Each file gets frontmatter parsing and section extraction.
+ */
+export function batchParseGsdFiles(
+  directory: string,
+): BatchParseResult {
+  return (native as Record<string, Function>).batchParseGsdFiles(
+    directory,
+  ) as BatchParseResult;
+}
+
+/**
+ * Parse a roadmap file's content into structured data.
+ *
+ * Extracts title, vision, success criteria, slices (with risk/depends),
+ * and boundary map entries.
+ */
+export function parseRoadmapFile(content: string): NativeRoadmap {
+  return (native as Record<string, Function>).parseRoadmapFile(
+    content,
+  ) as NativeRoadmap;
+}