gsd-pi 2.26.1-next.1 → 2.28.0-dev.4009980

package/dist/resources/extensions/shared/tests/format-utils.test.ts

@@ -0,0 +1,153 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import {
+  formatDuration,
+  padRight,
+  joinColumns,
+  centerLine,
+  fitColumns,
+  sparkline,
+  stripAnsi,
+} from "../format-utils.js";
+
+describe("formatDuration", () => {
+  it("formats seconds", () => {
+    assert.equal(formatDuration(0), "0s");
+    assert.equal(formatDuration(5_000), "5s");
+    assert.equal(formatDuration(59_000), "59s");
+  });
+
+  it("formats minutes and seconds", () => {
+    assert.equal(formatDuration(60_000), "1m 0s");
+    assert.equal(formatDuration(90_000), "1m 30s");
+    assert.equal(formatDuration(3_540_000), "59m 0s");
+  });
+
+  it("formats hours and minutes", () => {
+    assert.equal(formatDuration(3_600_000), "1h 0m");
+    assert.equal(formatDuration(5_400_000), "1h 30m");
+    assert.equal(formatDuration(7_200_000), "2h 0m");
+  });
+});
+
+describe("padRight", () => {
+  it("pads plain text to width", () => {
+    const result = padRight("abc", 6);
+    assert.equal(result, "abc   ");
+  });
+
+  it("does not pad when text fills width", () => {
+    const result = padRight("abcdef", 6);
+    assert.equal(result, "abcdef");
+  });
+
+  it("does not pad when text exceeds width", () => {
+    const result = padRight("abcdefgh", 6);
+    assert.equal(result, "abcdefgh");
+  });
+});
+
+describe("joinColumns", () => {
+  it("joins left and right with spacing", () => {
+    const result = joinColumns("left", "right", 20);
+    assert.equal(result.length, 20);
+    assert.ok(result.startsWith("left"));
+    assert.ok(result.endsWith("right"));
+  });
+
+  it("truncates when content overflows", () => {
+    const result = joinColumns("a".repeat(20), "b".repeat(20), 30);
+    // Should be truncated to 30 chars
+    assert.ok(result.length <= 30);
+  });
+});
+
+describe("centerLine", () => {
+  it("centers text within width", () => {
+    const result = centerLine("hi", 10);
+    assert.equal(result, "    hi");
+  });
+
+  it("truncates when content exceeds width", () => {
+    const result = centerLine("abcdefgh", 4);
+    assert.ok(result.length <= 4);
+  });
+});
+
+describe("fitColumns", () => {
+  it("joins parts that fit", () => {
+    const result = fitColumns(["aaa", "bbb", "ccc"], 20);
+    assert.ok(result.includes("aaa"));
+    assert.ok(result.includes("bbb"));
+    assert.ok(result.includes("ccc"));
+  });
+
+  it("drops parts that overflow", () => {
+    const result = fitColumns(["aaa", "bbb", "ccc"], 10);
+    assert.ok(result.includes("aaa"));
+    // May or may not include bbb depending on separator width
+  });
+
+  it("returns empty string for empty array", () => {
+    assert.equal(fitColumns([], 80), "");
+  });
+
+  it("filters out empty strings", () => {
+    const result = fitColumns(["aaa", "", "bbb"], 80);
+    assert.ok(result.includes("aaa"));
+    assert.ok(result.includes("bbb"));
+  });
+});
+
+describe("sparkline", () => {
+  it("returns empty string for empty array", () => {
+    assert.equal(sparkline([]), "");
+  });
+
+  it("renders all lowest blocks for all-zero values", () => {
+    const result = sparkline([0, 0, 0]);
+    assert.equal(result.length, 3);
+    // All chars should be the same (lowest block)
+    assert.equal(result[0], result[1]);
+    assert.equal(result[1], result[2]);
+  });
+
+  it("renders highest block for max value", () => {
+    const result = sparkline([0, 10, 5]);
+    assert.equal(result.length, 3);
+    // Middle should be highest block (█)
+    assert.equal(result[1], "\u2588");
+  });
+
+  it("handles single value", () => {
+    const result = sparkline([42]);
+    assert.equal(result.length, 1);
+    assert.equal(result, "\u2588");
+  });
+
+  it("handles large arrays without stack overflow", () => {
+    const largeArray = new Array(100_000).fill(0).map((_, i) => i);
+    const result = sparkline(largeArray);
+    assert.equal(result.length, 100_000);
+  });
+});
+
+describe("stripAnsi", () => {
+  it("strips ANSI escape sequences", () => {
+    const result = stripAnsi("\x1b[31mred\x1b[0m text");
+    assert.equal(result, "red text");
+  });
+
+  it("returns plain text unchanged", () => {
+    assert.equal(stripAnsi("plain text"), "plain text");
+  });
+
+  it("strips multiple escape sequences", () => {
+    const result = stripAnsi("\x1b[1m\x1b[32mbold green\x1b[0m");
+    assert.equal(result, "bold green");
+  });
+
+  it("handles empty string", () => {
+    assert.equal(stripAnsi(""), "");
+  });
+});

