@nathapp/nax 0.28.0 → 0.29.0

package/test/integration/plugins/config-integration.test.ts

@@ -1,173 +0,0 @@
-// RE-ARCH: keep
-/**
- * End-to-end plugin config integration test
- *
- * Demonstrates US-007 working in a realistic scenario with:
- * - A project with nax/config.json
- * - Relative plugin paths
- * - Plugin-specific config passed to setup()
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { loadPlugins } from "../../../src/plugins/loader";
-
-async function createTempDir(): Promise<string> {
-  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-integration-test-"));
-  return tmpDir;
-}
-
-async function cleanupTempDir(dir: string): Promise<void> {
-  try {
-    await fs.rm(dir, { recursive: true, force: true });
-  } catch {
-    // Ignore
-  }
-}
-
-describe("Plugin config integration (US-007)", () => {
-  let projectRoot: string;
-
-  beforeEach(async () => {
-    projectRoot = await createTempDir();
-  });
-
-  afterEach(async () => {
-    await cleanupTempDir(projectRoot);
-  });
-
-  test("realistic scenario: project with relative plugin paths in config", async () => {
-    // Setup project structure:
-    // project/
-    //   nax/
-    //     (no plugins/ directory to avoid auto-discovery)
-    //   custom-plugins/
-    //     external-plugin.ts
-    //     local-plugin.ts
-
-    const naxDir = path.join(projectRoot, "nax");
-    const customPluginsDir = path.join(projectRoot, "custom-plugins");
-
-    await fs.mkdir(naxDir, { recursive: true });
-    await fs.mkdir(customPluginsDir, { recursive: true });
-
-    // Create a config file to track which plugins were initialized
-    const configTracker = path.join(projectRoot, "plugin-init-tracker.json");
-
-    // Create local plugin (in custom-plugins/)
-    const localPluginCode = `
-export default {
-  name: "local-plugin",
-  version: "1.0.0",
-  provides: ["optimizer"],
-  async setup(config) {
-    const fs = await import("node:fs/promises");
-    const path = await import("node:path");
-    const trackerPath = "${configTracker}";
-
-    let tracker = {};
-    try {
-      tracker = JSON.parse(await fs.readFile(trackerPath, "utf-8"));
-    } catch {}
-
-    tracker["local-plugin"] = config;
-    await fs.writeFile(trackerPath, JSON.stringify(tracker, null, 2), "utf-8");
-  },
-  extensions: {
-    optimizer: {
-      name: "local",
-      async optimize(input) {
-        return {
-          optimizedPrompt: input.prompt,
-          estimatedTokens: input.estimatedTokens,
-          tokensSaved: 0,
-          appliedStrategies: []
-        };
-      }
-    }
-  }
-};
-`;
-    await fs.writeFile(path.join(customPluginsDir, "local-plugin.ts"), localPluginCode, "utf-8");
-
-    // Create external plugin (in custom-plugins/)
-    const externalPluginCode = `
-export default {
-  name: "external-plugin",
-  version: "2.0.0",
-  provides: ["optimizer"],
-  async setup(config) {
-    const fs = await import("node:fs/promises");
-    const path = await import("node:path");
-    const trackerPath = "${configTracker}";
-
-    let tracker = {};
-    try {
-      tracker = JSON.parse(await fs.readFile(trackerPath, "utf-8"));
-    } catch {}
-
-    tracker["external-plugin"] = config;
-    await fs.writeFile(trackerPath, JSON.stringify(tracker, null, 2), "utf-8");
-  },
-  extensions: {
-    optimizer: {
-      name: "external",
-      async optimize(input) {
-        return {
-          optimizedPrompt: input.prompt,
-          estimatedTokens: input.estimatedTokens,
-          tokensSaved: 0,
-          appliedStrategies: []
-        };
-      }
-    }
-  }
-};
-`;
-    await fs.writeFile(path.join(customPluginsDir, "external-plugin.ts"), externalPluginCode, "utf-8");
-
-    // Simulate config.json plugins array
-    const configPlugins = [
-      {
-        // Relative path to custom plugins directory
-        module: "./custom-plugins/external-plugin.ts",
-        config: {
-          apiKey: "test-key-123",
-          timeout: 5000,
-        },
-      },
-      {
-        // Another relative path to custom plugins directory
-        module: "./custom-plugins/local-plugin.ts",
-        config: {
-          enabled: true,
-          level: "debug",
-        },
-      },
-    ];
-
-    // Load plugins as the runner would
-    const globalPluginsDir = path.join(projectRoot, ".nax", "plugins");
-    const projectPluginsDir = path.join(projectRoot, "nax", "plugins");
-
-    const registry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, projectRoot);
-
-    // Verify both plugins loaded
-    expect(registry.plugins).toHaveLength(2);
-    const pluginNames = registry.plugins.map((p) => p.name).sort();
-    expect(pluginNames).toEqual(["external-plugin", "local-plugin"]);
-
-    // Verify configs were passed to setup()
-    const tracker = JSON.parse(await fs.readFile(configTracker, "utf-8"));
-    expect(tracker["external-plugin"]).toEqual({
-      apiKey: "test-key-123",
-      timeout: 5000,
-    });
-    expect(tracker["local-plugin"]).toEqual({
-      enabled: true,
-      level: "debug",
-    });
-  });
-});

package/test/integration/plugins/config-resolution.test.ts

@@ -1,523 +0,0 @@
-// RE-ARCH: keep
-/**
- * Plugin config path resolution tests
- *
- * Validates US-007 acceptance criteria:
- * 1. plugins[] from config.json are passed to loadPlugins() as configPlugins parameter
- * 2. Relative module paths in plugins[].module are resolved relative to project root
- * 3. Absolute module paths and npm package names work as-is
- * 4. If a plugin module cannot be found, a clear error message is logged with the path tried
- * 5. Plugin-specific config (plugins[].config) is passed to the plugin's setup() function
- */
-
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { loadPlugins, _setPluginErrorSink, _resetPluginErrorSink } from "../../../src/plugins/loader";
-import type { PluginConfigEntry } from "../../../src/plugins/types";
-import type { NaxPlugin } from "../../../src/plugins/types";
-
-// Test fixture helpers
-async function createTempDir(): Promise<string> {
-  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "nax-plugin-config-test-"));
-  return tmpDir;
-}
-
-async function cleanupTempDir(dir: string): Promise<void> {
-  try {
-    await fs.rm(dir, { recursive: true, force: true });
-  } catch {
-    // Ignore cleanup errors
-  }
-}
-
-async function writePluginFile(filePath: string, plugin: NaxPlugin, setupFn?: string): Promise<void> {
-  let extensionsCode = "";
-
-  if (plugin.extensions.optimizer) {
-    extensionsCode += `
-    optimizer: {
-      name: "${plugin.extensions.optimizer.name}",
-      async optimize(input) {
-        return {
-          optimizedPrompt: input.prompt,
-          estimatedTokens: input.estimatedTokens,
-          tokensSaved: 0,
-          appliedStrategies: []
-        };
-      }
-    },`;
-  }
-
-  const setupCode = setupFn || (plugin.setup ? "async setup(config) { }," : "");
-  const teardownCode = plugin.teardown ? "async teardown() { }," : "";
-
-  const pluginCode = `
-export default {
-  name: "${plugin.name}",
-  version: "${plugin.version}",
-  provides: ${JSON.stringify(plugin.provides)},
-  ${setupCode}
-  ${teardownCode}
-  extensions: {${extensionsCode}
-  }
-};
-`;
-  await fs.writeFile(filePath, pluginCode, "utf-8");
-}
-
-describe("Plugin config path resolution (US-007)", () => {
-  let tempDir: string;
-
-  beforeEach(async () => {
-    tempDir = await createTempDir();
-  });
-
-  afterEach(async () => {
-    await cleanupTempDir(tempDir);
-  });
-
-  describe("AC1: plugins[] from config.json passed to loadPlugins", () => {
-    test("loads plugins from config array", async () => {
-      const pluginDir = path.join(tempDir, "plugins");
-      await fs.mkdir(pluginDir, { recursive: true });
-
-      const plugin: NaxPlugin = {
-        name: "config-plugin",
-        version: "1.0.0",
-        provides: ["optimizer"],
-        extensions: {
-          optimizer: {
-            name: "test",
-            async optimize(input) {
-              return {
-                optimizedPrompt: input.prompt,
-                estimatedTokens: input.estimatedTokens,
-                tokensSaved: 0,
-                appliedStrategies: [],
-              };
-            },
-          },
-        },
-      };
-
-      await writePluginFile(path.join(pluginDir, "plugin.ts"), plugin);
-
-      const configPlugins: PluginConfigEntry[] = [
-        {
-          module: path.join(pluginDir, "plugin.ts"),
-          config: {},
-        },
-      ];
-
-      const registry = await loadPlugins(
-        path.join(tempDir, "nonexistent-global"),
-        path.join(tempDir, "nonexistent-project"),
-        configPlugins,
-        tempDir,
-      );
-
-      expect(registry.plugins).toHaveLength(1);
-      expect(registry.plugins[0].name).toBe("config-plugin");
-    });
-
-    test("loads multiple plugins from config array", async () => {
-      const plugin1Dir = path.join(tempDir, "plugin1");
-      const plugin2Dir = path.join(tempDir, "plugin2");
-      await fs.mkdir(plugin1Dir, { recursive: true });
-      await fs.mkdir(plugin2Dir, { recursive: true });
-
-      const plugin1: NaxPlugin = {
-        name: "plugin-one",
-        version: "1.0.0",
-        provides: ["optimizer"],
-        extensions: {
-          optimizer: {
-            name: "test",
-            async optimize(input) {
-              return {
-                optimizedPrompt: input.prompt,
-                estimatedTokens: input.estimatedTokens,
-                tokensSaved: 0,
-                appliedStrategies: [],
-              };
-            },
-          },
-        },
-      };
-
-      const plugin2: NaxPlugin = {
-        name: "plugin-two",
-        version: "2.0.0",
-        provides: ["optimizer"],
-        extensions: {
-          optimizer: {
-            name: "test",
-            async optimize(input) {
-              return {
-                optimizedPrompt: input.prompt,
-                estimatedTokens: input.estimatedTokens,
-                tokensSaved: 0,
-                appliedStrategies: [],
-              };
-            },
-          },
-        },
-      };
-
-      await writePluginFile(path.join(plugin1Dir, "index.ts"), plugin1);
-      await writePluginFile(path.join(plugin2Dir, "index.ts"), plugin2);
-
-      const configPlugins: PluginConfigEntry[] = [
-        { module: path.join(plugin1Dir, "index.ts"), config: {} },
-        { module: path.join(plugin2Dir, "index.ts"), config: {} },
-      ];
-
-      const registry = await loadPlugins(
-        path.join(tempDir, "nonexistent-global"),
-        path.join(tempDir, "nonexistent-project"),
-        configPlugins,
-        tempDir,
-      );
-
-      expect(registry.plugins).toHaveLength(2);
-      expect(registry.plugins[0].name).toBe("plugin-one");
-      expect(registry.plugins[1].name).toBe("plugin-two");
-    });
-  });
-
-  describe("AC2: Relative module paths resolved relative to project root", () => {
-    test("resolves ./relative/path from project root", async () => {
-      const pluginDir = path.join(tempDir, "custom-plugins");
-      await fs.mkdir(pluginDir, { recursive: true });
-
-      const plugin: NaxPlugin = {
-        name: "relative-plugin",
-        version: "1.0.0",
-        provides: ["optimizer"],
-        extensions: {
-          optimizer: {
-            name: "test",
-            async optimize(input) {
-              return {
-                optimizedPrompt: input.prompt,
-                estimatedTokens: input.estimatedTokens,
-                tokensSaved: 0,
-                appliedStrategies: [],
-              };
-            },
-          },
-        },
-      };
-
-      await writePluginFile(path.join(pluginDir, "my-plugin.ts"), plugin);
-
-      const configPlugins: PluginConfigEntry[] = [
-        {
-          module: "./custom-plugins/my-plugin.ts",
-          config: {},
-        },
-      ];
-
-      const registry = await loadPlugins(
-        path.join(tempDir, "nonexistent-global"),
-        path.join(tempDir, "nonexistent-project"),
-        configPlugins,
-        tempDir,
-      );
-
-      expect(registry.plugins).toHaveLength(1);
-      expect(registry.plugins[0].name).toBe("relative-plugin");
-    });
-
-    test("blocks ../ traversal outside project root (SEC-1/SEC-2)", async () => {
-      const projectRoot = path.join(tempDir, "project");
-      const pluginDir = path.join(tempDir, "shared-plugins");
-      await fs.mkdir(projectRoot, { recursive: true });
-      await fs.mkdir(pluginDir, { recursive: true });
-
-      const plugin: NaxPlugin = {
-        name: "parent-relative-plugin",
-        version: "1.0.0",
-        provides: ["optimizer"],
-        extensions: {
-          optimizer: {
-            name: "test",
-            async optimize(input) {
-              return {
-                optimizedPrompt: input.prompt,
-                estimatedTokens: input.estimatedTokens,
-                tokensSaved: 0,
-                appliedStrategies: [],
-              };
-            },
-          },
-        },
-      };
-
-      await writePluginFile(path.join(pluginDir, "plugin.ts"), plugin);
-
-      const configPlugins: PluginConfigEntry[] = [
-        {
-          module: "../shared-plugins/plugin.ts",
-          config: {},
-        },
-      ];
-
-      const registry = await loadPlugins(
-        path.join(tempDir, "nonexistent-global"),
-        path.join(tempDir, "nonexistent-project"),
-        configPlugins,
-        projectRoot,
-      );
-
-      // SEC-1/SEC-2: traversal outside project root is blocked
-      expect(registry.plugins).toHaveLength(0);
-    });
-  });
-
-  describe("AC3: Absolute paths and npm packages work as-is", () => {
-    test("loads plugin with absolute path", async () => {
-      const pluginDir = path.join(tempDir, "absolute-test");
-      await fs.mkdir(pluginDir, { recursive: true });
-
-      const plugin: NaxPlugin = {
-        name: "absolute-plugin",
-        version: "1.0.0",
-        provides: ["optimizer"],
-        extensions: {
-          optimizer: {
-            name: "test",
-            async optimize(input) {
-              return {
-                optimizedPrompt: input.prompt,
-                estimatedTokens: input.estimatedTokens,
-                tokensSaved: 0,
-                appliedStrategies: [],
-              };
-            },
-          },
-        },
-      };
-
-      const absolutePath = path.join(pluginDir, "plugin.ts");
-      await writePluginFile(absolutePath, plugin);
-
-      const configPlugins: PluginConfigEntry[] = [
-        {
-          module: absolutePath,
-          config: {},
-        },
-      ];
-
-      const registry = await loadPlugins(
-        path.join(tempDir, "nonexistent-global"),
-        path.join(tempDir, "nonexistent-project"),
-        configPlugins,
-        tempDir,
-      );
-
-      expect(registry.plugins).toHaveLength(1);
-      expect(registry.plugins[0].name).toBe("absolute-plugin");
-    });
-
-    test("treats non-relative paths as npm packages (doesn't crash)", async () => {
-      // This test verifies that npm package names (no ./ or ../) are passed through as-is
-      // They will fail to load since we don't have real npm packages, but shouldn't crash
-      const configPlugins: PluginConfigEntry[] = [
-        {
-          module: "nonexistent-npm-package",
-          config: {},
-        },
-      ];
-
-      const registry = await loadPlugins(
-        path.join(tempDir, "nonexistent-global"),
-        path.join(tempDir, "nonexistent-project"),
-        configPlugins,
-        tempDir,
-      );
-
-      // Should return empty registry since package doesn't exist
-      expect(registry.plugins).toHaveLength(0);
-    });
-  });
-
-  describe("AC4: Clear error message when plugin module not found", () => {
-    test("logs helpful error for missing relative path", async () => {
-      const errorLogs: string[] = [];
-      _setPluginErrorSink((...args: unknown[]) => {
-        errorLogs.push(args.map((arg) => String(arg)).join(" "));
-      });
-
-      try {
-        const configPlugins: PluginConfigEntry[] = [
-          {
-            module: "./nonexistent/plugin.ts",
-            config: {},
-          },
-        ];
-
-        await loadPlugins(
-          path.join(tempDir, "nonexistent-global"),
-          path.join(tempDir, "nonexistent-project"),
-          configPlugins,
-          tempDir,
-        );
-
-        // Should log error with original path
-        const errorOutput = errorLogs.join("\n");
-        expect(errorOutput).toContain("Failed to load plugin module");
-        expect(errorOutput).toContain("./nonexistent/plugin.ts");
-        expect(errorOutput).toContain("Attempted path:");
-        expect(errorOutput).toContain(path.join(tempDir, "nonexistent/plugin.ts"));
-      } finally {
-        _resetPluginErrorSink();
-      }
-    });
-
-    test("logs helpful error for missing absolute path", async () => {
-      const errorLogs: string[] = [];
-      _setPluginErrorSink((...args: unknown[]) => {
-        errorLogs.push(args.map((arg) => String(arg)).join(" "));
-      });
-
-      try {
-        const absolutePath = path.join(tempDir, "missing-plugin.ts");
-        const configPlugins: PluginConfigEntry[] = [
-          {
-            module: absolutePath,
-            config: {},
-          },
-        ];
-
-        await loadPlugins(
-          path.join(tempDir, "nonexistent-global"),
-          path.join(tempDir, "nonexistent-project"),
-          configPlugins,
-          tempDir,
-        );
-
-        const errorOutput = errorLogs.join("\n");
-        expect(errorOutput).toContain("Failed to load plugin module");
-        expect(errorOutput).toContain(absolutePath);
-      } finally {
-        _resetPluginErrorSink();
-      }
-    });
-  });
-
-  describe("AC5: Plugin-specific config passed to setup()", () => {
-    test("passes config object to plugin setup function", async () => {
-      const pluginDir = path.join(tempDir, "config-test");
-      await fs.mkdir(pluginDir, { recursive: true });
-
-      // Create a plugin that writes received config to a file we can check
-      const configFile = path.join(tempDir, "received-config.json");
-      const plugin: NaxPlugin = {
-        name: "config-receiver",
-        version: "1.0.0",
-        provides: ["optimizer"],
-        extensions: {
-          optimizer: {
-            name: "test",
-            async optimize(input) {
-              return {
-                optimizedPrompt: input.prompt,
-                estimatedTokens: input.estimatedTokens,
-                tokensSaved: 0,
-                appliedStrategies: [],
-              };
-            },
-          },
-        },
-      };
-
-      const setupFn = `
-  async setup(config) {
-    const fs = await import("node:fs/promises");
-    await fs.writeFile("${configFile}", JSON.stringify(config), "utf-8");
-  },`;
-
-      await writePluginFile(path.join(pluginDir, "plugin.ts"), plugin, setupFn);
-
-      const pluginConfig = {
-        apiKey: "test-key-123",
-        enabled: true,
-        options: {
-          timeout: 5000,
-        },
-      };
-
-      const configPlugins: PluginConfigEntry[] = [
-        {
-          module: path.join(pluginDir, "plugin.ts"),
-          config: pluginConfig,
-        },
-      ];
-
-      await loadPlugins(
-        path.join(tempDir, "nonexistent-global"),
-        path.join(tempDir, "nonexistent-project"),
-        configPlugins,
-        tempDir,
-      );
-
-      // Verify config was written
-      const receivedConfig = JSON.parse(await fs.readFile(configFile, "utf-8"));
-      expect(receivedConfig).toEqual(pluginConfig);
-    });
-
-    test("passes empty config object when config is undefined", async () => {
-      const pluginDir = path.join(tempDir, "empty-config-test");
-      await fs.mkdir(pluginDir, { recursive: true });
-
-      const configFile = path.join(tempDir, "empty-config.json");
-      const plugin: NaxPlugin = {
-        name: "empty-config-receiver",
-        version: "1.0.0",
-        provides: ["optimizer"],
-        extensions: {
-          optimizer: {
-            name: "test",
-            async optimize(input) {
-              return {
-                optimizedPrompt: input.prompt,
-                estimatedTokens: input.estimatedTokens,
-                tokensSaved: 0,
-                appliedStrategies: [],
-              };
-            },
-          },
-        },
-      };
-
-      const setupFn = `
-  async setup(config) {
-    const fs = await import("node:fs/promises");
-    await fs.writeFile("${configFile}", JSON.stringify(config), "utf-8");
-  },`;
-
-      await writePluginFile(path.join(pluginDir, "plugin.ts"), plugin, setupFn);
-
-      const configPlugins: PluginConfigEntry[] = [
-        {
-          module: path.join(pluginDir, "plugin.ts"),
-          // config is undefined
-        },
-      ];
-
-      await loadPlugins(
-        path.join(tempDir, "nonexistent-global"),
-        path.join(tempDir, "nonexistent-project"),
-        configPlugins,
-        tempDir,
-      );
-
-      // Verify empty config was passed
-      const receivedConfig = JSON.parse(await fs.readFile(configFile, "utf-8"));
-      expect(receivedConfig).toEqual({});
-    });
-  });
-});