gsd-pi 2.9.0 → 2.10.0

package/node_modules/@gsd/native/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@gsd/native",
+  "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",
+  "scripts": {
+    "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"
+    },
+    "./grep": {
+      "types": "./src/grep/index.ts",
+      "import": "./src/grep/index.ts"
+    },
+    "./ps": {
+      "types": "./src/ps/index.ts",
+      "import": "./src/ps/index.ts"
+    },
+    "./glob": {
+      "types": "./src/glob/index.ts",
+      "import": "./src/glob/index.ts"
+    },
+    "./clipboard": {
+      "types": "./src/clipboard/index.ts",
+      "import": "./src/clipboard/index.ts"
+    },
+    "./ast": {
+      "types": "./src/ast/index.ts",
+      "import": "./src/ast/index.ts"
+    },
+    "./html": {
+      "types": "./src/html/index.ts",
+      "import": "./src/html/index.ts"
+    },
+    "./text": {
+      "types": "./src/text/index.ts",
+      "import": "./src/text/index.ts"
+    },
+    "./fd": {
+      "types": "./src/fd/index.ts",
+      "import": "./src/fd/index.ts"
+    },
+    "./image": {
+      "types": "./src/image/index.ts",
+      "import": "./src/image/index.ts"
+    }
+  },
+  "files": [
+    "src"
+  ],
+  "license": "MIT"
+}

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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,164 @@
+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})`,
+      );
+    }
+  });
+});

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

@@ -0,0 +1,237 @@
+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 glob: glob()", () => {
+  test("finds files matching a pattern", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.writeFileSync(path.join(tmpDir, "file1.ts"), "const a = 1;");
+    fs.writeFileSync(path.join(tmpDir, "file2.ts"), "const b = 2;");
+    fs.writeFileSync(path.join(tmpDir, "file3.js"), "const c = 3;");
+
+    const result = await native.glob({ pattern: "*.ts", path: tmpDir });
+
+    assert.equal(result.totalMatches, 2);
+    assert.equal(result.matches.length, 2);
+    const paths = result.matches.map((m) => m.path).sort();
+    assert.deepEqual(paths, ["file1.ts", "file2.ts"]);
+  });
+
+  test("recursive matching into subdirectories", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.mkdirSync(path.join(tmpDir, "src"));
+    fs.mkdirSync(path.join(tmpDir, "src", "nested"));
+    fs.writeFileSync(path.join(tmpDir, "root.ts"), "");
+    fs.writeFileSync(path.join(tmpDir, "src", "a.ts"), "");
+    fs.writeFileSync(path.join(tmpDir, "src", "nested", "b.ts"), "");
+
+    const result = await native.glob({ pattern: "*.ts", path: tmpDir });
+
+    assert.equal(result.totalMatches, 3);
+    const paths = result.matches.map((m) => m.path).sort();
+    assert.ok(paths.includes("root.ts"));
+    assert.ok(paths.includes("src/a.ts"));
+    assert.ok(paths.includes("src/nested/b.ts"));
+  });
+
+  test("respects maxResults limit", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-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`), "");
+    }
+
+    const result = await native.glob({
+      pattern: "*.txt",
+      path: tmpDir,
+      maxResults: 3,
+    });
+
+    assert.equal(result.matches.length, 3);
+    assert.equal(result.totalMatches, 3);
+  });
+
+  test("filters by file type (directories only)", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.mkdirSync(path.join(tmpDir, "dir1"));
+    fs.mkdirSync(path.join(tmpDir, "dir2"));
+    fs.writeFileSync(path.join(tmpDir, "file.txt"), "");
+
+    const result = await native.glob({
+      pattern: "*",
+      path: tmpDir,
+      recursive: false,
+      fileType: 2, // Dir
+    });
+
+    assert.equal(result.totalMatches, 2);
+    const paths = result.matches.map((m) => m.path).sort();
+    assert.deepEqual(paths, ["dir1", "dir2"]);
+  });
+
+  test("respects .gitignore", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    // Init a git repo so .gitignore is respected
+    fs.mkdirSync(path.join(tmpDir, ".git"));
+    fs.writeFileSync(path.join(tmpDir, ".gitignore"), "ignored.txt\n");
+    fs.writeFileSync(path.join(tmpDir, "kept.txt"), "");
+    fs.writeFileSync(path.join(tmpDir, "ignored.txt"), "");
+
+    const result = await native.glob({
+      pattern: "*.txt",
+      path: tmpDir,
+      gitignore: true,
+    });
+
+    assert.equal(result.totalMatches, 1);
+    assert.equal(result.matches[0].path, "kept.txt");
+  });
+
+  test("includes gitignored files when gitignore=false", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.mkdirSync(path.join(tmpDir, ".git"));
+    fs.writeFileSync(path.join(tmpDir, ".gitignore"), "ignored.txt\n");
+    fs.writeFileSync(path.join(tmpDir, "kept.txt"), "");
+    fs.writeFileSync(path.join(tmpDir, "ignored.txt"), "");
+
+    const result = await native.glob({
+      pattern: "*.txt",
+      path: tmpDir,
+      gitignore: false,
+    });
+
+    assert.equal(result.totalMatches, 2);
+  });
+
+  test("skips node_modules by default", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.mkdirSync(path.join(tmpDir, "node_modules"));
+    fs.writeFileSync(path.join(tmpDir, "node_modules", "dep.js"), "");
+    fs.writeFileSync(path.join(tmpDir, "app.js"), "");
+
+    const result = await native.glob({
+      pattern: "*.js",
+      path: tmpDir,
+      gitignore: false,
+    });
+
+    assert.equal(result.totalMatches, 1);
+    assert.equal(result.matches[0].path, "app.js");
+  });
+
+  test("sortByMtime returns most recent first", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.writeFileSync(path.join(tmpDir, "old.txt"), "old");
+    // Ensure different mtime
+    const now = new Date();
+    fs.utimesSync(
+      path.join(tmpDir, "old.txt"),
+      new Date(now.getTime() - 5000),
+      new Date(now.getTime() - 5000),
+    );
+    fs.writeFileSync(path.join(tmpDir, "new.txt"), "new");
+
+    const result = await native.glob({
+      pattern: "*.txt",
+      path: tmpDir,
+      sortByMtime: true,
+    });
+
+    assert.equal(result.totalMatches, 2);
+    assert.equal(result.matches[0].path, "new.txt");
+    assert.equal(result.matches[1].path, "old.txt");
+  });
+
+  test("errors on non-existent path", async () => {
+    await assert.rejects(
+      () =>
+        native.glob({
+          pattern: "*.txt",
+          path: "/nonexistent/path/that/does/not/exist",
+        }),
+      /Path not found/,
+    );
+  });
+
+  test("returns mtime for each entry", async (t) => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-glob-test-"));
+    t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+    fs.writeFileSync(path.join(tmpDir, "test.txt"), "content");
+
+    const result = await native.glob({ pattern: "*.txt", path: tmpDir });
+
+    assert.equal(result.matches.length, 1);
+    assert.ok(typeof result.matches[0].mtime === "number");
+    // mtime should be within the last minute
+    const oneMinuteAgo = Date.now() - 60_000;
+    assert.ok(result.matches[0].mtime > oneMinuteAgo);
+  });
+});
+
+describe("native glob: invalidateFsScanCache()", () => {
+  test("can be called with a path", () => {
+    // Should not throw
+    native.invalidateFsScanCache("/tmp");
+  });
+
+  test("can be called without arguments", () => {
+    // Should not throw
+    native.invalidateFsScanCache();
+  });
+});