fix(pi-tree): load runtime bundle modules for pi >= 0.84.3

packages/pi-tree/package.json

@@ -36,7 +36,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@zigai/pi-extension-internals": "0.1.0",
+    "@zigai/pi-extension-internals": "0.1.2",
     "@zigai/pi-extension-settings": "0.5.2"
   },
   "peerDependencies": {

packages/pi-tree/src/internal-imports.ts

@@ -1,4 +1,4 @@
-import { loadPiInternalModule } from "@zigai/pi-extension-internals";
+import { loadPiRuntimeModule } from "@zigai/pi-extension-internals";
 
 export type TreeSelectorModule = {
     TreeSelectorComponent: new (
@@ -23,7 +23,7 @@ export type ThemeModule = {
 };
 
 export async function loadTreeInternals(): Promise<[TreeSelectorModule, ThemeModule] | undefined> {
-    const treeSelectorModule = await loadPiInternalModule(
+    const treeSelectorModule = await loadPiRuntimeModule(
         "modes/interactive/components/tree-selector.js",
         {
             scope: "pi-tree",
@@ -44,7 +44,7 @@ export async function loadTreeInternals(): Promise<[TreeSelectorModule, ThemeMod
     );
     if (treeSelectorModule === undefined) return undefined;
 
-    const themeModule = await loadPiInternalModule("modes/interactive/theme/theme.js", {
+    const themeModule = await loadPiRuntimeModule("modes/interactive/theme/theme.js", {
         scope: "pi-tree",
         feature: "tree selector patch",
         parse(module: unknown): ThemeModule | undefined {

packages/pi-tree/test/internal-imports.test.ts

@@ -0,0 +1,111 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { expect, onTestFinished, test } from "vitest";
+
+import { loadTreeInternals } from "../src/internal-imports.ts";
+
+type TreeRuntimeModule = {
+    readonly TreeSelectorComponent: object;
+};
+
+function isTreeRuntimeModule(value: unknown): value is TreeRuntimeModule {
+    return (
+        typeof value === "object" &&
+        value !== null &&
+        "TreeSelectorComponent" in value &&
+        typeof value.TreeSelectorComponent === "function"
+    );
+}
+
+const treeRuntimeParser = {
+    parse(value: unknown): TreeRuntimeModule {
+        if (!isTreeRuntimeModule(value)) {
+            throw new Error("fixture module must export its tree constructor");
+        }
+        return value;
+    },
+};
+
+test.each(["bundled", "modular"])(
+    "loads the tree constructor used by a %s Pi runtime",
+    async (runtime) => {
+        const fixtureRoot = await mkdtemp(join(tmpdir(), "pi-tree-runtime-"));
+        const packageDirectory = join(
+            fixtureRoot,
+            "node_modules",
+            "@earendil-works",
+            "pi-coding-agent",
+        );
+        const distDirectory = join(packageDirectory, "dist");
+        const componentDirectory = join(distDirectory, "modes", "interactive", "components");
+        const themeDirectory = join(distDirectory, "modes", "interactive", "theme");
+        const bundleDirectory = join(distDirectory, "bundle");
+        const originalEntrypoint = process.argv[1];
+        const originalPiFlag = process.env.PI_CODING_AGENT;
+        const originalPackageDirectory = process.env.PI_PACKAGE_DIR;
+        onTestFinished(async () => {
+            process.argv[1] = originalEntrypoint;
+            if (originalPiFlag === undefined) {
+                delete process.env.PI_CODING_AGENT;
+            } else {
+                process.env.PI_CODING_AGENT = originalPiFlag;
+            }
+            if (originalPackageDirectory === undefined) {
+                delete process.env.PI_PACKAGE_DIR;
+            } else {
+                process.env.PI_PACKAGE_DIR = originalPackageDirectory;
+            }
+            await rm(fixtureRoot, { recursive: true, force: true });
+        });
+
+        for (const directory of [componentDirectory, themeDirectory, bundleDirectory]) {
+            await mkdir(directory, { recursive: true });
+        }
+        await writeFile(
+            join(packageDirectory, "package.json"),
+            '{"name":"@earendil-works/pi-coding-agent","type":"module"}\n',
+        );
+        const modularSelectorPath = join(componentDirectory, "tree-selector.js");
+        const selectorSource = "export class TreeSelectorComponent {}\n";
+        await writeFile(modularSelectorPath, selectorSource);
+        await writeFile(
+            join(themeDirectory, "theme.js"),
+            "export function initTheme() {}\nexport const theme = {};\n",
+        );
+
+        let entrypointPath = join(distDirectory, "cli.js");
+        if (runtime === "bundled") {
+            entrypointPath = join(bundleDirectory, "cli.js");
+            await writeFile(join(bundleDirectory, "chunk-tree.js"), selectorSource);
+            await writeFile(
+                entrypointPath,
+                'export { TreeSelectorComponent } from "./chunk-tree.js";\n',
+            );
+        } else {
+            await writeFile(
+                entrypointPath,
+                'export { TreeSelectorComponent } from "./modes/interactive/components/tree-selector.js";\n',
+            );
+        }
+        process.argv[1] = entrypointPath;
+        process.env.PI_CODING_AGENT = "true";
+        delete process.env.PI_PACKAGE_DIR;
+
+        // Import the host entrypoint independently: matching export shapes alone would
+        // also accept the unused modular class and miss the original regression.
+        const host = treeRuntimeParser.parse(await import(pathToFileURL(entrypointPath).href));
+        const internals = await loadTreeInternals();
+        expect(internals).toBeDefined();
+        expect(internals?.[0].TreeSelectorComponent).toBe(host.TreeSelectorComponent);
+        expect(internals?.[1].theme).toEqual({});
+
+        if (runtime === "bundled") {
+            const modular = treeRuntimeParser.parse(
+                await import(pathToFileURL(modularSelectorPath).href),
+            );
+            expect(internals?.[0].TreeSelectorComponent).not.toBe(modular.TreeSelectorComponent);
+        }
+    },
+);