@useatlas/create 0.0.6 → 0.0.7

package/templates/nextjs-standalone/src/lib/scheduler/index.ts

@@ -1,7 +0,0 @@
-/**
- * Scheduler barrel — re-exports for clean imports.
- */
-
-export { getScheduler, triggerTask, runTick, _resetScheduler, type TickResult } from "./engine";
-export { executeScheduledTask, type ExecutionResult } from "./executor";
-export { deliverResult, type DeliverySummary } from "./delivery";

package/templates/nextjs-standalone/src/lib/slack/__tests__/api.test.ts

@@ -1,160 +0,0 @@
-/**
- * Tests for the thin Slack Web API client (api.ts).
- *
- * Mocks global fetch to isolate HTTP behavior.
- */
-
-import { describe, it, expect, beforeEach, afterEach, mock, type Mock } from "bun:test";
-
-mock.module("@atlas/api/lib/logger", () => ({
-  createLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-}));
-
-const { slackAPI, postMessage, updateMessage } = await import("../api");
-
-describe("api", () => {
-  const originalFetch = globalThis.fetch;
-  let mockFetch: Mock<typeof globalThis.fetch>;
-
-  beforeEach(() => {
-    mockFetch = mock() as unknown as Mock<typeof globalThis.fetch>;
-    globalThis.fetch = mockFetch as unknown as typeof globalThis.fetch;
-  });
-
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-  });
-
-  describe("slackAPI", () => {
-    it("successful call returns parsed response", async () => {
-      mockFetch.mockResolvedValue(
-        new Response(JSON.stringify({ ok: true, ts: "1234.5678", channel: "C123" }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        }),
-      );
-
-      const result = await slackAPI("chat.postMessage", "xoxb-token", { channel: "C123", text: "hi" });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.ts).toBe("1234.5678");
-        expect(result.channel).toBe("C123");
-      }
-
-      // Verify fetch was called with correct URL and headers
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const [url, init] = mockFetch.mock.calls[0];
-      expect(url).toBe("https://slack.com/api/chat.postMessage");
-      expect((init as RequestInit).method).toBe("POST");
-      expect((init as RequestInit).headers).toEqual(
-        expect.objectContaining({
-          Authorization: "Bearer xoxb-token",
-        }),
-      );
-    });
-
-    it("HTTP error (non-2xx) returns { ok: false, error }", async () => {
-      mockFetch.mockResolvedValue(
-        new Response("Internal Server Error", { status: 500 }),
-      );
-
-      const result = await slackAPI("chat.postMessage", "xoxb-token", { channel: "C123" });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error).toBe("HTTP 500");
-      }
-    });
-
-    it("network error (fetch throws) returns { ok: false, error }", async () => {
-      mockFetch.mockRejectedValue(new Error("ECONNREFUSED"));
-
-      const result = await slackAPI("chat.postMessage", "xoxb-token", { channel: "C123" });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error).toContain("request_failed");
-        expect(result.error).toContain("ECONNREFUSED");
-      }
-    });
-
-    it("malformed JSON response returns error", async () => {
-      mockFetch.mockResolvedValue(
-        new Response("not json at all{{{", {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        }),
-      );
-
-      const result = await slackAPI("chat.postMessage", "xoxb-token", { channel: "C123" });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error).toContain("request_failed");
-      }
-    });
-
-    it("Slack-level error (HTTP 200, ok: false) returns the error", async () => {
-      mockFetch.mockResolvedValue(
-        new Response(JSON.stringify({ ok: false, error: "channel_not_found" }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        }),
-      );
-
-      const result = await slackAPI("chat.postMessage", "xoxb-token", { channel: "CXXX" });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error).toBe("channel_not_found");
-      }
-    });
-  });
-
-  describe("postMessage", () => {
-    it("delegates to slackAPI with correct method", async () => {
-      mockFetch.mockResolvedValue(
-        new Response(JSON.stringify({ ok: true, ts: "1111.2222" }), { status: 200 }),
-      );
-
-      const result = await postMessage("xoxb-token", {
-        channel: "C123",
-        text: "hello",
-        thread_ts: "1000.0001",
-      });
-
-      expect(result.ok).toBe(true);
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const [url, init] = mockFetch.mock.calls[0];
-      expect(url).toBe("https://slack.com/api/chat.postMessage");
-      const body = JSON.parse((init as RequestInit).body as string);
-      expect(body.channel).toBe("C123");
-      expect(body.text).toBe("hello");
-      expect(body.thread_ts).toBe("1000.0001");
-    });
-  });
-
-  describe("updateMessage", () => {
-    it("delegates to slackAPI with correct method", async () => {
-      mockFetch.mockResolvedValue(
-        new Response(JSON.stringify({ ok: true }), { status: 200 }),
-      );
-
-      const result = await updateMessage("xoxb-token", {
-        channel: "C123",
-        ts: "1111.2222",
-        text: "updated text",
-      });
-
-      expect(result.ok).toBe(true);
-      expect(mockFetch).toHaveBeenCalledTimes(1);
-      const [url, init] = mockFetch.mock.calls[0];
-      expect(url).toBe("https://slack.com/api/chat.update");
-      const body = JSON.parse((init as RequestInit).body as string);
-      expect(body.channel).toBe("C123");
-      expect(body.ts).toBe("1111.2222");
-      expect(body.text).toBe("updated text");
-    });
-  });
-});