package/dist/resources/extensions/slash-commands/create-extension.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
-import { showInterviewRound, type Question, type RoundResult } from "../shared/interview-ui.js";
+import { showInterviewRound, type Question, type RoundResult } from "../shared/mod.js";
 
 export default function createExtension(pi: ExtensionAPI) {
 	pi.registerCommand("create-extension", {

package/dist/resources/extensions/slash-commands/create-slash-command.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
-import { showInterviewRound, type Question, type RoundResult } from "../shared/interview-ui.js";
+import { showInterviewRound, type Question, type RoundResult } from "../shared/mod.js";
 
 export default function createSlashCommand(pi: ExtensionAPI) {
 	pi.registerCommand("create-slash-command", {

package/dist/resources/extensions/subagent/index.ts

@@ -12,7 +12,7 @@
  * Uses JSON mode to capture structured output from subagents.
  */
 
-import { spawn } from "node:child_process";
+import { spawn, type ChildProcess } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
@@ -23,7 +23,6 @@ import { StringEnum } from "@gsd/pi-ai";
 import { type ExtensionAPI, getMarkdownTheme } from "@gsd/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { parseBundledExtensionPaths } from "../shared/bundled-extension-paths.js";
 import { type AgentConfig, type AgentScope, discoverAgents } from "./agents.js";
 import {
 	type IsolationEnvironment,
@@ -38,6 +37,44 @@ import { registerWorker, updateWorker } from "./worker-registry.js";
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
 const COLLAPSED_ITEM_COUNT = 10;
+const liveSubagentProcesses = new Set<ChildProcess>();
+
+async function stopLiveSubagents(): Promise<void> {
+	const active = Array.from(liveSubagentProcesses);
+	if (active.length === 0) return;
+
+	for (const proc of active) {
+		try {
+			proc.kill("SIGTERM");
+		} catch {
+			/* ignore */
+		}
+	}
+
+	await Promise.all(
+		active.map(
+			(proc) =>
+				new Promise<void>((resolve) => {
+					const done = () => resolve();
+					const timer = setTimeout(done, 500);
+					proc.once("exit", () => {
+						clearTimeout(timer);
+						resolve();
+					});
+				}),
+		),
+	);
+
+	for (const proc of active) {
+		if (proc.exitCode === null) {
+			try {
+				proc.kill("SIGKILL");
+			} catch {
+				/* ignore */
+			}
+		}
+	}
+}
 
 function formatTokens(count: number): string {
 	if (count < 1000) return count.toString();
@@ -295,13 +332,14 @@ async function runSingleAgent(
 		let wasAborted = false;
 
 		const exitCode = await new Promise<number>((resolve) => {
-			const bundledPaths = parseBundledExtensionPaths(process.env.GSD_BUNDLED_EXTENSION_PATHS);
+			const bundledPaths = (process.env.GSD_BUNDLED_EXTENSION_PATHS ?? "").split(path.delimiter).map(s => s.trim()).filter(Boolean);
 			const extensionArgs = bundledPaths.flatMap(p => ["--extension", p]);
 			const proc = spawn(
 				process.execPath,
 				[process.env.GSD_BIN_PATH!, ...extensionArgs, ...args],
 				{ cwd: cwd ?? defaultCwd, shell: false, stdio: ["ignore", "pipe", "pipe"] },
 			);
+			liveSubagentProcesses.add(proc);
 			let buffer = "";
 
 			const processLine = (line: string) => {
@@ -353,11 +391,13 @@ async function runSingleAgent(
 			});
 
 			proc.on("close", (code) => {
+				liveSubagentProcesses.delete(proc);
 				if (buffer.trim()) processLine(buffer);
 				resolve(code ?? 0);
 			});
 
 			proc.on("error", () => {
+				liveSubagentProcesses.delete(proc);
 				resolve(1);
 			});
 
@@ -432,6 +472,10 @@ const SubagentParams = Type.Object({
 });
 
 export default function (pi: ExtensionAPI) {
+	pi.on("session_shutdown", async () => {
+		await stopLiveSubagents();
+	});
+
 	// /subagent command - list available agents
 	pi.registerCommand("subagent", {
 		description: "List available subagents",

package/dist/resources/extensions/subagent/isolation.ts

@@ -273,13 +273,16 @@ export async function createWorktreeIsolation(
 		async cleanup(): Promise<void> {
 			activeIsolations.delete(worktreeDir);
 			try {
-				await git(
-					["worktree", "remove", "--force", worktreeDir],
-					repoRoot,
-				);
+				await Promise.race([
+					git(["worktree", "remove", "--force", worktreeDir], repoRoot),
+					new Promise<never>((_, reject) =>
+						setTimeout(() => reject(new Error("Worktree cleanup timed out")), 10_000),
+					),
+				]);
 			} catch {
-				// Force remove directory if git worktree remove fails
-				fs.rmSync(worktreeDir, { recursive: true, force: true });
+				try {
+					fs.rmSync(worktreeDir, { recursive: true, force: true });
+				} catch { /* best effort */ }
 			}
 		},
 	};

package/dist/resources/extensions/ttsr/index.ts

@@ -85,6 +85,11 @@ function extractDeltaContext(
 	return null;
 }
 
+// Re-exports for external consumers
+export { TtsrManager } from "./ttsr-manager.js";
+export type { Rule, TtsrMatchContext } from "./ttsr-manager.js";
+export { loadRules } from "./rule-loader.js";
+
 export default function (pi: ExtensionAPI) {
 	let manager: TtsrManager | null = null;
 	let pendingViolation: PendingViolation | null = null;

package/dist/resources/extensions/ttsr/rule-loader.ts

@@ -9,53 +9,7 @@ import { readdirSync, readFileSync, existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { homedir } from "node:os";
 import type { Rule } from "./ttsr-manager.js";
-
-const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
-
-/** Minimal YAML parser for frontmatter (handles string arrays and scalars). */
-function parseFrontmatter(raw: string): Record<string, unknown> {
-	const result: Record<string, unknown> = {};
-	let currentKey: string | null = null;
-	let currentArray: string[] | null = null;
-
-	for (const line of raw.split("\n")) {
-		const trimmed = line.trimEnd();
-
-		// Array item under current key
-		if (currentKey && /^\s+-\s+/.test(trimmed)) {
-			const value = trimmed.replace(/^\s+-\s+/, "").replace(/^["']|["']$/g, "");
-			currentArray!.push(value);
-			continue;
-		}
-
-		// Flush previous array
-		if (currentKey && currentArray) {
-			result[currentKey] = currentArray;
-			currentKey = null;
-			currentArray = null;
-		}
-
-		// Key-value or key-with-array
-		const kvMatch = trimmed.match(/^(\w[\w-]*):\s*(.*)$/);
-		if (kvMatch) {
-			const [, key, value] = kvMatch;
-			if (value.length === 0) {
-				// Expect array items below
-				currentKey = key;
-				currentArray = [];
-			} else {
-				result[key] = value.replace(/^["']|["']$/g, "");
-			}
-		}
-	}
-
-	// Flush trailing array
-	if (currentKey && currentArray) {
-		result[currentKey] = currentArray;
-	}
-
-	return result;
-}
+import { splitFrontmatter, parseFrontmatterMap } from "../shared/frontmatter.js";
 
 function parseRuleFile(filePath: string): Rule | null {
 	let content: string;
@@ -65,11 +19,10 @@ function parseRuleFile(filePath: string): Rule | null {
 		return null;
 	}
 
-	const match = FRONTMATTER_RE.exec(content);
-	if (!match) return null;
+	const [fmLines, body] = splitFrontmatter(content);
+	if (!fmLines) return null;
 
-	const [, frontmatterRaw, body] = match;
-	const meta = parseFrontmatter(frontmatterRaw);
+	const meta = parseFrontmatterMap(fmLines);
 
 	const condition = meta.condition;
 	if (!Array.isArray(condition) || condition.length === 0) return null;

package/dist/resources/extensions/universal-config/discovery.ts

@@ -10,6 +10,25 @@ import { TOOLS } from "./tools.js";
 import { SCANNERS } from "./scanners.js";
 import type { DiscoveryResult, DiscoveredItem, ToolDiscoveryResult } from "./types.js";
 
+/** Inline concurrency limiter to cap parallel async operations. */
+function pLimit(concurrency: number) {
+  const queue: (() => void)[] = [];
+  let active = 0;
+  return <T>(fn: () => Promise<T>): Promise<T> => {
+    return new Promise<T>((resolve, reject) => {
+      const run = () => {
+        active++;
+        fn().then(resolve, reject).finally(() => {
+          active--;
+          if (queue.length > 0) queue.shift()!();
+        });
+      };
+      if (active < concurrency) run();
+      else queue.push(run);
+    });
+  };
+}
+
 /**
  * Run universal config discovery across all supported AI coding tools.
  *
@@ -25,22 +44,25 @@ export async function discoverAllConfigs(
   const allWarnings: string[] = [];
   const toolResults: ToolDiscoveryResult[] = [];
 
-  // Run all scanners in parallel
+  // Run scanners with bounded concurrency to avoid memory spikes
+  const limit = pLimit(5);
   const results = await Promise.allSettled(
-    TOOLS.map(async (tool) => {
-      const scanner = SCANNERS[tool.id];
-      if (!scanner) return { tool, items: [] as DiscoveredItem[], warnings: [`No scanner for ${tool.id}`] };
-      try {
-        const { items, warnings } = await scanner(projectRoot, home, tool);
-        return { tool, items, warnings };
-      } catch (err) {
-        return {
-          tool,
-          items: [] as DiscoveredItem[],
-          warnings: [`Scanner error for ${tool.name}: ${err instanceof Error ? err.message : String(err)}`],
-        };
-      }
-    }),
+    TOOLS.map((tool) =>
+      limit(async () => {
+        const scanner = SCANNERS[tool.id];
+        if (!scanner) return { tool, items: [] as DiscoveredItem[], warnings: [`No scanner for ${tool.id}`] };
+        try {
+          const { items, warnings } = await scanner(projectRoot, home, tool);
+          return { tool, items, warnings };
+        } catch (err) {
+          return {
+            tool,
+            items: [] as DiscoveredItem[],
+            warnings: [`Scanner error for ${tool.name}: ${err instanceof Error ? err.message : String(err)}`],
+          };
+        }
+      }),
+    ),
   );
 
   for (const result of results) {

package/dist/resources/extensions/voice/index.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
-import { shortcutDesc } from "../shared/terminal.js";
+import { shortcutDesc } from "../shared/mod.js";
 import type { AssistantMessage } from "@gsd/pi-ai";
 import { isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import { spawn, execSync, type ChildProcess } from "node:child_process";