@useatlas/create 0.0.1

package/templates/docker/src/lib/tools/__tests__/registry-actions.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it, afterEach, mock } from "bun:test";
+import { tool } from "ai";
+import { z } from "zod";
+
+// Mock the Salesforce tool so the registry module can be imported
+// without needing jsforce or a real Salesforce connection.
+const mockSfTool = tool({
+  description: "Mock querySalesforce",
+  inputSchema: z.object({ soql: z.string() }),
+  execute: async ({ soql }) => soql,
+});
+
+mock.module("@atlas/api/lib/tools/salesforce", () => ({
+  querySalesforce: mockSfTool,
+}));
+
+const { ToolRegistry } = await import("@atlas/api/lib/tools/registry");
+
+function makeTool(name: string) {
+  return tool({
+    description: `Test tool: ${name}`,
+    inputSchema: z.object({ input: z.string() }),
+    execute: async ({ input }) => input,
+  });
+}
+
+function makeAction(name: string, opts?: { requiredCredentials?: string[] }) {
+  return {
+    name,
+    description: `Action: ${name}`,
+    tool: tool({
+      description: name,
+      inputSchema: z.object({ input: z.string() }),
+      execute: async ({ input }) => input,
+    }),
+    actionType: `test:${name}`,
+    reversible: true,
+    defaultApproval: "manual" as const,
+    requiredCredentials: opts?.requiredCredentials ?? [],
+  };
+}
+
+describe("ToolRegistry — getActions", () => {
+  it("returns empty array when no actions registered", () => {
+    const registry = new ToolRegistry();
+    expect(registry.getActions()).toEqual([]);
+  });
+
+  it("returns only tools that are actions (have actionType field)", () => {
+    const registry = new ToolRegistry();
+    const action1 = makeAction("sendEmail");
+    const action2 = makeAction("createTicket");
+    registry.register(action1);
+    registry.register(action2);
+
+    const actions = registry.getActions();
+    expect(actions).toHaveLength(2);
+    expect(actions[0].name).toBe("sendEmail");
+    expect(actions[1].name).toBe("createTicket");
+  });
+
+  it("doesn't return regular tools (without actionType)", () => {
+    const registry = new ToolRegistry();
+    registry.register({ name: "explore", description: "Explore", tool: makeTool("explore") });
+    registry.register({ name: "executeSQL", description: "SQL", tool: makeTool("sql") });
+
+    const actions = registry.getActions();
+    expect(actions).toEqual([]);
+  });
+});
+
+describe("ToolRegistry — validateActionCredentials", () => {
+  const origTestApiKey = process.env.TEST_API_KEY;
+  const origTestSecret = process.env.TEST_SECRET;
+  const origMissingKeyA = process.env.MISSING_KEY_A;
+  const origMissingKeyB = process.env.MISSING_KEY_B;
+  const origPresentKey = process.env.PRESENT_KEY;
+
+  afterEach(() => {
+    if (origTestApiKey !== undefined) process.env.TEST_API_KEY = origTestApiKey; else delete process.env.TEST_API_KEY;
+    if (origTestSecret !== undefined) process.env.TEST_SECRET = origTestSecret; else delete process.env.TEST_SECRET;
+    if (origMissingKeyA !== undefined) process.env.MISSING_KEY_A = origMissingKeyA; else delete process.env.MISSING_KEY_A;
+    if (origMissingKeyB !== undefined) process.env.MISSING_KEY_B = origMissingKeyB; else delete process.env.MISSING_KEY_B;
+    if (origPresentKey !== undefined) process.env.PRESENT_KEY = origPresentKey; else delete process.env.PRESENT_KEY;
+  });
+
+  it("returns empty array when no actions", () => {
+    const registry = new ToolRegistry();
+    expect(registry.validateActionCredentials()).toEqual([]);
+  });
+
+  it("returns empty array when all credentials present", () => {
+    process.env.TEST_API_KEY = "key-123";
+    process.env.TEST_SECRET = "secret-456";
+
+    const registry = new ToolRegistry();
+    registry.register(
+      makeAction("myAction", { requiredCredentials: ["TEST_API_KEY", "TEST_SECRET"] }),
+    );
+
+    expect(registry.validateActionCredentials()).toEqual([]);
+  });
+
+  it("returns missing credentials for each action", () => {
+    delete process.env.MISSING_KEY_A;
+    delete process.env.MISSING_KEY_B;
+    process.env.PRESENT_KEY = "exists";
+
+    const registry = new ToolRegistry();
+    registry.register(
+      makeAction("actionA", { requiredCredentials: ["MISSING_KEY_A", "PRESENT_KEY"] }),
+    );
+    registry.register(
+      makeAction("actionB", { requiredCredentials: ["MISSING_KEY_B"] }),
+    );
+
+    const result = registry.validateActionCredentials();
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({ action: "actionA", missing: ["MISSING_KEY_A"] });
+    expect(result[1]).toEqual({ action: "actionB", missing: ["MISSING_KEY_B"] });
+  });
+});
+
+describe("ToolRegistry — actions alongside regular tools", () => {
+  it("actions can be registered alongside regular tools", () => {
+    const registry = new ToolRegistry();
+    registry.register({ name: "explore", description: "Explore", tool: makeTool("explore") });
+    registry.register(makeAction("sendEmail"));
+    registry.register({ name: "executeSQL", description: "SQL", tool: makeTool("sql") });
+    registry.register(makeAction("createTicket"));
+
+    const all = registry.getAll();
+    expect(Object.keys(all).sort()).toEqual([
+      "createTicket",
+      "executeSQL",
+      "explore",
+      "sendEmail",
+    ]);
+
+    const actions = registry.getActions();
+    expect(actions).toHaveLength(2);
+    expect(actions.map((a) => a.name).sort()).toEqual(["createTicket", "sendEmail"]);
+  });
+});

