gsd-pi 2.29.0 → 2.30.0-dev.7e1bbce

package/dist/worktree-cli.js

@@ -0,0 +1,294 @@
+/**
+ * GSD Worktree CLI — standalone subcommand and -w flag handling.
+ *
+ * Manages the full worktree lifecycle from the command line:
+ *   gsd -w                    Create auto-named worktree, start interactive session
+ *   gsd -w my-feature         Create/resume named worktree
+ *   gsd worktree list         List worktrees with status
+ *   gsd worktree merge [name] Squash-merge a worktree into main
+ *   gsd worktree clean        Remove all merged/empty worktrees
+ *   gsd worktree remove <n>   Remove a specific worktree
+ *
+ * On session exit (via session_shutdown event), auto-commits dirty work
+ * so nothing is lost. The GSD extension reads GSD_CLI_WORKTREE to know
+ * when a session was launched via -w.
+ */
+import chalk from 'chalk';
+import { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, worktreeBranchName, } from './resources/extensions/gsd/worktree-manager.js';
+import { runWorktreePostCreateHook } from './resources/extensions/gsd/auto-worktree.js';
+import { generateWorktreeName } from './worktree-name-gen.js';
+import { nativeHasChanges, nativeDetectMainBranch, nativeCommitCountBetween, } from './resources/extensions/gsd/native-git-bridge.js';
+import { inferCommitType } from './resources/extensions/gsd/git-service.js';
+import { existsSync } from 'node:fs';
+// ─── Status Helpers ─────────────────────────────────────────────────────────
+function getWorktreeStatus(basePath, name, wtPath) {
+    const diff = diffWorktreeAll(basePath, name);
+    const numstat = diffWorktreeNumstat(basePath, name);
+    const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const s of numstat) {
+        linesAdded += s.added;
+        linesRemoved += s.removed;
+    }
+    let uncommitted = false;
+    try {
+        uncommitted = existsSync(wtPath) && nativeHasChanges(wtPath);
+    }
+    catch { /* */ }
+    let commits = 0;
+    try {
+        const mainBranch = nativeDetectMainBranch(basePath);
+        commits = nativeCommitCountBetween(basePath, mainBranch, worktreeBranchName(name));
+    }
+    catch { /* */ }
+    return {
+        name,
+        path: wtPath,
+        branch: worktreeBranchName(name),
+        exists: existsSync(wtPath),
+        filesChanged,
+        linesAdded,
+        linesRemoved,
+        uncommitted,
+        commits,
+    };
+}
+// ─── Formatters ─────────────────────────────────────────────────────────────
+function formatStatus(s) {
+    const lines = [];
+    const badge = s.uncommitted
+        ? chalk.yellow(' (uncommitted)')
+        : s.filesChanged > 0
+            ? chalk.cyan(' (unmerged)')
+            : chalk.green(' (clean)');
+    lines.push(`  ${chalk.bold.cyan(s.name)}${badge}`);
+    lines.push(`    ${chalk.dim('branch')}  ${chalk.magenta(s.branch)}`);
+    lines.push(`    ${chalk.dim('path')}    ${chalk.dim(s.path)}`);
+    if (s.filesChanged > 0) {
+        lines.push(`    ${chalk.dim('diff')}    ${s.filesChanged} files, ${chalk.green(`+${s.linesAdded}`)} ${chalk.red(`-${s.linesRemoved}`)}, ${s.commits} commit${s.commits === 1 ? '' : 's'}`);
+    }
+    return lines.join('\n');
+}
+// ─── Subcommand: list ───────────────────────────────────────────────────────
+function handleList(basePath) {
+    const worktrees = listWorktrees(basePath);
+    if (worktrees.length === 0) {
+        process.stderr.write(chalk.dim('No worktrees. Create one with: gsd -w <name>\n'));
+        return;
+    }
+    process.stderr.write(chalk.bold('\nWorktrees\n\n'));
+    for (const wt of worktrees) {
+        const status = getWorktreeStatus(basePath, wt.name, wt.path);
+        process.stderr.write(formatStatus(status) + '\n\n');
+    }
+}
+// ─── Subcommand: merge ──────────────────────────────────────────────────────
+async function handleMerge(basePath, args) {
+    const name = args[0];
+    if (!name) {
+        // If only one worktree exists, merge it
+        const worktrees = listWorktrees(basePath);
+        if (worktrees.length === 1) {
+            await doMerge(basePath, worktrees[0].name);
+            return;
+        }
+        process.stderr.write(chalk.red('Usage: gsd worktree merge <name>\n'));
+        process.stderr.write(chalk.dim('Run gsd worktree list to see worktrees.\n'));
+        process.exit(1);
+    }
+    await doMerge(basePath, name);
+}
+async function doMerge(basePath, name) {
+    const worktrees = listWorktrees(basePath);
+    const wt = worktrees.find(w => w.name === name);
+    if (!wt) {
+        process.stderr.write(chalk.red(`Worktree "${name}" not found.\n`));
+        process.exit(1);
+    }
+    const status = getWorktreeStatus(basePath, name, wt.path);
+    if (status.filesChanged === 0 && !status.uncommitted) {
+        process.stderr.write(chalk.dim(`Worktree "${name}" has no changes to merge.\n`));
+        // Clean up empty worktree
+        removeWorktree(basePath, name, { deleteBranch: true });
+        process.stderr.write(chalk.green(`Removed empty worktree ${chalk.bold(name)}.\n`));
+        return;
+    }
+    // Auto-commit dirty work before merge
+    if (status.uncommitted) {
+        try {
+            const { autoCommitCurrentBranch } = await import('./resources/extensions/gsd/worktree.js');
+            autoCommitCurrentBranch(wt.path, 'worktree-merge', name);
+            process.stderr.write(chalk.dim('  Auto-committed dirty work before merge.\n'));
+        }
+        catch { /* best-effort */ }
+    }
+    const commitType = inferCommitType(name);
+    const commitMessage = `${commitType}(${name}): merge worktree ${name}`;
+    process.stderr.write(`\nMerging ${chalk.bold.cyan(name)} → ${chalk.magenta(nativeDetectMainBranch(basePath))}\n`);
+    process.stderr.write(chalk.dim(`  ${status.filesChanged} files, ${chalk.green(`+${status.linesAdded}`)} ${chalk.red(`-${status.linesRemoved}`)}\n\n`));
+    try {
+        mergeWorktreeToMain(basePath, name, commitMessage);
+        removeWorktree(basePath, name, { deleteBranch: true });
+        process.stderr.write(chalk.green(`✓ Merged and cleaned up ${chalk.bold(name)}\n`));
+        process.stderr.write(chalk.dim(`  commit: ${commitMessage}\n`));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(chalk.red(`✗ Merge failed: ${msg}\n`));
+        process.stderr.write(chalk.dim('  Resolve conflicts manually, then run gsd worktree merge again.\n'));
+        process.exit(1);
+    }
+}
+// ─── Subcommand: clean ──────────────────────────────────────────────────────
+function handleClean(basePath) {
+    const worktrees = listWorktrees(basePath);
+    if (worktrees.length === 0) {
+        process.stderr.write(chalk.dim('No worktrees to clean.\n'));
+        return;
+    }
+    let cleaned = 0;
+    for (const wt of worktrees) {
+        const status = getWorktreeStatus(basePath, wt.name, wt.path);
+        if (status.filesChanged === 0 && !status.uncommitted) {
+            try {
+                removeWorktree(basePath, wt.name, { deleteBranch: true });
+                process.stderr.write(chalk.green(`  ✓ Removed ${chalk.bold(wt.name)} (clean)\n`));
+                cleaned++;
+            }
+            catch {
+                process.stderr.write(chalk.yellow(`  ✗ Failed to remove ${wt.name}\n`));
+            }
+        }
+        else {
+            process.stderr.write(chalk.dim(`  ─ Kept ${chalk.bold(wt.name)} (${status.filesChanged} changed files)\n`));
+        }
+    }
+    process.stderr.write(chalk.dim(`\nCleaned ${cleaned} worktree${cleaned === 1 ? '' : 's'}.\n`));
+}
+// ─── Subcommand: remove ─────────────────────────────────────────────────────
+function handleRemove(basePath, args) {
+    const name = args[0];
+    if (!name) {
+        process.stderr.write(chalk.red('Usage: gsd worktree remove <name>\n'));
+        process.exit(1);
+    }
+    const worktrees = listWorktrees(basePath);
+    const wt = worktrees.find(w => w.name === name);
+    if (!wt) {
+        process.stderr.write(chalk.red(`Worktree "${name}" not found.\n`));
+        process.exit(1);
+    }
+    const status = getWorktreeStatus(basePath, name, wt.path);
+    if (status.filesChanged > 0 || status.uncommitted) {
+        process.stderr.write(chalk.yellow(`⚠ Worktree "${name}" has unmerged changes (${status.filesChanged} files).\n`));
+        process.stderr.write(chalk.yellow('  Use --force to remove anyway, or merge first: gsd worktree merge ' + name + '\n'));
+        if (!process.argv.includes('--force')) {
+            process.exit(1);
+        }
+    }
+    removeWorktree(basePath, name, { deleteBranch: true });
+    process.stderr.write(chalk.green(`✓ Removed worktree ${chalk.bold(name)}\n`));
+}
+// ─── Subcommand: status (default when no args) ─────────────────────────────
+function handleStatusBanner(basePath) {
+    const worktrees = listWorktrees(basePath);
+    if (worktrees.length === 0)
+        return;
+    const withChanges = worktrees.filter(wt => {
+        try {
+            const diff = diffWorktreeAll(basePath, wt.name);
+            return diff.added.length + diff.modified.length + diff.removed.length > 0;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (withChanges.length === 0)
+        return;
+    const names = withChanges.map(w => chalk.cyan(w.name)).join(', ');
+    process.stderr.write(chalk.dim('[gsd] ') +
+        chalk.yellow(`${withChanges.length} worktree${withChanges.length === 1 ? '' : 's'} with unmerged changes: `) +
+        names + '\n' +
+        chalk.dim('[gsd] ') +
+        chalk.dim('Resume: gsd -w <name>  |  Merge: gsd worktree merge <name>  |  List: gsd worktree list\n\n'));
+}
+// ─── -w flag: create/resume worktree for interactive session ────────────────
+function handleWorktreeFlag(worktreeFlag) {
+    const basePath = process.cwd();
+    // gsd -w (no name) — resume most recent worktree with changes, or create new
+    if (worktreeFlag === true) {
+        const existing = listWorktrees(basePath);
+        const withChanges = existing.filter(wt => {
+            try {
+                const diff = diffWorktreeAll(basePath, wt.name);
+                return diff.added.length + diff.modified.length + diff.removed.length > 0;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (withChanges.length === 1) {
+            // Single active worktree — resume it
+            const wt = withChanges[0];
+            process.chdir(wt.path);
+            process.env.GSD_CLI_WORKTREE = wt.name;
+            process.env.GSD_CLI_WORKTREE_BASE = basePath;
+            process.stderr.write(chalk.green(`✓ Resumed worktree ${chalk.bold(wt.name)}\n`));
+            process.stderr.write(chalk.dim(`  path   ${wt.path}\n`));
+            process.stderr.write(chalk.dim(`  branch ${wt.branch}\n\n`));
+            return;
+        }
+        if (withChanges.length > 1) {
+            // Multiple active worktrees — show them and ask user to pick
+            process.stderr.write(chalk.yellow(`${withChanges.length} worktrees have unmerged changes:\n\n`));
+            for (const wt of withChanges) {
+                const status = getWorktreeStatus(basePath, wt.name, wt.path);
+                process.stderr.write(formatStatus(status) + '\n\n');
+            }
+            process.stderr.write(chalk.dim('Specify which one: gsd -w <name>\n'));
+            process.exit(0);
+        }
+        // No active worktrees — create a new one
+        const name = generateWorktreeName();
+        createAndEnter(basePath, name);
+        return;
+    }
+    // gsd -w <name> — create or resume named worktree
+    const name = worktreeFlag;
+    const existing = listWorktrees(basePath);
+    const found = existing.find(wt => wt.name === name);
+    if (found) {
+        process.chdir(found.path);
+        process.env.GSD_CLI_WORKTREE = name;
+        process.env.GSD_CLI_WORKTREE_BASE = basePath;
+        process.stderr.write(chalk.green(`✓ Resumed worktree ${chalk.bold(name)}\n`));
+        process.stderr.write(chalk.dim(`  path   ${found.path}\n`));
+        process.stderr.write(chalk.dim(`  branch ${found.branch}\n\n`));
+    }
+    else {
+        createAndEnter(basePath, name);
+    }
+}
+function createAndEnter(basePath, name) {
+    try {
+        const info = createWorktree(basePath, name);
+        const hookError = runWorktreePostCreateHook(basePath, info.path);
+        if (hookError) {
+            process.stderr.write(chalk.yellow(`[gsd] ${hookError}\n`));
+        }
+        process.chdir(info.path);
+        process.env.GSD_CLI_WORKTREE = name;
+        process.env.GSD_CLI_WORKTREE_BASE = basePath;
+        process.stderr.write(chalk.green(`✓ Created worktree ${chalk.bold(name)}\n`));
+        process.stderr.write(chalk.dim(`  path   ${info.path}\n`));
+        process.stderr.write(chalk.dim(`  branch ${info.branch}\n\n`));
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(chalk.red(`[gsd] Failed to create worktree: ${msg}\n`));
+        process.exit(1);
+    }
+}
+// ─── Exports ────────────────────────────────────────────────────────────────
+export { handleList, handleMerge, handleClean, handleRemove, handleStatusBanner, handleWorktreeFlag, getWorktreeStatus, };

package/dist/worktree-name-gen.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Random worktree name generator.
+ *
+ * Produces names in the pattern: adjective-verbing-noun
+ * e.g. "noble-roaming-karp", "swift-whistling-matsumoto"
+ */
+export declare function generateWorktreeName(): string;

package/dist/worktree-name-gen.js

@@ -0,0 +1,44 @@
+/**
+ * Random worktree name generator.
+ *
+ * Produces names in the pattern: adjective-verbing-noun
+ * e.g. "noble-roaming-karp", "swift-whistling-matsumoto"
+ */
+const ADJECTIVES = [
+    'agile', 'bold', 'brave', 'bright', 'calm', 'clear', 'cool', 'crisp',
+    'dapper', 'eager', 'fair', 'fast', 'fierce', 'fine', 'fleet', 'fond',
+    'gentle', 'glad', 'grand', 'happy', 'keen', 'kind', 'lively', 'lucid',
+    'mellow', 'merry', 'mighty', 'neat', 'nimble', 'noble', 'plucky', 'polite',
+    'proud', 'quiet', 'rapid', 'ready', 'serene', 'sharp', 'sleek', 'sleepy',
+    'smooth', 'snappy', 'steady', 'sturdy', 'sunny', 'sure', 'swift', 'tidy',
+    'tough', 'tranquil', 'vivid', 'warm', 'wise', 'witty', 'zesty',
+];
+const VERBS = [
+    'baking', 'bouncing', 'building', 'carving', 'chasing', 'climbing',
+    'coding', 'crafting', 'dancing', 'dashing', 'diving', 'drawing',
+    'dreaming', 'drifting', 'drumming', 'exploring', 'fishing', 'floating',
+    'flying', 'forging', 'gliding', 'growing', 'hiking', 'humming',
+    'jumping', 'juggling', 'knitting', 'laughing', 'leaping', 'mapping',
+    'mixing', 'painting', 'planting', 'playing', 'racing', 'reading',
+    'riding', 'roaming', 'rowing', 'running', 'sailing', 'singing',
+    'skating', 'sketching', 'spinning', 'squishing', 'surfing', 'swimming',
+    'thinking', 'threading', 'tracing', 'walking', 'weaving', 'whistling',
+    'writing',
+];
+const NOUNS = [
+    'atlas', 'aurora', 'balloon', 'beacon', 'bolt', 'brook', 'canyon',
+    'cedar', 'comet', 'cook', 'coral', 'cosmos', 'crest', 'dawn', 'delta',
+    'echo', 'ember', 'falcon', 'fern', 'flare', 'frost', 'gale', 'glacier',
+    'grove', 'harbor', 'hawk', 'horizon', 'iris', 'jade', 'karp', 'lantern',
+    'lark', 'luna', 'maple', 'marsh', 'matsumoto', 'mesa', 'nebula', 'oasis',
+    'orbit', 'otter', 'pebble', 'phoenix', 'pine', 'prism', 'puppy', 'quartz',
+    'raven', 'reef', 'ridge', 'river', 'sage', 'shore', 'sierra', 'spark',
+    'sprout', 'stone', 'summit', 'thorn', 'tide', 'topaz', 'trail', 'vale',
+    'violet', 'wave', 'willow', 'zenith',
+];
+function pick(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+export function generateWorktreeName() {
+    return `${pick(ADJECTIVES)}-${pick(VERBS)}-${pick(NOUNS)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.29.0",
+  "version": "2.30.0-dev.7e1bbce",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/packages/native/dist/native.d.ts

@@ -55,3 +55,5 @@ export declare const native: {
     parseStreamingJson: (text: string) => unknown;
     xxHash32: (input: string, seed: number) => number;
 };
+/** True when the native addon loaded successfully. False on unsupported platforms. */
+export declare const nativeAvailable = false;

package/packages/native/dist/native.js

@@ -22,12 +22,14 @@ const platformPackageMap = {
     "linux-arm64": "linux-arm64-gnu",
     "win32-x64": "win32-x64-msvc",
 };
+let _loadedSuccessfully = false;
 function loadNative() {
     const errors = [];
     // 1. Try the platform-specific npm optional dependency
     const packageSuffix = platformPackageMap[platformTag];
     if (packageSuffix) {
         try {
+            _loadedSuccessfully = true;
             return require(`@gsd-build/engine-${packageSuffix}`);
         }
         catch (err) {
@@ -38,6 +40,7 @@ function loadNative() {
     // 2. Try local release build (native/addon/gsd_engine.{platform}.node)
     const releasePath = path.join(addonDir, `gsd_engine.${platformTag}.node`);
     try {
+        _loadedSuccessfully = true;
         return require(releasePath);
     }
     catch (err) {
@@ -47,6 +50,7 @@ function loadNative() {
     // 3. Try local dev build (native/addon/gsd_engine.dev.node)
     const devPath = path.join(addonDir, "gsd_engine.dev.node");
     try {
+        _loadedSuccessfully = true;
         return require(devPath);
     }
     catch (err) {
@@ -55,10 +59,20 @@ function loadNative() {
     }
     const details = errors.map((e) => `  - ${e}`).join("\n");
     const supportedPlatforms = Object.keys(platformPackageMap);
-    throw new Error(`Failed to load gsd_engine native addon for ${platformTag}.\n\n` +
-        `Tried:\n${details}\n\n` +
-        `Supported platforms: ${supportedPlatforms.join(", ")}\n` +
-        `If your platform is listed, try reinstalling: npm i -g gsd-pi\n` +
-        `Otherwise, please open an issue: https://github.com/gsd-build/gsd-2/issues`);
+    // Graceful fallback: on unsupported platforms (e.g., win32-arm64), return a
+    // proxy that throws on individual function calls rather than crashing the
+    // entire import chain at startup (#1223). Consumers with JS fallbacks
+    // (parseRoadmap, parsePlan, fuzzyFind, etc.) catch these and degrade gracefully.
+    process.stderr.write(`[gsd] Native addon not available for ${platformTag}. Falling back to JS implementations (slower).\n` +
+        `  Supported native platforms: ${supportedPlatforms.join(", ")}\n`);
+    return new Proxy({}, {
+        get(_target, prop) {
+            return (..._args) => {
+                throw new Error(`Native function '${String(prop)}' is not available on ${platformTag}`);
+            };
+        },
+    });
 }
 export const native = loadNative();
+/** True when the native addon loaded successfully. False on unsupported platforms. */
+export const nativeAvailable = _loadedSuccessfully;

package/packages/native/src/native.ts

@@ -27,6 +27,8 @@ const platformPackageMap: Record<string, string> = {
   "win32-x64": "win32-x64-msvc",
 };
 
+let _loadedSuccessfully = false;
+
 function loadNative(): Record<string, unknown> {
   const errors: string[] = [];
 
@@ -34,7 +36,7 @@ function loadNative(): Record<string, unknown> {
   const packageSuffix = platformPackageMap[platformTag];
   if (packageSuffix) {
     try {
-      return require(`@gsd-build/engine-${packageSuffix}`) as Record<string, unknown>;
+      _loadedSuccessfully = true; return require(`@gsd-build/engine-${packageSuffix}`) as Record<string, unknown>;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       errors.push(`@gsd-build/engine-${packageSuffix}: ${message}`);
@@ -44,7 +46,7 @@ function loadNative(): Record<string, unknown> {
   // 2. Try local release build (native/addon/gsd_engine.{platform}.node)
   const releasePath = path.join(addonDir, `gsd_engine.${platformTag}.node`);
   try {
-    return require(releasePath) as Record<string, unknown>;
+    _loadedSuccessfully = true; return require(releasePath) as Record<string, unknown>;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     errors.push(`${releasePath}: ${message}`);
@@ -53,7 +55,7 @@ function loadNative(): Record<string, unknown> {
   // 3. Try local dev build (native/addon/gsd_engine.dev.node)
   const devPath = path.join(addonDir, "gsd_engine.dev.node");
   try {
-    return require(devPath) as Record<string, unknown>;
+    _loadedSuccessfully = true; return require(devPath) as Record<string, unknown>;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     errors.push(`${devPath}: ${message}`);
@@ -61,13 +63,22 @@ function loadNative(): Record<string, unknown> {
 
   const details = errors.map((e) => `  - ${e}`).join("\n");
   const supportedPlatforms = Object.keys(platformPackageMap);
-  throw new Error(
-    `Failed to load gsd_engine native addon for ${platformTag}.\n\n` +
-      `Tried:\n${details}\n\n` +
-      `Supported platforms: ${supportedPlatforms.join(", ")}\n` +
-      `If your platform is listed, try reinstalling: npm i -g gsd-pi\n` +
-      `Otherwise, please open an issue: https://github.com/gsd-build/gsd-2/issues`,
+
+  // Graceful fallback: on unsupported platforms (e.g., win32-arm64), return a
+  // proxy that throws on individual function calls rather than crashing the
+  // entire import chain at startup (#1223). Consumers with JS fallbacks
+  // (parseRoadmap, parsePlan, fuzzyFind, etc.) catch these and degrade gracefully.
+  process.stderr.write(
+    `[gsd] Native addon not available for ${platformTag}. Falling back to JS implementations (slower).\n` +
+      `  Supported native platforms: ${supportedPlatforms.join(", ")}\n`,
   );
+  return new Proxy({} as Record<string, unknown>, {
+    get(_target, prop) {
+      return (..._args: unknown[]) => {
+        throw new Error(`Native function '${String(prop)}' is not available on ${platformTag}`);
+      };
+    },
+  });
 }
 
 export const native = loadNative() as {
@@ -140,3 +151,6 @@ export const native = loadNative() as {
   parseStreamingJson: (text: string) => unknown;
   xxHash32: (input: string, seed: number) => number;
 };
+
+/** True when the native addon loaded successfully. False on unsupported platforms. */
+export const nativeAvailable = _loadedSuccessfully;

package/packages/pi-coding-agent/dist/core/extensions/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAsBH,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIhE,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAChG,OAAO,KAAK,EACX,SAAS,EAET,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EAKpB,MAAM,YAAY,CAAC;AA6FpB;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAkCzD;AA6LD;;GAEG;AACH,wBAAsB,wBAAwB,CAC7C,OAAO,EAAE,gBAAgB,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,gBAAgB,EACzB,aAAa,SAAa,GACxB,OAAO,CAAC,SAAS,CAAC,CAKpB;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAyBrH;AA+GD;;GAEG;AACH,wBAAsB,yBAAyB,CAC9C,eAAe,EAAE,MAAM,EAAE,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,MAAsB,EAChC,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,oBAAoB,CAAC,CAoD/B"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyBH,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIhE,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAChG,OAAO,KAAK,EACX,SAAS,EAET,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EAKpB,MAAM,YAAY,CAAC;AAuGpB;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAkCzD;AA6LD;;GAEG;AACH,wBAAsB,wBAAwB,CAC7C,OAAO,EAAE,gBAAgB,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,gBAAgB,EACzB,aAAa,SAAa,GACxB,OAAO,CAAC,SAAS,CAAC,CAKpB;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAyBrH;AA+GD;;GAEG;AACH,wBAAsB,yBAAyB,CAC9C,eAAe,EAAE,MAAM,EAAE,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,MAAsB,EAChC,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,oBAAoB,CAAC,CAoD/B"}

package/packages/pi-coding-agent/dist/core/extensions/loader.js

@@ -18,6 +18,9 @@ import * as _bundledPiTui from "@gsd/pi-tui";
 // The virtualModules option then makes them available to extensions.
 import * as _bundledTypebox from "@sinclair/typebox";
 import * as _bundledYaml from "yaml";
+import * as _bundledMcpClient from "@modelcontextprotocol/sdk/client";
+import * as _bundledMcpStdio from "@modelcontextprotocol/sdk/client/stdio.js";
+import * as _bundledMcpStreamableHttp from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { getAgentDir, isBunBinary } from "../../config.js";
 // NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
 // avoiding a circular dependency. Extensions can import from @gsd/pi-coding-agent.
@@ -35,6 +38,11 @@ const VIRTUAL_MODULES = {
     "@gsd/pi-ai/oauth": _bundledPiAiOauth,
     "@gsd/pi-coding-agent": _bundledPiCodingAgent,
     "yaml": _bundledYaml,
+    "@modelcontextprotocol/sdk/client": _bundledMcpClient,
+    "@modelcontextprotocol/sdk/client/stdio": _bundledMcpStdio,
+    "@modelcontextprotocol/sdk/client/stdio.js": _bundledMcpStdio,
+    "@modelcontextprotocol/sdk/client/streamableHttp": _bundledMcpStreamableHttp,
+    "@modelcontextprotocol/sdk/client/streamableHttp.js": _bundledMcpStreamableHttp,
     // Aliases for external PI ecosystem packages that import from the original scope
     "@mariozechner/pi-agent-core": _bundledPiAgentCore,
     "@mariozechner/pi-tui": _bundledPiTui,
@@ -73,6 +81,11 @@ function getAliases() {
         "@gsd/pi-ai/oauth": resolveWorkspaceOrImport("ai/dist/oauth.js", "@gsd/pi-ai/oauth"),
         "@sinclair/typebox": typeboxRoot,
         "yaml": yamlRoot,
+        "@modelcontextprotocol/sdk/client": require.resolve("@modelcontextprotocol/sdk/client"),
+        "@modelcontextprotocol/sdk/client/stdio": require.resolve("@modelcontextprotocol/sdk/client/stdio.js"),
+        "@modelcontextprotocol/sdk/client/stdio.js": require.resolve("@modelcontextprotocol/sdk/client/stdio.js"),
+        "@modelcontextprotocol/sdk/client/streamableHttp": require.resolve("@modelcontextprotocol/sdk/client/streamableHttp.js"),
+        "@modelcontextprotocol/sdk/client/streamableHttp.js": require.resolve("@modelcontextprotocol/sdk/client/streamableHttp.js"),
         // Aliases for external PI ecosystem packages that import from the original scope
         "@mariozechner/pi-coding-agent": packageIndex,
         "@mariozechner/pi-agent-core": resolveWorkspaceOrImport("agent/dist/index.js", "@gsd/pi-agent-core"),