gsd-pi 2.10.0 → 2.10.2

package/src/resources/extensions/gsd/files.ts

@@ -19,6 +19,7 @@ import type {
 
 import { checkExistingEnvKeys } from '../get-secrets-from-user.ts';
 import { parseRoadmapSlices } from './roadmap-slices.ts';
+import { nativeParseRoadmap, nativeExtractSection, NATIVE_UNAVAILABLE } from './native-parser-bridge.ts';
 
 // ─── Helpers ───────────────────────────────────────────────────────────────
 
@@ -130,6 +131,10 @@ export function parseFrontmatterMap(lines: string[]): Record<string, unknown> {
 
 /** Extract the text after a heading at a given level, up to the next heading of same or higher level. */
 export function extractSection(body: string, heading: string, level: number = 2): string | null {
+  // Try native parser first for better performance on large files
+  const nativeResult = nativeExtractSection(body, heading, level);
+  if (nativeResult !== NATIVE_UNAVAILABLE) return nativeResult as string | null;
+
   const prefix = '#'.repeat(level) + ' ';
   const regex = new RegExp(`^${prefix}${escapeRegex(heading)}\\s*$`, 'm');
   const match = regex.exec(body);
@@ -182,6 +187,10 @@ export function extractBoldField(text: string, key: string): string | null {
 // ─── Roadmap Parser ────────────────────────────────────────────────────────
 
 export function parseRoadmap(content: string): Roadmap {
+  // Try native parser first for better performance
+  const nativeResult = nativeParseRoadmap(content);
+  if (nativeResult) return nativeResult;
+
   const lines = content.split('\n');
 
   const h1 = lines.find(l => l.startsWith('# '));

package/src/resources/extensions/gsd/native-parser-bridge.ts

@@ -0,0 +1,135 @@
+// Native GSD Parser Bridge
+// Provides drop-in replacements for the JS parsing functions in files.ts,
+// backed by the Rust native parser for better performance on large projects.
+//
+// Functions fall back to JS implementations if the native module is unavailable.
+
+import type { Roadmap, BoundaryMapEntry, RoadmapSliceEntry, RiskLevel } from './types.ts';
+
+let nativeModule: {
+  parseFrontmatter: (content: string) => { metadata: string; body: string };
+  extractSection: (content: string, heading: string, level?: number) => { content: string; found: boolean };
+  extractAllSections: (content: string, level?: number) => string;
+  batchParseGsdFiles: (directory: string) => { files: Array<{ path: string; metadata: string; body: string; sections: string }>; count: number };
+  parseRoadmapFile: (content: string) => {
+    title: string;
+    vision: string;
+    successCriteria: string[];
+    slices: Array<{ id: string; title: string; risk: string; depends: string[]; done: boolean; demo: string }>;
+    boundaryMap: Array<{ fromSlice: string; toSlice: string; produces: string; consumes: string }>;
+  };
+} | null = null;
+
+let loadAttempted = false;
+
+function loadNative(): typeof nativeModule {
+  if (loadAttempted) return nativeModule;
+  loadAttempted = true;
+
+  try {
+    // Dynamic import to avoid hard dependency - fails gracefully if native module not built
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const mod = require('@gsd/native');
+    if (mod.parseFrontmatter && mod.extractSection && mod.batchParseGsdFiles) {
+      nativeModule = mod;
+    }
+  } catch {
+    // Native module not available - all functions fall back to JS
+  }
+
+  return nativeModule;
+}
+
+/**
+ * Native-backed frontmatter splitting.
+ * Returns [parsedMetadata, body] where parsedMetadata is the parsed key-value map.
+ */
+export function nativeSplitFrontmatter(content: string): { metadata: Record<string, unknown>; body: string } | null {
+  const native = loadNative();
+  if (!native) return null;
+
+  const result = native.parseFrontmatter(content);
+  return {
+    metadata: JSON.parse(result.metadata) as Record<string, unknown>,
+    body: result.body,
+  };
+}
+
+/** Sentinel value indicating the native module is not available. */
+const NATIVE_UNAVAILABLE = Symbol('native-unavailable');
+
+/**
+ * Native-backed section extraction.
+ * Returns section content, null if not found, or NATIVE_UNAVAILABLE symbol
+ * if the native module isn't loaded.
+ */
+export function nativeExtractSection(content: string, heading: string, level: number = 2): string | null | typeof NATIVE_UNAVAILABLE {
+  const native = loadNative();
+  if (!native) return NATIVE_UNAVAILABLE;
+
+  const result = native.extractSection(content, heading, level);
+  return result.found ? result.content : null;
+}
+
+export { NATIVE_UNAVAILABLE };
+
+/**
+ * Native-backed roadmap parsing.
+ * Returns a Roadmap object or null if native module unavailable.
+ */
+export function nativeParseRoadmap(content: string): Roadmap | null {
+  const native = loadNative();
+  if (!native) return null;
+
+  const result = native.parseRoadmapFile(content);
+  return {
+    title: result.title,
+    vision: result.vision,
+    successCriteria: result.successCriteria,
+    slices: result.slices.map(s => ({
+      id: s.id,
+      title: s.title,
+      risk: s.risk as RiskLevel,
+      depends: s.depends,
+      done: s.done,
+      demo: s.demo,
+    })),
+    boundaryMap: result.boundaryMap.map(b => ({
+      fromSlice: b.fromSlice,
+      toSlice: b.toSlice,
+      produces: b.produces,
+      consumes: b.consumes,
+    })),
+  };
+}
+
+export interface BatchParsedFile {
+  path: string;
+  metadata: Record<string, unknown>;
+  body: string;
+  sections: Record<string, string>;
+}
+
+/**
+ * Batch-parse all .md files in a .gsd/ directory tree using the native parser.
+ * Returns null if native module unavailable.
+ */
+export function nativeBatchParseGsdFiles(directory: string): BatchParsedFile[] | null {
+  const native = loadNative();
+  if (!native) return null;
+
+  const result = native.batchParseGsdFiles(directory);
+  return result.files.map(f => ({
+    path: f.path,
+    metadata: JSON.parse(f.metadata) as Record<string, unknown>,
+    body: f.body,
+    sections: JSON.parse(f.sections) as Record<string, string>,
+  }));
+}
+
+/**
+ * Check if the native parser is available.
+ */
+export function isNativeParserAvailable(): boolean {
+  return loadNative() !== null;
+}

package/src/resources/extensions/ttsr/ttsr-manager.ts

@@ -4,9 +4,34 @@
  * Manages rules that get injected mid-stream when their condition pattern matches
  * the agent's output. When a match occurs, the stream is aborted, the rule is
  * injected as a system reminder, and the request is retried.
+ *
+ * The regex hot-path is delegated to a native Rust RegexSet engine when
+ * available, testing all patterns in a single DFA pass. Falls back to
+ * per-rule JS RegExp iteration when the native module is not loaded.
  */
 import picomatch from "picomatch";
 
+// ── Native TTSR engine (optional) ─────────────────────────────────────
+let nativeTtsr: {
+	ttsrCompileRules: (rules: { name: string; conditions: string[] }[]) => number;
+	ttsrCheckBuffer: (handle: number, buffer: string) => string[];
+	ttsrFreeRules: (handle: number) => void;
+} | null = null;
+
+try {
+	// Dynamic import to avoid hard dependency — gracefully degrades to JS.
+	const native = await import("@gsd/native");
+	if (native.ttsrCompileRules && native.ttsrCheckBuffer && native.ttsrFreeRules) {
+		nativeTtsr = {
+			ttsrCompileRules: native.ttsrCompileRules,
+			ttsrCheckBuffer: native.ttsrCheckBuffer,
+			ttsrFreeRules: native.ttsrFreeRules,
+		};
+	}
+} catch {
+	// Native module not available — JS fallback will be used.
+}
+
 export type TtsrMatchSource = "text" | "thinking" | "tool";
 
 /** Context about the stream content currently being checked against TTSR rules. */
@@ -86,6 +111,8 @@ export class TtsrManager {
 	readonly #injectionRecords = new Map<string, InjectionRecord>();
 	readonly #buffers = new Map<string, string>();
 	#messageCount = 0;
+	#nativeHandle: number | null = null;
+	#nativeDirty = false;
 
 	constructor(settings?: TtsrSettings) {
 		this.#settings = { ...DEFAULT_SETTINGS, ...settings };
@@ -245,6 +272,40 @@ export class TtsrManager {
 		return false;
 	}
 
+	/** Compile (or recompile) the native RegexSet from all current rules. */
+	#compileNative(): void {
+		if (!nativeTtsr || !this.#nativeDirty) return;
+
+		// Free previous handle if any.
+		if (this.#nativeHandle !== null) {
+			try {
+				nativeTtsr.ttsrFreeRules(this.#nativeHandle);
+			} catch { /* ignore */ }
+			this.#nativeHandle = null;
+		}
+
+		const ruleInputs: { name: string; conditions: string[] }[] = [];
+		for (const [, entry] of this.#rules) {
+			ruleInputs.push({
+				name: entry.rule.name,
+				conditions: entry.rule.condition,
+			});
+		}
+
+		if (ruleInputs.length === 0) {
+			this.#nativeDirty = false;
+			return;
+		}
+
+		try {
+			this.#nativeHandle = nativeTtsr.ttsrCompileRules(ruleInputs);
+		} catch (err) {
+			console.warn(`[ttsr] Native compilation failed, using JS fallback: ${(err as Error).message}`);
+			this.#nativeHandle = null;
+		}
+		this.#nativeDirty = false;
+	}
+
 	/** Add a TTSR rule to be monitored. */
 	addRule(rule: Rule): boolean {
 		if (this.#rules.has(rule.name)) return false;
@@ -257,6 +318,7 @@ export class TtsrManager {
 
 		const globalPathMatchers = this.#compileGlobalPathMatchers(rule.globs);
 		this.#rules.set(rule.name, { rule, conditions, scope, globalPathMatchers });
+		this.#nativeDirty = true;
 		return true;
 	}
 
@@ -265,6 +327,10 @@ export class TtsrManager {
 	 *
 	 * Buffers are isolated by source/tool key so matches don't bleed across
 	 * assistant prose, thinking text, and unrelated tool argument streams.
+	 *
+	 * When the native Rust engine is available, all regex conditions are tested
+	 * in a single DFA pass via RegexSet. Scope, glob, and repeat-gate checks
+	 * remain in JS as they are lightweight and context-dependent.
 	 */
 	checkDelta(delta: string, context: TtsrMatchContext): Rule[] {
 		const bufferKey = this.#bufferKey(context);
@@ -275,6 +341,26 @@ export class TtsrManager {
 		}
 		this.#buffers.set(bufferKey, nextBuffer);
 
+		// Lazily compile native engine if rules changed.
+		if (this.#nativeDirty) this.#compileNative();
+
+		// ── Native path: single-pass RegexSet match ───────────────────────
+		if (nativeTtsr && this.#nativeHandle !== null) {
+			const regexMatchedNames = nativeTtsr.ttsrCheckBuffer(this.#nativeHandle, nextBuffer);
+			const regexMatchedSet = new Set(regexMatchedNames);
+
+			const matches: Rule[] = [];
+			for (const [name, entry] of this.#rules) {
+				if (!regexMatchedSet.has(name)) continue;
+				if (!this.#canTrigger(name)) continue;
+				if (!this.#matchesScope(entry, context)) continue;
+				if (!this.#matchesGlobalPaths(entry, context)) continue;
+				matches.push(entry.rule);
+			}
+			return matches;
+		}
+
+		// ── JS fallback: per-rule regex iteration ─────────────────────────
 		const matches: Rule[] = [];
 		for (const [name, entry] of this.#rules) {
 			if (!this.#canTrigger(name)) continue;

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

@@ -1,79 +0,0 @@
-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);
-
-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 build:native first.");
-  process.exit(1);
-}
-
-describe("native clipboard: copyToClipboard()", () => {
-  test("copies text without throwing", () => {
-    assert.doesNotThrow(() => {
-      native.copyToClipboard("GSD clipboard test");
-    });
-  });
-
-  test("accepts empty string", () => {
-    assert.doesNotThrow(() => {
-      native.copyToClipboard("");
-    });
-  });
-
-  test("accepts unicode text", () => {
-    assert.doesNotThrow(() => {
-      native.copyToClipboard("Hello 世界");
-    });
-  });
-});
-
-describe("native clipboard: readTextFromClipboard()", () => {
-  test("reads back text that was copied", () => {
-    const testText = `GSD clipboard roundtrip ${Date.now()}`;
-    native.copyToClipboard(testText);
-    const result = native.readTextFromClipboard();
-    assert.equal(result, testText);
-  });
-
-  test("returns a string or null", () => {
-    const result = native.readTextFromClipboard();
-    assert.ok(result === null || typeof result === "string");
-  });
-});
-
-describe("native clipboard: readImageFromClipboard()", () => {
-  test("returns a promise", () => {
-    const result = native.readImageFromClipboard();
-    assert.ok(result instanceof Promise);
-  });
-
-  test("resolves to ClipboardImage or null", async () => {
-    const result = await native.readImageFromClipboard();
-    if (result !== null) {
-      assert.ok(result.data instanceof Uint8Array, "data should be Uint8Array");
-      assert.equal(result.mimeType, "image/png");
-    }
-  });
-});

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

@@ -1,164 +0,0 @@
-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 * as fs from "node:fs";
-import * as os from "node:os";
-
-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 fd: fuzzyFind()", () => {
-  test("finds files matching a query", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-fd-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "main.rs"), "fn main() {}");
-    fs.writeFileSync(path.join(tmpDir, "lib.rs"), "pub mod lib;");
-    fs.writeFileSync(path.join(tmpDir, "utils.ts"), "export {}");
-    fs.mkdirSync(path.join(tmpDir, "src"));
-    fs.writeFileSync(path.join(tmpDir, "src", "helper.rs"), "fn helper() {}");
-
-    const result = native.fuzzyFind({ query: "main", path: tmpDir });
-
-    assert.ok(result.matches.length > 0, "Should find at least one match");
-    assert.equal(result.matches[0].path, "main.rs");
-    assert.equal(result.matches[0].isDirectory, false);
-    assert.ok(result.matches[0].score > 0);
-  });
-
-  test("returns empty results for non-matching query", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-fd-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "hello.txt"), "hello");
-
-    const result = native.fuzzyFind({
-      query: "zzzznotexist",
-      path: tmpDir,
-    });
-
-    assert.equal(result.matches.length, 0);
-    assert.equal(result.totalMatches, 0);
-  });
-
-  test("respects maxResults limit", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-fd-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    for (let i = 0; i < 10; i++) {
-      fs.writeFileSync(path.join(tmpDir, `file${i}.txt`), "content");
-    }
-
-    const result = native.fuzzyFind({
-      query: "file",
-      path: tmpDir,
-      maxResults: 3,
-    });
-
-    assert.equal(result.matches.length, 3);
-    assert.ok(result.totalMatches >= 3);
-  });
-
-  test("directories have trailing slash and bonus score", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-fd-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.mkdirSync(path.join(tmpDir, "models"));
-    fs.writeFileSync(path.join(tmpDir, "models.ts"), "export {}");
-
-    const result = native.fuzzyFind({ query: "models", path: tmpDir });
-
-    const dirMatch = result.matches.find((m) => m.isDirectory);
-    const fileMatch = result.matches.find((m) => !m.isDirectory);
-
-    assert.ok(dirMatch, "Should find a directory match");
-    assert.ok(fileMatch, "Should find a file match");
-    assert.ok(dirMatch.path.endsWith("/"), "Directory should have trailing slash");
-    assert.ok(dirMatch.score > fileMatch.score, "Directory should score higher");
-  });
-
-  test("empty query returns all entries", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-fd-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "a.txt"), "a");
-    fs.writeFileSync(path.join(tmpDir, "b.txt"), "b");
-    fs.writeFileSync(path.join(tmpDir, "c.txt"), "c");
-
-    const result = native.fuzzyFind({ query: "", path: tmpDir });
-
-    assert.equal(result.matches.length, 3);
-  });
-
-  test("errors on non-existent path", () => {
-    assert.throws(
-      () => native.fuzzyFind({ query: "test", path: "/nonexistent/path" }),
-      { message: /Path not found/ },
-    );
-  });
-
-  test("fuzzy subsequence matching works", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-fd-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "MyComponentFile.tsx"), "export {}");
-    fs.writeFileSync(path.join(tmpDir, "other.txt"), "other");
-
-    // "mcf" should fuzzy-match "MyComponentFile" via subsequence
-    const result = native.fuzzyFind({ query: "mcf", path: tmpDir });
-
-    assert.ok(result.matches.length > 0, "Fuzzy subsequence should match");
-    assert.ok(
-      result.matches.some((m) => m.path.includes("MyComponentFile")),
-      "Should find MyComponentFile via fuzzy match",
-    );
-  });
-
-  test("results are sorted by score descending", (t) => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-fd-test-"));
-    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
-
-    fs.writeFileSync(path.join(tmpDir, "main.ts"), "");
-    fs.writeFileSync(path.join(tmpDir, "my_main.ts"), "");
-    fs.mkdirSync(path.join(tmpDir, "src"));
-    fs.writeFileSync(path.join(tmpDir, "src", "main.rs"), "");
-
-    const result = native.fuzzyFind({
-      query: "main",
-      path: tmpDir,
-      maxResults: 100,
-    });
-
-    for (let i = 1; i < result.matches.length; i++) {
-      assert.ok(
-        result.matches[i - 1].score >= result.matches[i].score,
-        `Match ${i - 1} (score ${result.matches[i - 1].score}) should be >= match ${i} (score ${result.matches[i].score})`,
-      );
-    }
-  });
-});