package/templates/docker/src/lib/tools/__tests__/registry.test.ts

@@ -0,0 +1,235 @@
+import { describe, expect, it, mock } from "bun:test";
+import { tool } from "ai";
+import { z } from "zod";
+
+// Mock the Salesforce tool so buildRegistry({ includeSalesforce: true }) works
+// without needing jsforce or a real Salesforce connection.
+const mockSfTool = tool({
+  description: "Mock querySalesforce",
+  inputSchema: z.object({ soql: z.string() }),
+  execute: async ({ soql }) => soql,
+});
+
+mock.module("@atlas/api/lib/tools/salesforce", () => ({
+  querySalesforce: mockSfTool,
+}));
+
+// Mock the action tools so buildRegistry({ includeActions: true }) works
+// without needing JIRA/email credentials or external services.
+const mockJiraTool = tool({
+  description: "Mock createJiraTicket tool",
+  inputSchema: z.object({ summary: z.string() }),
+  execute: async ({ summary }) => summary,
+});
+const mockEmailTool = tool({
+  description: "Mock sendEmailReport tool",
+  inputSchema: z.object({ to: z.string() }),
+  execute: async ({ to }) => to,
+});
+
+mock.module("@atlas/api/lib/tools/actions", () => ({
+  createJiraTicket: {
+    name: "createJiraTicket",
+    description: "### Create JIRA Ticket\nMock description",
+    tool: mockJiraTool,
+    actionType: "jira:create",
+    reversible: true,
+    defaultApproval: "manual",
+    requiredCredentials: ["JIRA_BASE_URL", "JIRA_EMAIL", "JIRA_API_TOKEN"],
+  },
+  sendEmailReport: {
+    name: "sendEmailReport",
+    description: "### Send Email Report\nMock description",
+    tool: mockEmailTool,
+    actionType: "email:send",
+    reversible: false,
+    defaultApproval: "admin-only",
+    requiredCredentials: ["RESEND_API_KEY"],
+  },
+}));
+
+const { ToolRegistry, defaultRegistry, buildRegistry } = await import(
+  "@atlas/api/lib/tools/registry"
+);
+
+function makeTool(name: string) {
+  return tool({
+    description: `Test tool: ${name}`,
+    inputSchema: z.object({ input: z.string() }),
+    execute: async ({ input }) => input,
+  });
+}
+
+describe("ToolRegistry", () => {
+  it("register + get — stores and retrieves a tool", () => {
+    const registry = new ToolRegistry();
+    const entry = { name: "foo", description: "Foo desc", tool: makeTool("foo") };
+    registry.register(entry);
+    expect(registry.get("foo")).toBe(entry);
+  });
+
+  it("get returns undefined for unknown name", () => {
+    const registry = new ToolRegistry();
+    expect(registry.get("nonexistent")).toBeUndefined();
+  });
+
+  it("getAll returns a ToolSet with all registered tools", () => {
+    const registry = new ToolRegistry();
+    const fooTool = makeTool("foo");
+    const barTool = makeTool("bar");
+    registry.register({ name: "foo", description: "Foo", tool: fooTool });
+    registry.register({ name: "bar", description: "Bar", tool: barTool });
+
+    const all = registry.getAll();
+    expect(Object.keys(all).sort()).toEqual(["bar", "foo"]);
+    expect(all.foo).toBe(fooTool);
+    expect(all.bar).toBe(barTool);
+  });
+
+  it("describe concatenates descriptions with \\n\\n separator", () => {
+    const registry = new ToolRegistry();
+    registry.register({ name: "a", description: "Desc A", tool: makeTool("a") });
+    registry.register({ name: "b", description: "Desc B", tool: makeTool("b") });
+    expect(registry.describe()).toBe("Desc A\n\nDesc B");
+  });
+
+  it("describe returns empty string for empty registry", () => {
+    const registry = new ToolRegistry();
+    expect(registry.describe()).toBe("");
+  });
+
+  it("duplicate registration overwrites the previous entry", () => {
+    const registry = new ToolRegistry();
+    const tool1 = makeTool("v1");
+    const tool2 = makeTool("v2");
+    registry.register({ name: "x", description: "First", tool: tool1 });
+    registry.register({ name: "x", description: "Second", tool: tool2 });
+
+    expect(registry.get("x")!.description).toBe("Second");
+    expect(registry.get("x")!.tool).toBe(tool2);
+    expect(Object.keys(registry.getAll())).toEqual(["x"]);
+  });
+
+  it("describe() preserves registration order", () => {
+    const registry = new ToolRegistry();
+    registry.register({ name: "a", description: "Desc A", tool: makeTool("a") });
+    registry.register({ name: "b", description: "Desc B", tool: makeTool("b") });
+    registry.register({ name: "c", description: "Desc C", tool: makeTool("c") });
+    expect(registry.describe()).toBe("Desc A\n\nDesc B\n\nDesc C");
+  });
+
+  it("getAll() returns a fresh object", () => {
+    const registry = new ToolRegistry();
+    registry.register({ name: "a", description: "A", tool: makeTool("a") });
+    registry.register({ name: "b", description: "B", tool: makeTool("b") });
+
+    const first = registry.getAll();
+    delete first.a;
+
+    const second = registry.getAll();
+    expect(second.a).toBeDefined();
+  });
+
+  it("register() throws on empty name", () => {
+    const registry = new ToolRegistry();
+    expect(() =>
+      registry.register({ name: "", description: "X", tool: makeTool("x") })
+    ).toThrow();
+  });
+
+  it("register() throws on empty description", () => {
+    const registry = new ToolRegistry();
+    expect(() =>
+      registry.register({ name: "x", description: "", tool: makeTool("x") })
+    ).toThrow();
+  });
+
+  it("register() throws on frozen registry", () => {
+    const registry = new ToolRegistry();
+    registry.register({ name: "a", description: "A", tool: makeTool("a") });
+    registry.freeze();
+    expect(() =>
+      registry.register({ name: "b", description: "B", tool: makeTool("b") })
+    ).toThrow();
+  });
+});
+
+describe("defaultRegistry", () => {
+  it("contains all 2 core tools", () => {
+    expect(defaultRegistry.get("explore")).toBeDefined();
+    expect(defaultRegistry.get("executeSQL")).toBeDefined();
+  });
+
+  it("getAll returns exactly the 2 core tools", () => {
+    const all = defaultRegistry.getAll();
+    expect(Object.keys(all).sort()).toEqual(["executeSQL", "explore"]);
+  });
+
+  it("describe produces the expected workflow text", () => {
+    const text = defaultRegistry.describe();
+    expect(text).toContain("### 2. Explore the Semantic Layer");
+    expect(text).toContain("### 3. Write and Execute SQL");
+  });
+
+  it("is frozen — cannot register additional tools", () => {
+    expect(() =>
+      defaultRegistry.register({ name: "rogue", description: "X", tool: makeTool("x") })
+    ).toThrow("Cannot register tools on a frozen registry");
+  });
+});
+
+describe("buildRegistry", () => {
+  it("without Salesforce returns 2 core tools", async () => {
+    const registry = await buildRegistry();
+    const names = Object.keys(registry.getAll()).sort();
+    expect(names).toEqual(["executeSQL", "explore"]);
+  });
+
+  it("with includeSalesforce returns 3 tools including querySalesforce", async () => {
+    const registry = await buildRegistry({ includeSalesforce: true });
+    const names = Object.keys(registry.getAll()).sort();
+    expect(names).toEqual(["executeSQL", "explore", "querySalesforce"]);
+  });
+
+  it("with includeActions returns 4 tools including createJiraTicket and sendEmailReport", async () => {
+    const registry = await buildRegistry({ includeActions: true });
+    const names = Object.keys(registry.getAll()).sort();
+    expect(names).toEqual([
+      "createJiraTicket",
+      "executeSQL",
+      "explore",
+      "sendEmailReport",
+    ]);
+  });
+
+  it("with both includeSalesforce and includeActions returns 5 tools", async () => {
+    const registry = await buildRegistry({ includeSalesforce: true, includeActions: true });
+    const names = Object.keys(registry.getAll()).sort();
+    expect(names).toEqual([
+      "createJiraTicket",
+      "executeSQL",
+      "explore",
+      "querySalesforce",
+      "sendEmailReport",
+    ]);
+  });
+
+  it("returned registry is frozen", async () => {
+    const registry = await buildRegistry();
+    expect(() =>
+      registry.register({ name: "extra", description: "X", tool: makeTool("x") })
+    ).toThrow("Cannot register tools on a frozen registry");
+  });
+
+  it("getActions returns action tools with correct metadata", async () => {
+    const registry = await buildRegistry({ includeActions: true });
+    const actions = registry.getActions();
+    const actionTypes = actions.map((a) => a.actionType).sort();
+    expect(actionTypes).toEqual(["email:send", "jira:create"]);
+  });
+
+  it("core-only registry has no actions", async () => {
+    const registry = await buildRegistry();
+    expect(registry.getActions()).toEqual([]);
+  });
+});

