@sundaeswap/sprinkles 0.6.0 → 0.7.0

package/dist/cjs/Sprinkle/__tests__/action-integration.test.js

@@ -0,0 +1,590 @@
+"use strict";
+
+var _bunTest = require("bun:test");
+var fs = _interopRequireWildcard(require("fs"));
+var path = _interopRequireWildcard(require("path"));
+var os = _interopRequireWildcard(require("os"));
+var _typebox = require("@sinclair/typebox");
+var _index = require("../index.js");
+var _testHelpers = require("./test-helpers.js");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+// Helper: write a minimal profile file into a tmp storage directory
+function writeTestProfile(storagePath, id, name, settings) {
+  const dir = path.join(storagePath, "profiles");
+  fs.mkdirSync(dir, {
+    recursive: true
+  });
+  const meta = {
+    name,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  fs.writeFileSync(path.join(dir, `${id}.json`), JSON.stringify({
+    meta,
+    settings,
+    defaults: {}
+  }, null, 2), "utf-8");
+}
+
+// Simple settings schema used for integration tests
+const TestSchema = _typebox.Type.Object({
+  name: _typebox.Type.String()
+});
+
+// A reusable valid action
+const greetAction = {
+  name: "greet",
+  description: "Greets someone",
+  inputSchema: _typebox.Type.Object({
+    who: _typebox.Type.String()
+  }),
+  outputSchema: _typebox.Type.Object({
+    greeting: _typebox.Type.String()
+  }),
+  execute: async input => ({
+    greeting: `Hello, ${input.who}!`
+  })
+};
+(0, _bunTest.describe)("Sprinkle action integration", () => {
+  let tmpDir;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-action-test-"));
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // actionRegistry field
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("Sprinkle constructor initialises actionRegistry", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    (0, _bunTest.expect)(sprinkle.actionRegistry).toBeInstanceOf(_index.ActionRegistry);
+  });
+
+  // -------------------------------------------------------------------------
+  // registerAction / getAction / listActions
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("registerAction stores an action retrievable via getAction", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    sprinkle.registerAction(greetAction);
+    (0, _bunTest.expect)(sprinkle.getAction("greet")).toBe(greetAction);
+  });
+  (0, _bunTest.test)("listActions returns all registered actions", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    const actionB = {
+      ...greetAction,
+      name: "farewell"
+    };
+    sprinkle.registerAction(greetAction);
+    sprinkle.registerAction(actionB);
+    (0, _bunTest.expect)(sprinkle.listActions()).toHaveLength(2);
+  });
+  (0, _bunTest.test)("listActions returns empty array when no actions registered", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    (0, _bunTest.expect)(sprinkle.listActions()).toEqual([]);
+  });
+  (0, _bunTest.test)("getAction returns undefined for unknown action", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    (0, _bunTest.expect)(sprinkle.getAction("does-not-exist")).toBeUndefined();
+  });
+  (0, _bunTest.test)("registerAction throws for duplicate name", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    sprinkle.registerAction(greetAction);
+    (0, _bunTest.expect)(() => sprinkle.registerAction(greetAction)).toThrow(/already registered/);
+  });
+  (0, _bunTest.test)("registerAction throws for non-kebab-case name", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    (0, _bunTest.expect)(() => sprinkle.registerAction({
+      ...greetAction,
+      name: "BadName"
+    })).toThrow(/Invalid action name/);
+  });
+
+  // -------------------------------------------------------------------------
+  // runAction
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("runAction executes action and returns success result", async () => {
+    const sprinkle = (0, _testHelpers.withProfile)(new _index.Sprinkle(TestSchema, tmpDir));
+    sprinkle.settings = {
+      name: "tester"
+    };
+    sprinkle.registerAction(greetAction);
+    const result = await sprinkle.runAction("greet", {
+      who: "World"
+    });
+    (0, _bunTest.expect)(result.success).toBe(true);
+    if (result.success) {
+      (0, _bunTest.expect)(result.data).toEqual({
+        greeting: "Hello, World!"
+      });
+    }
+  });
+  (0, _bunTest.test)("runAction returns failure result on invalid input", async () => {
+    const sprinkle = (0, _testHelpers.withProfile)(new _index.Sprinkle(TestSchema, tmpDir));
+    sprinkle.settings = {
+      name: "tester"
+    };
+    sprinkle.registerAction(greetAction);
+
+    // 'who' field is missing
+    const result = await sprinkle.runAction("greet", {
+      wrongField: "oops"
+    });
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error.code).toBe("VALIDATION_ERROR");
+    }
+  });
+  (0, _bunTest.test)("runAction throws when action name is not registered", async () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    await (0, _bunTest.expect)(sprinkle.runAction("not-registered", {})).rejects.toThrow(/not registered/);
+  });
+  (0, _bunTest.test)("runAction error message lists available actions when none registered", async () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    await (0, _bunTest.expect)(sprinkle.runAction("nope", {})).rejects.toThrow(/\(none\)/);
+  });
+  (0, _bunTest.test)("runAction error message lists registered action names", async () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    sprinkle.registerAction(greetAction);
+    await (0, _bunTest.expect)(sprinkle.runAction("nope", {})).rejects.toThrow(/greet/);
+  });
+  (0, _bunTest.test)("runAction provides sprinkle and settings via context", async () => {
+    let capturedContext;
+    const ctxAction = {
+      name: "ctx-test",
+      description: "Captures context",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async (_input, ctx) => {
+        capturedContext = ctx;
+        return {};
+      }
+    };
+    const sprinkle = (0, _testHelpers.withProfile)(new _index.Sprinkle(TestSchema, tmpDir));
+    sprinkle.settings = {
+      name: "ctx-user"
+    };
+    sprinkle.registerAction(ctxAction);
+    await sprinkle.runAction("ctx-test", {});
+    (0, _bunTest.expect)(capturedContext.sprinkle).toBe(sprinkle);
+    (0, _bunTest.expect)(capturedContext.settings).toEqual({
+      name: "ctx-user"
+    });
+  });
+  (0, _bunTest.test)("runAction propagates ActionError from execute without re-wrapping", async () => {
+    const myError = new _index.ActionError("deliberate failure", "DELIBERATE", {
+      detail: 42
+    });
+    const failAction = {
+      name: "fail-action",
+      description: "Always fails",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({}),
+      execute: async () => {
+        throw myError;
+      }
+    };
+    const sprinkle = (0, _testHelpers.withProfile)(new _index.Sprinkle(TestSchema, tmpDir));
+    sprinkle.settings = {
+      name: "x"
+    };
+    sprinkle.registerAction(failAction);
+    const result = await sprinkle.runAction("fail-action", {});
+    (0, _bunTest.expect)(result.success).toBe(false);
+    if (!result.success) {
+      (0, _bunTest.expect)(result.error).toBe(myError);
+    }
+  });
+
+  // -------------------------------------------------------------------------
+  // Re-exports from index
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("ActionRegistry is re-exported from Sprinkle index", () => {
+    (0, _bunTest.expect)(_index.ActionRegistry).toBeDefined();
+  });
+  (0, _bunTest.test)("ActionError is re-exported from Sprinkle index", () => {
+    (0, _bunTest.expect)(_index.ActionError).toBeDefined();
+  });
+
+  // -------------------------------------------------------------------------
+  // listActionsByCategory
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("listActionsByCategory returns empty map when no actions registered", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    const map = sprinkle.listActionsByCategory();
+    (0, _bunTest.expect)(map.size).toBe(0);
+  });
+  (0, _bunTest.test)("listActionsByCategory places uncategorised actions under 'default'", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    sprinkle.registerAction(greetAction); // no category field
+    const map = sprinkle.listActionsByCategory();
+    (0, _bunTest.expect)(map.has("default")).toBe(true);
+    (0, _bunTest.expect)(map.get("default")).toHaveLength(1);
+    (0, _bunTest.expect)(map.get("default")[0].name).toBe("greet");
+  });
+  (0, _bunTest.test)("listActionsByCategory groups categorised actions correctly", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    const alpha1 = {
+      ...greetAction,
+      name: "alpha-one",
+      category: "alpha"
+    };
+    const alpha2 = {
+      ...greetAction,
+      name: "alpha-two",
+      category: "alpha"
+    };
+    const beta1 = {
+      ...greetAction,
+      name: "beta-one",
+      category: "beta"
+    };
+    sprinkle.registerAction(alpha1);
+    sprinkle.registerAction(alpha2);
+    sprinkle.registerAction(beta1);
+    const map = sprinkle.listActionsByCategory();
+    (0, _bunTest.expect)(map.get("alpha")).toHaveLength(2);
+    (0, _bunTest.expect)(map.get("beta")).toHaveLength(1);
+    (0, _bunTest.expect)(map.has("default")).toBe(false);
+  });
+  (0, _bunTest.test)("listActionsByCategory mixes categorised and uncategorised actions", () => {
+    const sprinkle = new _index.Sprinkle(TestSchema, tmpDir);
+    const categorised = {
+      ...greetAction,
+      name: "cat-action",
+      category: "tools"
+    };
+    sprinkle.registerAction(greetAction); // uncategorised
+    sprinkle.registerAction(categorised);
+    const map = sprinkle.listActionsByCategory();
+    (0, _bunTest.expect)(map.get("default")).toHaveLength(1);
+    (0, _bunTest.expect)(map.get("tools")).toHaveLength(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Sprinkle.run() static entry point
+// ---------------------------------------------------------------------------
+
+(0, _bunTest.describe)("Sprinkle.run() static entry point", () => {
+  let tmpDir;
+  let logSpy;
+  let errorSpy;
+  let exitSpy;
+  (0, _bunTest.beforeEach)(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sprinkles-run-test-"));
+    logSpy = (0, _bunTest.spyOn)(console, "log").mockImplementation(() => {});
+    errorSpy = (0, _bunTest.spyOn)(console, "error").mockImplementation(() => {});
+    exitSpy = (0, _bunTest.spyOn)(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit called");
+    });
+  });
+  (0, _bunTest.afterEach)(() => {
+    fs.rmSync(tmpDir, {
+      recursive: true,
+      force: true
+    });
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  // -------------------------------------------------------------------------
+  // help mode
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("help mode prints 'No actions registered.' when no actions provided", async () => {
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      argv: ["--help"]
+    });
+    const output = logSpy.mock.calls.map(c => String(c[0])).join("\n");
+    (0, _bunTest.expect)(output).toContain("No actions registered.");
+  });
+  (0, _bunTest.test)("help mode prints 'Available actions:' header when actions are registered", async () => {
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [greetAction],
+      argv: ["--help"]
+    });
+    const output = logSpy.mock.calls.map(c => String(c[0])).join("\n");
+    (0, _bunTest.expect)(output).toContain("Available actions:");
+  });
+  (0, _bunTest.test)("help mode lists registered action name and description", async () => {
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [greetAction],
+      argv: ["--help"]
+    });
+    const output = logSpy.mock.calls.map(c => String(c[0])).join("\n");
+    (0, _bunTest.expect)(output).toContain("greet");
+    (0, _bunTest.expect)(output).toContain("Greets someone");
+  });
+  (0, _bunTest.test)("help mode prints category header for categorised actions", async () => {
+    const catAction = {
+      ...greetAction,
+      name: "do-thing",
+      category: "tools"
+    };
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [catAction],
+      argv: ["--help"]
+    });
+    const output = logSpy.mock.calls.map(c => String(c[0])).join("\n");
+    (0, _bunTest.expect)(output).toContain("tools:");
+  });
+  (0, _bunTest.test)("help mode does not print 'default:' header for uncategorised actions", async () => {
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [greetAction],
+      argv: ["--help"]
+    });
+    const output = logSpy.mock.calls.map(c => String(c[0])).join("\n");
+    (0, _bunTest.expect)(output).not.toContain("default:");
+  });
+  (0, _bunTest.test)("help mode also triggers with -h flag", async () => {
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      argv: ["-h"]
+    });
+    const output = logSpy.mock.calls.map(c => String(c[0])).join("\n");
+    (0, _bunTest.expect)(output).toContain("No actions registered.");
+  });
+
+  // -------------------------------------------------------------------------
+  // CLI mode
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("CLI mode executes action and writes JSON result to stdout", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "tester"
+    });
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [greetAction],
+      argv: ["greet", "--who", "World"]
+    });
+    const calls = logSpy.mock.calls.map(c => String(c[0]));
+    const jsonLine = calls.find(l => {
+      try {
+        JSON.parse(l);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    (0, _bunTest.expect)(jsonLine).toBeDefined();
+    const parsed = JSON.parse(jsonLine);
+    (0, _bunTest.expect)(parsed.success).toBe(true);
+    (0, _bunTest.expect)(parsed.data).toEqual({
+      greeting: "Hello, World!"
+    });
+  });
+  (0, _bunTest.test)("CLI mode result contains success:false for invalid input", async () => {
+    writeTestProfile(tmpDir, "default", "Default", {
+      name: "tester"
+    });
+    await (0, _bunTest.expect)(_index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [greetAction],
+      argv: ["greet"]
+    })).rejects.toThrow("process.exit called");
+    const calls = errorSpy.mock.calls.map(c => String(c[0]));
+    const jsonLine = calls.find(l => {
+      try {
+        JSON.parse(l);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    (0, _bunTest.expect)(jsonLine).toBeDefined();
+    const parsed = JSON.parse(jsonLine);
+    (0, _bunTest.expect)(parsed.success).toBe(false);
+    (0, _bunTest.expect)(parsed.error.code).toBe("VALIDATION_ERROR");
+    (0, _bunTest.expect)(exitSpy).toHaveBeenCalledWith(1);
+  });
+  (0, _bunTest.test)("CLI mode --profile flag selects the named profile", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    let capturedSettings;
+    const captureAction = {
+      name: "capture",
+      description: "Captures settings",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({
+        name: _typebox.Type.String()
+      }),
+      execute: async (_input, ctx) => {
+        capturedSettings = ctx.settings;
+        return {
+          name: ctx.settings.name
+        };
+      }
+    };
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [captureAction],
+      argv: ["capture", "--profile", "alice"]
+    });
+    (0, _bunTest.expect)(capturedSettings).toBeDefined();
+    (0, _bunTest.expect)(capturedSettings.name).toBe("alice");
+  });
+  (0, _bunTest.test)("CLI mode --profile flag selects the correct profile when multiple exist", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    const captureAction = {
+      name: "capture-two",
+      description: "Captures settings",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({
+        name: _typebox.Type.String()
+      }),
+      execute: async (_input, ctx) => ({
+        name: ctx.settings.name
+      })
+    };
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [captureAction],
+      argv: ["capture-two", "--profile", "bob"]
+    });
+    const calls = logSpy.mock.calls.map(c => String(c[0]));
+    const jsonLine = calls.find(l => {
+      try {
+        JSON.parse(l);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    const parsed = JSON.parse(jsonLine);
+    (0, _bunTest.expect)(parsed.success).toBe(true);
+    (0, _bunTest.expect)(parsed.data.name).toBe("bob");
+  });
+  (0, _bunTest.test)("CLI mode auto-selects the only profile when no --profile flag given", async () => {
+    writeTestProfile(tmpDir, "solo", "Solo", {
+      name: "solo-user"
+    });
+    const captureAction = {
+      name: "capture-auto",
+      description: "Captures settings",
+      inputSchema: _typebox.Type.Object({}),
+      outputSchema: _typebox.Type.Object({
+        name: _typebox.Type.String()
+      }),
+      execute: async (_input, ctx) => ({
+        name: ctx.settings.name
+      })
+    };
+    await _index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [captureAction],
+      argv: ["capture-auto"]
+    });
+    const calls = logSpy.mock.calls.map(c => String(c[0]));
+    const jsonLine = calls.find(l => {
+      try {
+        JSON.parse(l);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    const parsed = JSON.parse(jsonLine);
+    (0, _bunTest.expect)(parsed.success).toBe(true);
+    (0, _bunTest.expect)(parsed.data.name).toBe("solo-user");
+  });
+  (0, _bunTest.test)("CLI mode throws when multiple profiles exist and no --profile flag given", async () => {
+    writeTestProfile(tmpDir, "alice", "Alice", {
+      name: "alice"
+    });
+    writeTestProfile(tmpDir, "bob", "Bob", {
+      name: "bob"
+    });
+    await (0, _bunTest.expect)(_index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [greetAction],
+      argv: ["greet", "--who", "World"]
+    })).rejects.toThrow(/--profile/);
+  });
+  (0, _bunTest.test)("CLI mode throws when no profiles exist", async () => {
+    await (0, _bunTest.expect)(_index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      actions: [greetAction],
+      argv: ["greet", "--who", "World"]
+    })).rejects.toThrow(/No profiles found/);
+  });
+
+  // -------------------------------------------------------------------------
+  // TUI mode
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("TUI mode throws when no menu option is provided", async () => {
+    await (0, _bunTest.expect)(_index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      argv: []
+    })).rejects.toThrow(/TUI mode requires a menu/);
+  });
+  (0, _bunTest.test)("TUI mode throws when --interactive flag is passed without a menu", async () => {
+    await (0, _bunTest.expect)(_index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      argv: ["--interactive"]
+    })).rejects.toThrow(/TUI mode requires a menu/);
+  });
+
+  // -------------------------------------------------------------------------
+  // MCP mode
+  // -------------------------------------------------------------------------
+
+  (0, _bunTest.test)("MCP mode throws when SDK is not installed", async () => {
+    // MCP mode is implemented but requires the optional @modelcontextprotocol/sdk
+    // peer dependency. When the SDK is available (as in this dev environment),
+    // MCP mode will attempt to start a server. When the SDK is not installed,
+    // it should throw a clear error message with install instructions.
+    //
+    // In CI/dev with the SDK installed, MCP mode will attempt to connect to
+    // stdio transport. We test the error path by verifying the mode no longer
+    // throws "not yet implemented" -- specific MCP behavior is tested in
+    // mcp-adapter.test.ts.
+    await (0, _bunTest.expect)(_index.Sprinkle.run({
+      type: TestSchema,
+      storagePath: tmpDir,
+      argv: ["--mcp"]
+    })).rejects.not.toThrow(/not yet implemented/i);
+  });
+});
+//# sourceMappingURL=action-integration.test.js.map