package/templates/nextjs-standalone/src/lib/slack/__tests__/format.test.ts

@@ -1,237 +0,0 @@
-/**
- * Tests for Slack Block Kit formatter.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-  formatQueryResponse,
-  formatErrorResponse,
-  formatActionApproval,
-  formatActionResult,
-  type SlackQueryResult,
-  type SlackBlock,
-} from "../format";
-import type { PendingAction } from "@atlas/api/lib/agent-query";
-
-/** Helper: extract text from a section block */
-function blockText(block: SlackBlock): string {
-  if (block.type === "section") return block.text.text;
-  return "";
-}
-
-/** Helper: extract context element texts */
-function contextTexts(block: SlackBlock): string[] {
-  if (block.type === "context") return block.elements.map((e) => e.text);
-  return [];
-}
-
-function makeResult(overrides: Partial<SlackQueryResult> = {}): SlackQueryResult {
-  return {
-    answer: "There were 1,234 active users last month.",
-    sql: ["SELECT COUNT(*) FROM users WHERE active = true"],
-    data: [
-      {
-        columns: ["count"],
-        rows: [{ count: 1234 }],
-      },
-    ],
-    steps: 3,
-    usage: { totalTokens: 5000 },
-    ...overrides,
-  };
-}
-
-describe("formatQueryResponse", () => {
-  it("formats a complete query response with answer, SQL, and data", () => {
-    const blocks = formatQueryResponse(makeResult());
-
-    expect(blocks.length).toBeGreaterThanOrEqual(3); // answer + SQL + data + context
-    expect(blocks[0].type).toBe("section");
-    expect(blockText(blocks[0])).toContain("1,234 active users");
-
-    // SQL block
-    expect(blockText(blocks[1])).toContain("```");
-    expect(blockText(blocks[1])).toContain("SELECT COUNT(*)");
-
-    // Context block (last)
-    const last = blocks[blocks.length - 1];
-    expect(last.type).toBe("context");
-    expect(contextTexts(last)[0]).toContain("3 steps");
-    expect(contextTexts(last)[0]).toContain("5,000 tokens");
-  });
-
-  it("handles missing SQL gracefully", () => {
-    const blocks = formatQueryResponse(makeResult({ sql: [] }));
-    const sqlBlocks = blocks.filter(
-      (b) => blockText(b).includes("```") && blockText(b).includes("SQL"),
-    );
-    expect(sqlBlocks.length).toBe(0);
-  });
-
-  it("handles empty data gracefully", () => {
-    const blocks = formatQueryResponse(makeResult({ data: [] }));
-    expect(blocks.length).toBeGreaterThanOrEqual(2);
-    expect(blockText(blocks[0])).toContain("active users");
-  });
-
-  it("handles missing answer with default text", () => {
-    const blocks = formatQueryResponse(makeResult({ answer: "" }));
-    expect(blockText(blocks[0])).toContain("No answer generated");
-  });
-
-  it("truncates large data tables", () => {
-    const manyRows = Array.from({ length: 50 }, (_, i) => ({
-      id: i,
-      name: `User ${i}`,
-      email: `user${i}@example.com`,
-    }));
-
-    const blocks = formatQueryResponse(
-      makeResult({
-        data: [
-          {
-            columns: ["id", "name", "email"],
-            rows: manyRows as Record<string, unknown>[],
-          },
-        ],
-      }),
-    );
-
-    const dataBlock = blocks.find(
-      (b) => blockText(b).includes("```") && !blockText(b).includes("SQL"),
-    );
-    expect(dataBlock).toBeDefined();
-    expect(blockText(dataBlock!)).toContain("Showing first");
-  });
-
-  it("stays within 50 block limit", () => {
-    const manyDatasets = Array.from({ length: 60 }, () => ({
-      columns: ["col"],
-      rows: [{ col: "value" }],
-    }));
-
-    const blocks = formatQueryResponse(makeResult({ data: manyDatasets }));
-    expect(blocks.length).toBeLessThanOrEqual(50);
-  });
-
-  it("truncates long answer text to 3000 chars", () => {
-    const longAnswer = "A".repeat(4000);
-    const blocks = formatQueryResponse(makeResult({ answer: longAnswer }));
-    expect(blockText(blocks[0]).length).toBeLessThanOrEqual(3000);
-    expect(blockText(blocks[0])).toEndWith("...");
-  });
-});
-
-describe("formatErrorResponse", () => {
-  it("formats an error message", () => {
-    const blocks = formatErrorResponse("Something went wrong");
-    expect(blocks.length).toBe(1);
-    expect(blocks[0].type).toBe("section");
-    expect(blockText(blocks[0])).toContain("Something went wrong");
-    expect(blockText(blocks[0])).toContain(":warning:");
-  });
-
-  it("truncates long error messages", () => {
-    const longError = "E".repeat(500);
-    const blocks = formatErrorResponse(longError);
-    expect(blockText(blocks[0]).length).toBeLessThan(300);
-  });
-});
-
-/** Helper: build a PendingAction for tests */
-function makeAction(overrides: Partial<PendingAction> = {}): PendingAction {
-  return {
-    id: "act_123",
-    type: "executeSQL",
-    target: "SELECT 1",
-    summary: "Run a test query",
-    ...overrides,
-  };
-}
-
-describe("formatActionApproval", () => {
-  it("returns a section block and an actions block with two buttons", () => {
-    const blocks = formatActionApproval(makeAction());
-    expect(blocks.length).toBe(2);
-    expect(blocks[0].type).toBe("section");
-    expect(blocks[1].type).toBe("actions");
-    if (blocks[1].type === "actions") {
-      expect(blocks[1].elements.length).toBe(2);
-    }
-  });
-
-  it("approve button has correct action_id and value", () => {
-    const action = makeAction({ id: "act_abc" });
-    const blocks = formatActionApproval(action);
-    const actionsBlock = blocks[1];
-    if (actionsBlock.type === "actions") {
-      const approve = actionsBlock.elements[0];
-      expect(approve.action_id).toBe("atlas_action_approve");
-      expect(approve.value).toBe("act_abc");
-      expect(approve.style).toBe("primary");
-    }
-  });
-
-  it("deny button has correct action_id and value", () => {
-    const action = makeAction({ id: "act_xyz" });
-    const blocks = formatActionApproval(action);
-    const actionsBlock = blocks[1];
-    if (actionsBlock.type === "actions") {
-      const deny = actionsBlock.elements[1];
-      expect(deny.action_id).toBe("atlas_action_deny");
-      expect(deny.value).toBe("act_xyz");
-      expect(deny.style).toBe("danger");
-    }
-  });
-
-  it("falls back to action.type when summary is empty", () => {
-    const blocks = formatActionApproval(makeAction({ summary: "", type: "executeSQL" }));
-    expect(blockText(blocks[0])).toContain("executeSQL");
-    expect(blockText(blocks[0])).not.toContain("\n\n");
-  });
-
-  it("truncates very long summaries", () => {
-    const longSummary = "S".repeat(4000);
-    const blocks = formatActionApproval(makeAction({ summary: longSummary }));
-    expect(blockText(blocks[0]).length).toBeLessThanOrEqual(3000);
-  });
-});
-
-describe("formatActionResult", () => {
-  it("executed status produces check mark emoji", () => {
-    const blocks = formatActionResult(makeAction(), "executed");
-    expect(blockText(blocks[0])).toContain(":white_check_mark:");
-    expect(blockText(blocks[0])).toContain("executed");
-  });
-
-  it("denied status produces no_entry_sign emoji", () => {
-    const blocks = formatActionResult(makeAction(), "denied");
-    expect(blockText(blocks[0])).toContain(":no_entry_sign:");
-    expect(blockText(blocks[0])).toContain("denied");
-  });
-
-  it("failed status produces x emoji", () => {
-    const blocks = formatActionResult(makeAction(), "failed");
-    expect(blockText(blocks[0])).toContain(":x:");
-    expect(blockText(blocks[0])).toContain("failed");
-  });
-
-  it("appends error text when provided", () => {
-    const blocks = formatActionResult(makeAction(), "failed", "Connection timed out");
-    expect(blockText(blocks[0])).toContain("Connection timed out");
-  });
-
-  it("truncates very long error text", () => {
-    const longError = "E".repeat(500);
-    const blocks = formatActionResult(makeAction(), "failed", longError);
-    const text = blockText(blocks[0]);
-    // Error portion truncated to 200 chars (plus "..." = 203 max)
-    expect(text.length).toBeLessThan(500);
-    expect(text).toContain("...");
-  });
-
-  it("falls back to action.type when summary is empty", () => {
-    const blocks = formatActionResult(makeAction({ summary: "", type: "executeSQL" }), "executed");
-    expect(blockText(blocks[0])).toContain("executeSQL");
-  });
-});