package/templates/docker/src/lib/tools/__tests__/salesforce-tool.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Tests for the querySalesforce agent tool.
+ */
+import { describe, it, expect, beforeEach, mock } from "bun:test";
+
+// Mock Salesforce registry
+const mockQuery = mock(() =>
+  Promise.resolve({
+    columns: ["Id", "Name"],
+    rows: [
+      { Id: "001", Name: "Acme" },
+      { Id: "002", Name: "Widget Co" },
+    ],
+  }),
+);
+
+const mockSources = new Map<string, { query: typeof mockQuery; close: () => Promise<void> }>();
+
+mock.module("@atlas/api/lib/db/salesforce", () => ({
+  getSalesforceSource: (id: string) => {
+    const source = mockSources.get(id);
+    if (!source) throw new Error(`Salesforce source "${id}" is not registered.`);
+    return source;
+  },
+  listSalesforceSources: () => Array.from(mockSources.keys()),
+}));
+
+// Mock semantic layer
+mock.module("@atlas/api/lib/semantic", () => ({
+  getWhitelistedTables: () => new Set(["account", "contact", "opportunity"]),
+  _resetWhitelists: () => {},
+}));
+
+// Mock audit log (no-op)
+mock.module("@atlas/api/lib/auth/audit", () => ({
+  logQueryAudit: () => {},
+}));
+
+const { querySalesforce } = await import("@atlas/api/lib/tools/salesforce");
+
+// Helper to call the tool's execute function
+async function executeTool(params: {
+  soql: string;
+  explanation: string;
+  connectionId?: string;
+}) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return (querySalesforce as any).execute(params);
+}
+
+describe("querySalesforce tool", () => {
+  beforeEach(() => {
+    mockQuery.mockClear();
+    mockQuery.mockImplementation(() =>
+      Promise.resolve({
+        columns: ["Id", "Name"],
+        rows: [
+          { Id: "001", Name: "Acme" },
+          { Id: "002", Name: "Widget Co" },
+        ],
+      }),
+    );
+    mockSources.clear();
+    mockSources.set("default", {
+      query: mockQuery,
+      close: async () => {},
+    });
+  });
+
+  it("executes a valid query and returns results", async () => {
+    const result = await executeTool({
+      soql: "SELECT Id, Name FROM Account",
+      explanation: "Get all accounts",
+    });
+    expect(result.success).toBe(true);
+    expect(result.columns).toEqual(["Id", "Name"]);
+    expect(result.rows).toHaveLength(2);
+    expect(result.row_count).toBe(2);
+  });
+
+  it("rejects invalid SOQL (mutation)", async () => {
+    const result = await executeTool({
+      soql: "DELETE FROM Account",
+      explanation: "Delete accounts",
+    });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("Forbidden");
+  });
+
+  it("rejects queries against non-whitelisted objects", async () => {
+    const result = await executeTool({
+      soql: "SELECT Id FROM CustomObject__c",
+      explanation: "Get custom objects",
+    });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("not in the allowed list");
+  });
+
+  it("returns error for unregistered connection", async () => {
+    const result = await executeTool({
+      soql: "SELECT Id FROM Account",
+      explanation: "test",
+      connectionId: "nonexistent",
+    });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("not registered");
+  });
+
+  it("appends LIMIT when not present", async () => {
+    await executeTool({
+      soql: "SELECT Id FROM Account",
+      explanation: "test",
+    });
+    // The mockQuery should have been called with a SOQL that includes LIMIT
+    const calledWith = (mockQuery.mock.calls as unknown as string[][])[0][0];
+    expect(calledWith).toContain("LIMIT");
+  });
+
+  it("does not double-append LIMIT", async () => {
+    await executeTool({
+      soql: "SELECT Id FROM Account LIMIT 5",
+      explanation: "test",
+    });
+    const calledWith = (mockQuery.mock.calls as unknown as string[][])[0][0];
+    // Should not have two LIMIT clauses
+    const limitCount = (calledWith.match(/LIMIT/gi) ?? []).length;
+    expect(limitCount).toBe(1);
+  });
+
+  it("scrubs sensitive error messages", async () => {
+    mockQuery.mockImplementationOnce(() =>
+      Promise.reject(new Error("INVALID_SESSION_ID: Session expired")),
+    );
+    const result = await executeTool({
+      soql: "SELECT Id FROM Account",
+      explanation: "test",
+    });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("check server logs");
+    expect(result.error).not.toContain("INVALID_SESSION_ID");
+  });
+
+  it("surfaces non-sensitive errors to the agent", async () => {
+    mockQuery.mockImplementationOnce(() =>
+      Promise.reject(new Error("INVALID_FIELD: No such column 'Foo'")),
+    );
+    const result = await executeTool({
+      soql: "SELECT Foo FROM Account",
+      explanation: "test",
+    });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("INVALID_FIELD");
+  });
+});