pi-ui-extend 0.1.6 → 0.1.9

package/external/pi-tools-suite/src/default-pi-tools-suite-config.ts

@@ -5,10 +5,10 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
   "disabledModules": [
     // "ast-grep",
     // "async-subagents",
-    // "terminal-bell",
     // "lsp",
     // "repo-discovery",
     // "antigravity-auth",
+    // "opencode-import",
     // "todo",
     // "model-tools",
     // "usage",
@@ -16,7 +16,7 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
     // "dcp"
   ],
 
-  // Terminal bell notification settings.
+  // Renderer bundled terminal-bell notification settings.
   "terminalBell": {
     // Toggle terminal-bell attention signals across supported OSes:
     // terminal BEL, macOS notification sound, and system notifications
@@ -359,6 +359,276 @@ export const DEFAULT_PI_TOOLS_SUITE_CONFIG_JSONC = `{
         "prompt": "Commit all changes"
       }
     }
+  },
+
+  // LSP language servers. TypeScript/JavaScript is enabled by default;
+  // uncomment additional server blocks after installing their binaries.
+  "lsp": {
+    "servers": [
+      {
+        "id": "typescript",
+        "include": [
+          "**/*.ts",
+          "**/*.tsx",
+          "**/*.js",
+          "**/*.jsx",
+          "**/*.mjs"
+        ],
+        "exclude": [
+          "**/node_modules/**",
+          "**/.next/**"
+        ],
+        "rootMarkers": [
+          "tsconfig.json",
+          "package.json"
+        ],
+        "bin": "typescript-language-server",
+        "args": [
+          "--stdio"
+        ],
+        "languageIdByExtension": {
+          ".ts": "typescript",
+          ".tsx": "typescriptreact",
+          ".js": "javascript",
+          ".jsx": "javascriptreact",
+          ".mjs": "javascript"
+        }
+      }
+      // ,
+      // {
+      //   "id": "python",
+      //   "include": [
+      //     "**/*.py",
+      //     "**/*.pyi"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/__pycache__/**",
+      //     "**/.venv/**",
+      //     "**/venv/**",
+      //     "**/.tox/**",
+      //     "**/.mypy_cache/**",
+      //     "**/.ruff_cache/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "pyproject.toml",
+      //     "setup.py",
+      //     "setup.cfg",
+      //     "requirements.txt",
+      //     "Pipfile",
+      //     "poetry.lock",
+      //     ".git"
+      //   ],
+      //   "bin": "pylsp",
+      //   "args": [],
+      //   "languageIdByExtension": {
+      //     ".py": "python",
+      //     ".pyi": "python"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "csharp",
+      //   "include": [
+      //     "**/*.cs",
+      //     "**/*.csx"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/bin/**",
+      //     "**/obj/**",
+      //     "**/.vs/**",
+      //     "**/Library/**",
+      //     "**/Temp/**",
+      //     "**/Logs/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "*.sln",
+      //     "*.csproj",
+      //     "global.json",
+      //     "Directory.Build.props",
+      //     "Directory.Packages.props",
+      //     "Packages/manifest.json",
+      //     "ProjectSettings/ProjectVersion.txt",
+      //     ".git"
+      //   ],
+      //   "bin": "~/.dotnet/tools/roslyn-language-server",
+      //   "args": [
+      //     "--stdio",
+      //     "--autoLoadProjects",
+      //     "--logLevel",
+      //     "Error"
+      //   ],
+      //   "startupTimeoutMs": 30000,
+      //   "diagnosticsWaitMs": 15000,
+      //   "languageIdByExtension": {
+      //     ".cs": "csharp",
+      //     ".csx": "csharp"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "gdscript",
+      //   "include": [
+      //     "**/*.gd",
+      //     "**/*.gdshader",
+      //     "**/*.gdshaderinc"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/.godot/**",
+      //     "**/imported/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "project.godot"
+      //   ],
+      //   "bin": "bash",
+      //   "args": [
+      //     "-lc",
+      //     "port=$(python3 -c 'import socket; s=socket.socket(); s.bind((\\"127.0.0.1\\", 0)); print(s.getsockname()[1]); s.close()'); log=\\"\${TMPDIR:-/tmp}/pi-godot-lsp-\${1##*/}-\${port}.log\\"; godot --headless --editor --path \\"$1\\" --lsp-port \\"$port\\" >\\"$log\\" 2>&1 & pid=$!; cleanup(){ kill \\"$pid\\" 2>/dev/null || true; wait \\"$pid\\" 2>/dev/null || true; }; trap 'cleanup; exit 143' TERM INT HUP; trap cleanup EXIT; for i in $(seq 1 80); do nc -z 127.0.0.1 \\"$port\\" 2>/dev/null && break; if ! kill -0 \\"$pid\\" 2>/dev/null; then cat \\"$log\\" >&2; exit 1; fi; sleep 0.25; done; if ! nc -z 127.0.0.1 \\"$port\\" 2>/dev/null; then echo \\"Godot LSP did not open 127.0.0.1:$port; see $log\\" >&2; exit 1; fi; nc 127.0.0.1 \\"$port\\"; status=$?; exit $status",
+      //     "pi-godot-lsp",
+      //     "{root}"
+      //   ],
+      //   "startupTimeoutMs": 30000,
+      //   "diagnosticsWaitMs": 6000,
+      //   "languageIdByExtension": {
+      //     ".gd": "gdscript",
+      //     ".gdshader": "gdshader",
+      //     ".gdshaderinc": "gdshader"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "ruby",
+      //   "include": [
+      //     "**/*.rb",
+      //     "**/*.rake",
+      //     "**/Gemfile",
+      //     "**/Rakefile",
+      //     "**/*.gemspec"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/vendor/bundle/**",
+      //     "**/.bundle/**",
+      //     "**/tmp/**",
+      //     "**/log/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "Gemfile.lock",
+      //     "*.gemspec",
+      //     "Rakefile",
+      //     ".ruby-version",
+      //     ".git"
+      //   ],
+      //   "bin": "ruby-lsp",
+      //   "args": [],
+      //   "startupTimeoutMs": 60000,
+      //   "diagnosticsWaitMs": 10000,
+      //   "languageIdByExtension": {
+      //     ".rb": "ruby",
+      //     ".rake": "ruby",
+      //     ".gemspec": "ruby"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "rust",
+      //   "include": [
+      //     "**/*.rs"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**",
+      //     "**/target/**"
+      //   ],
+      //   "rootMarkers": [
+      //     "Cargo.toml",
+      //     "rust-project.json",
+      //     ".git"
+      //   ],
+      //   "bin": "rust-analyzer",
+      //   "args": [],
+      //   "startupTimeoutMs": 20000,
+      //   "diagnosticsWaitMs": 8000,
+      //   "languageIdByExtension": {
+      //     ".rs": "rust"
+      //   }
+      // }
+      // ,
+      // {
+      //   "id": "markdown",
+      //   "include": [
+      //     "**/*.md",
+      //     "**/*.markdown",
+      //     "**/*.mdown",
+      //     "**/*.mkd",
+      //     "**/*.mmd",
+      //     "**/*.mermaid"
+      //   ],
+      //   "exclude": [
+      //     "**/.git/**",
+      //     "**/node_modules/**"
+      //   ],
+      //   "rootMarkers": [
+      //     ".git",
+      //     "package.json",
+      //     "README.md"
+      //   ],
+      //   "bin": "vscode-markdown-language-server",
+      //   "args": [
+      //     "--stdio"
+      //   ],
+      //   "startupTimeoutMs": 15000,
+      //   "diagnosticsWaitMs": 5000,
+      //   "languageIdByExtension": {
+      //     ".md": "markdown",
+      //     ".markdown": "markdown",
+      //     ".mdown": "markdown",
+      //     ".mkd": "markdown",
+      //     ".mmd": "markdown",
+      //     ".mermaid": "markdown"
+      //   },
+      //   "initializationOptions": {
+      //     "markdownFileExtensions": [
+      //       "md",
+      //       "markdown",
+      //       "mdown",
+      //       "mkd",
+      //       "mmd",
+      //       "mermaid"
+      //     ]
+      //   },
+      //   "settings": {
+      //     "markdown": {
+      //       "validate": {
+      //         "enabled": true,
+      //         "referenceLinks": {
+      //           "enabled": "error"
+      //         },
+      //         "fragmentLinks": {
+      //           "enabled": "error"
+      //         },
+      //         "fileLinks": {
+      //           "enabled": "error",
+      //           "markdownFragmentLinks": "inherit"
+      //         },
+      //         "unusedLinkDefinitions": {
+      //           "enabled": "hint"
+      //         },
+      //         "duplicateLinkDefinitions": {
+      //           "enabled": "warning"
+      //         },
+      //         "ignoredLinks": []
+      //       }
+      //     }
+      //   }
+      // }
+    ]
   }
 }
 `;

package/external/pi-tools-suite/src/index.ts

@@ -12,10 +12,10 @@ type ExtensionModule = {
 const MODULES: Array<{ name: string; load: () => Promise<ExtensionModule> }> = [
 	{ name: "ast-grep", load: () => import("./ast-grep/index") },
 	{ name: "async-subagents", load: () => import("./async-subagents/index") },
-	{ name: "terminal-bell", load: () => import("./terminal-bell/index") },
 	{ name: "lsp", load: () => import("./lsp/index") },
 	{ name: "repo-discovery", load: () => import("./repo-discovery/index") },
 	{ name: "antigravity-auth", load: () => import("./antigravity-auth/index") },
+	{ name: "opencode-import", load: () => import("./opencode-import/index") },
 	{ name: "todo", load: () => import("./todo/index") },
 	{ name: "model-tools", load: () => import("./model-tools/index") },
 	{ name: "usage", load: () => import("./usage/index") },

package/external/pi-tools-suite/src/lsp/_shared/config.ts

@@ -1,12 +1,19 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { parse as parseJsonc } from "jsonc-parser";
+import { getPiToolsSuiteUserConfigPath } from "../../config";
 import { findUp } from "./paths";
 import { askProjectConfigTrust, sha256 } from "./trust";
 import type { ConfigLayer, LoadedConfig, LspConfigFile, LspServerConfig, MatchableConfig } from "./types";
 
-function defaultAgentDir(): string {
-  return process.env.PI_AGENT_DIR ?? path.join(process.env.HOME ?? "", ".pi", "agent");
+function getPiConfigDir(): string | undefined {
+  const configured = process.env.PI_CONFIG_DIR;
+  return configured && configured.trim() !== "" ? configured : undefined;
+}
+
+function findProjectSuiteConfig(startDir: string): string | undefined {
+  return findUp(startDir, path.join(".pi", "pi-tools-suite.jsonc"));
 }
 
 function asObject(value: unknown): Record<string, unknown> | undefined {
@@ -78,9 +85,16 @@ function parseLspItems(parsed: unknown): LspServerConfig[] {
   return out;
 }
 
-async function readJsonLayer<TItem extends MatchableConfig>(options: {
+function extractLspConfig(parsed: unknown): unknown {
+  const root = asObject(parsed);
+  if (!root) return undefined;
+  return root.lsp;
+}
+
+async function readJsoncLayer<TItem extends MatchableConfig>(options: {
   scope: "global" | "project";
   filePath: string;
+  selectConfig?: (parsed: unknown) => unknown;
   parseItems: (parsed: unknown) => TItem[];
 }): Promise<ConfigLayer<TItem> | undefined> {
   let raw: string;
@@ -91,14 +105,19 @@ async function readJsonLayer<TItem extends MatchableConfig>(options: {
     throw error;
   }
 
-  const parsed = JSON.parse(raw) as unknown;
+  const parsed = parseJsonc(raw) as unknown;
+  const selected = options.selectConfig ? options.selectConfig(parsed) : parsed;
+  if (selected === undefined) return undefined;
+  const items = options.parseItems(selected);
+  if (items.length === 0) return undefined;
+
   return {
     scope: options.scope,
     path: options.filePath,
     dir: path.dirname(options.filePath),
     raw,
     hash: sha256(raw),
-    items: options.parseItems(parsed),
+    items,
   };
 }
 
@@ -123,19 +142,25 @@ function binariesForLsp(items: LspServerConfig[]): string[] {
 export async function loadLspConfig(ctx: ExtensionContext): Promise<LoadedConfig<LspServerConfig>> {
   const warnings: string[] = [];
   const layers: ConfigLayer<LspServerConfig>[] = [];
-  const globalPath = path.join(defaultAgentDir(), "lsp.json");
+  const piConfigDir = getPiConfigDir();
+  const globalPaths = [
+    getPiToolsSuiteUserConfigPath(process.env.HOME),
+    piConfigDir ? path.join(piConfigDir, "pi-tools-suite.jsonc") : undefined,
+  ].filter((item): item is string => typeof item === "string");
 
-  try {
-    const globalLayer = await readJsonLayer({ scope: "global", filePath: globalPath, parseItems: parseLspItems });
-    if (globalLayer) layers.push(globalLayer);
-  } catch (error) {
-    warnings.push(`Failed to load global lsp config: ${(error as Error).message}`);
+  for (const globalPath of globalPaths) {
+    try {
+      const globalLayer = await readJsoncLayer({ scope: "global", filePath: globalPath, selectConfig: extractLspConfig, parseItems: parseLspItems });
+      if (globalLayer) layers.push(globalLayer);
+    } catch (error) {
+      warnings.push(`Failed to load global lsp config ${globalPath}: ${(error as Error).message}`);
+    }
   }
 
-  const projectPath = findUp(ctx.cwd, path.join(".pi", "lsp.json"));
+  const projectPath = findProjectSuiteConfig(ctx.cwd);
   if (projectPath) {
     try {
-      const projectLayer = await readJsonLayer({ scope: "project", filePath: projectPath, parseItems: parseLspItems });
+      const projectLayer = await readJsoncLayer({ scope: "project", filePath: projectPath, selectConfig: extractLspConfig, parseItems: parseLspItems });
       if (projectLayer) {
         const decision = await askProjectConfigTrust({
           ctx,

package/external/pi-tools-suite/src/lsp/_shared/paths.ts

@@ -3,6 +3,7 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import type { CommandConfig, PathPlaceholders, ResolvedCommand } from "./types";
 import { applyTemplate, applyTemplateArray, applyTemplateRecord } from "./template";
+import { matchesGlob } from "./glob";
 
 export function expandHome(input: string): string {
   if (input === "~") return process.env.HOME ?? input;
@@ -26,7 +27,16 @@ export function isSubPathOrSame(parent: string, child: string): boolean {
 }
 
 export function markerExists(candidateDir: string, marker: string): boolean {
-  return fs.existsSync(path.resolve(candidateDir, marker));
+  if (!/[?*[]/.test(marker)) return fs.existsSync(path.resolve(candidateDir, marker));
+
+  const markerDir = path.dirname(marker);
+  const markerPattern = path.basename(marker);
+  const absoluteMarkerDir = path.resolve(candidateDir, markerDir === "." ? "" : markerDir);
+  try {
+    return fs.readdirSync(absoluteMarkerDir).some((entry) => matchesGlob(markerPattern, entry));
+  } catch {
+    return false;
+  }
 }
 
 export function findProjectRoot(filePath: string, rootMarkers: string[] | undefined, fallbackRoot: string): string | undefined {

package/external/pi-tools-suite/src/lsp/async.ts

@@ -18,12 +18,17 @@ export function delay(ms: number, signal?: AbortSignal): Promise<void> {
   });
 }
 
-export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
+export async function withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string, signal?: AbortSignal): Promise<T> {
+  if (signal?.aborted) throw new Error("aborted");
   let timeout: NodeJS.Timeout | undefined;
+  let abort: (() => void) | undefined;
   const timeoutPromise = new Promise<never>((_resolve, reject) => {
     timeout = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    abort = () => reject(new Error("aborted"));
+    signal?.addEventListener("abort", abort, { once: true });
   });
   return Promise.race([promise, timeoutPromise]).finally(() => {
     if (timeout) clearTimeout(timeout);
+    if (abort) signal?.removeEventListener("abort", abort);
   });
 }

package/external/pi-tools-suite/src/lsp/child-process.ts

@@ -10,6 +10,7 @@ function canWriteToChild(child: ChildProcessWithoutNullStreams): boolean {
 }
 
 export function killChild(child: ChildProcessWithoutNullStreams, signal: NodeJS.Signals): boolean {
+  let signaled = false;
   try {
     if (process.platform === "win32" && child.pid) {
       const result = spawnSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
@@ -19,9 +20,22 @@ export function killChild(child: ChildProcessWithoutNullStreams, signal: NodeJS.
       });
       if (!result.error && result.status === 0) return true;
     }
-    return child.kill(signal);
+
+    if (child.pid) {
+      try {
+        // LSP clients are spawned in their own process group on POSIX. Kill the
+        // whole group so wrapper scripts also lose children such as Godot and nc.
+        process.kill(-child.pid, signal);
+        signaled = true;
+      } catch {
+        // Fall back to the direct child below. The process may not be detached
+        // or may have already exited.
+      }
+    }
+
+    return child.kill(signal) || signaled;
   } catch {
-    return false;
+    return signaled;
   }
 }