package/templates/nextjs-standalone/src/lib/slack/__tests__/store.test.ts

@@ -1,188 +0,0 @@
-/**
- * Tests for Slack installation storage (store.ts).
- *
- * Mocks the internal DB layer to test DB-backed and env-var fallback paths.
- */
-
-import { describe, it, expect, beforeEach, afterEach, mock, type Mock } from "bun:test";
-
-// --- Mocks ---
-
-const mockHasInternalDB: Mock<() => boolean> = mock(() => true);
-const mockInternalQuery: Mock<(sql: string, params?: unknown[]) => Promise<Record<string, unknown>[]>> = mock(() =>
-  Promise.resolve([]),
-);
-
-const mockPoolQuery: Mock<(sql: string, params?: unknown[]) => Promise<void>> = mock(() =>
-  Promise.resolve(),
-);
-const mockGetInternalDB: Mock<() => { query: typeof mockPoolQuery }> = mock(() => ({
-  query: mockPoolQuery,
-}));
-
-mock.module("@atlas/api/lib/db/internal", () => ({
-  hasInternalDB: mockHasInternalDB,
-  internalQuery: mockInternalQuery,
-  getInternalDB: mockGetInternalDB,
-}));
-
-mock.module("@atlas/api/lib/logger", () => ({
-  createLogger: () => ({
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    debug: () => {},
-  }),
-}));
-
-// Import after mocks are registered
-const { getInstallation, saveInstallation, deleteInstallation, getBotToken } = await import("../store");
-
-describe("store", () => {
-  const savedBotToken = process.env.SLACK_BOT_TOKEN;
-
-  beforeEach(() => {
-    mockHasInternalDB.mockClear();
-    mockInternalQuery.mockClear();
-    mockPoolQuery.mockClear();
-    mockGetInternalDB.mockClear();
-    delete process.env.SLACK_BOT_TOKEN;
-  });
-
-  afterEach(() => {
-    if (savedBotToken !== undefined) process.env.SLACK_BOT_TOKEN = savedBotToken;
-    else delete process.env.SLACK_BOT_TOKEN;
-  });
-
-  describe("getInstallation", () => {
-    it("returns installation from DB when hasInternalDB() is true and row exists", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockInternalQuery.mockResolvedValue([
-        { team_id: "T123", bot_token: "xoxb-abc", installed_at: "2025-01-01T00:00:00Z" },
-      ]);
-
-      const result = await getInstallation("T123");
-      expect(result).toEqual({
-        team_id: "T123",
-        bot_token: "xoxb-abc",
-        installed_at: "2025-01-01T00:00:00Z",
-      });
-      expect(mockInternalQuery).toHaveBeenCalledTimes(1);
-    });
-
-    it("returns null when DB has no matching row", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockInternalQuery.mockResolvedValue([]);
-
-      const result = await getInstallation("T999");
-      expect(result).toBeNull();
-    });
-
-    it("throws when DB query fails (does NOT fall through to env var)", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockInternalQuery.mockRejectedValue(new Error("connection refused"));
-      process.env.SLACK_BOT_TOKEN = "xoxb-env-fallback";
-
-      await expect(getInstallation("T123")).rejects.toThrow("connection refused");
-    });
-
-    it("returns env var token when hasInternalDB() is false and SLACK_BOT_TOKEN is set", async () => {
-      mockHasInternalDB.mockReturnValue(false);
-      process.env.SLACK_BOT_TOKEN = "xoxb-env-token";
-
-      const result = await getInstallation("T123");
-      expect(result).not.toBeNull();
-      expect(result!.bot_token).toBe("xoxb-env-token");
-      expect(result!.team_id).toBe("T123");
-      expect(mockInternalQuery).not.toHaveBeenCalled();
-    });
-
-    it("returns null when hasInternalDB() is false and no env var", async () => {
-      mockHasInternalDB.mockReturnValue(false);
-      delete process.env.SLACK_BOT_TOKEN;
-
-      const result = await getInstallation("T123");
-      expect(result).toBeNull();
-    });
-
-    it("returns null for invalid DB record (non-string bot_token)", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockInternalQuery.mockResolvedValue([
-        { team_id: "T123", bot_token: 12345, installed_at: "2025-01-01T00:00:00Z" },
-      ]);
-
-      const result = await getInstallation("T123");
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("saveInstallation", () => {
-    it("resolves when DB write succeeds", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockPoolQuery.mockResolvedValue(undefined as never);
-
-      await expect(saveInstallation("T123", "xoxb-new")).resolves.toBeUndefined();
-      expect(mockPoolQuery).toHaveBeenCalledTimes(1);
-      // Verify the SQL contains INSERT and the params
-      const [sql, params] = mockPoolQuery.mock.calls[0];
-      expect(sql).toContain("INSERT INTO slack_installations");
-      expect(params).toEqual(["T123", "xoxb-new"]);
-    });
-
-    it("throws when no internal DB", async () => {
-      mockHasInternalDB.mockReturnValue(false);
-
-      await expect(saveInstallation("T123", "xoxb-token")).rejects.toThrow(
-        "no internal database configured",
-      );
-    });
-
-    it("throws when DB write fails", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockPoolQuery.mockRejectedValue(new Error("disk full"));
-
-      await expect(saveInstallation("T123", "xoxb-token")).rejects.toThrow("disk full");
-    });
-  });
-
-  describe("deleteInstallation", () => {
-    it("resolves when DB delete succeeds", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockPoolQuery.mockResolvedValue(undefined as never);
-
-      await expect(deleteInstallation("T123")).resolves.toBeUndefined();
-      expect(mockPoolQuery).toHaveBeenCalledTimes(1);
-      const [sql, params] = mockPoolQuery.mock.calls[0];
-      expect(sql).toContain("DELETE FROM slack_installations");
-      expect(params).toEqual(["T123"]);
-    });
-
-    it("resolves (with warning) when no internal DB", async () => {
-      mockHasInternalDB.mockReturnValue(false);
-
-      // Should not throw — just logs a warning and returns
-      await expect(deleteInstallation("T123")).resolves.toBeUndefined();
-      expect(mockPoolQuery).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("getBotToken", () => {
-    it("returns the token string from getInstallation", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockInternalQuery.mockResolvedValue([
-        { team_id: "T123", bot_token: "xoxb-from-db", installed_at: "2025-01-01T00:00:00Z" },
-      ]);
-
-      const token = await getBotToken("T123");
-      expect(token).toBe("xoxb-from-db");
-    });
-
-    it("returns null when no installation exists", async () => {
-      mockHasInternalDB.mockReturnValue(true);
-      mockInternalQuery.mockResolvedValue([]);
-
-      const token = await getBotToken("T999");
-      expect(token).toBeNull();
-    });
-  });
-});