gsd-pi 2.8.3 → 2.10.0

package/README.md

@@ -330,7 +330,7 @@ budget_ceiling: 50.00
 
 ### Bundled Tools
 
-GSD ships with 13 extensions, all loaded automatically:
+GSD ships with 14 extensions, all loaded automatically:
 
 | Extension | What it provides |
 |-----------|-----------------|
@@ -345,6 +345,7 @@ GSD ships with 13 extensions, all loaded automatically:
 | **MCPorter** | Lazy on-demand MCP server integration |
 | **Voice** | Real-time speech-to-text transcription (macOS) |
 | **Slash Commands** | Custom command creation |
+| **LSP** | Language Server Protocol integration — diagnostics, go-to-definition, references, hover, symbols, rename, code actions |
 | **Ask User Questions** | Structured user input with single/multi-select |
 | **Secure Env Collect** | Masked secret collection without manual .env editing |
 

package/dist/cli.js

@@ -7,6 +7,7 @@ import { ensureManagedTools } from './tool-bootstrap.js';
 import { loadStoredEnvKeys } from './wizard.js';
 import { getPiDefaultModelAndProvider, migratePiCredentials } from './pi-migration.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
+import { checkForUpdates } from './update-check.js';
 function parseCliArgs(argv) {
     const flags = { extensions: [], messages: [] };
     const args = argv.slice(2); // skip node + script
@@ -84,6 +85,10 @@ migratePiCredentials(authStorage);
 if (!isPrintMode && shouldRunOnboarding(authStorage)) {
     await runOnboarding(authStorage);
 }
+// Non-blocking update check — runs at most once per 24h, fire-and-forget
+if (!isPrintMode) {
+    checkForUpdates().catch(() => { });
+}
 const modelRegistry = new ModelRegistry(authStorage);
 const settingsManager = SettingsManager.create(agentDir);
 // Validate configured model on startup — catches stale settings from prior installs

package/dist/loader.js

@@ -13,7 +13,7 @@ const pkgDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'pkg');
 // MUST be set before any dynamic import of pi SDK fires — this is what config.js
 // reads to determine APP_NAME and CONFIG_DIR_NAME
 process.env.PI_PACKAGE_DIR = pkgDir;
-process.env.PI_SKIP_VERSION_CHECK = '1'; // GSD ships its own update check — suppress pi's
+process.env.PI_SKIP_VERSION_CHECK = '1'; // GSD runs its own update check in cli.ts — suppress pi's
 process.title = 'gsd';
 // Print branded banner on first launch (before ~/.gsd/ exists)
 if (!existsSync(appRoot)) {

package/dist/update-check.d.ts

@@ -0,0 +1,24 @@
+interface UpdateCheckCache {
+    lastCheck: number;
+    latestVersion: string;
+}
+/**
+ * Compares two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal.
+ */
+export declare function compareSemver(a: string, b: string): number;
+export declare function readUpdateCache(cachePath?: string): UpdateCheckCache | null;
+export declare function writeUpdateCache(cache: UpdateCheckCache, cachePath?: string): void;
+export interface UpdateCheckOptions {
+    currentVersion?: string;
+    cachePath?: string;
+    registryUrl?: string;
+    checkIntervalMs?: number;
+    fetchTimeoutMs?: number;
+    onUpdate?: (current: string, latest: string) => void;
+}
+/**
+ * Non-blocking update check. Queries npm registry at most once per 24h,
+ * caches the result, and prints a banner if a newer version is available.
+ */
+export declare function checkForUpdates(options?: UpdateCheckOptions): Promise<void>;
+export {};

package/dist/update-check.js

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { appRoot } from './app-paths.js';
+const CACHE_FILE = join(appRoot, '.update-check');
+const NPM_PACKAGE_NAME = 'gsd-pi';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const FETCH_TIMEOUT_MS = 5000;
+/**
+ * Compares two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal.
+ */
+export function compareSemver(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const va = pa[i] || 0;
+        const vb = pb[i] || 0;
+        if (va > vb)
+            return 1;
+        if (va < vb)
+            return -1;
+    }
+    return 0;
+}
+export function readUpdateCache(cachePath = CACHE_FILE) {
+    try {
+        if (!existsSync(cachePath))
+            return null;
+        return JSON.parse(readFileSync(cachePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeUpdateCache(cache, cachePath = CACHE_FILE) {
+    try {
+        mkdirSync(dirname(cachePath), { recursive: true });
+        writeFileSync(cachePath, JSON.stringify(cache));
+    }
+    catch {
+        // Non-fatal — don't block startup if cache write fails
+    }
+}
+function printUpdateBanner(current, latest) {
+    const yellow = '\x1b[33m';
+    const dim = '\x1b[2m';
+    const reset = '\x1b[0m';
+    const bold = '\x1b[1m';
+    process.stderr.write(`  ${yellow}Update available:${reset} ${dim}v${current}${reset} → ${bold}v${latest}${reset}\n` +
+        `  ${dim}Run${reset} npm update -g gsd-pi ${dim}or${reset} /gsd:update ${dim}to upgrade${reset}\n\n`);
+}
+/**
+ * Non-blocking update check. Queries npm registry at most once per 24h,
+ * caches the result, and prints a banner if a newer version is available.
+ */
+export async function checkForUpdates(options = {}) {
+    const currentVersion = options.currentVersion || process.env.GSD_VERSION || '0.0.0';
+    const cachePath = options.cachePath || CACHE_FILE;
+    const registryUrl = options.registryUrl || `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+    const checkIntervalMs = options.checkIntervalMs ?? CHECK_INTERVAL_MS;
+    const fetchTimeoutMs = options.fetchTimeoutMs ?? FETCH_TIMEOUT_MS;
+    const onUpdate = options.onUpdate || printUpdateBanner;
+    // Check cache — skip network if checked recently
+    const cache = readUpdateCache(cachePath);
+    if (cache && Date.now() - cache.lastCheck < checkIntervalMs) {
+        if (compareSemver(cache.latestVersion, currentVersion) > 0) {
+            onUpdate(currentVersion, cache.latestVersion);
+        }
+        return;
+    }
+    // Fetch latest version from npm registry
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), fetchTimeoutMs);
+    try {
+        const res = await fetch(registryUrl, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!res.ok)
+            return;
+        const data = (await res.json());
+        const latestVersion = data.version;
+        if (!latestVersion)
+            return;
+        writeUpdateCache({ lastCheck: Date.now(), latestVersion }, cachePath);
+        if (compareSemver(latestVersion, currentVersion) > 0) {
+            onUpdate(currentVersion, latestVersion);
+        }
+    }
+    catch {
+        // Network error or timeout — silently ignore, don't block startup
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

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