agent: @U0AJM7X8FBR Admin + Docs + API - we want a new admin page to view analy

app/api/admins/coding-agent/slack-tags/route.ts

@@ -0,0 +1,19 @@
+import { type NextRequest, NextResponse } from "next/server";
+import { getCorsHeaders } from "@/lib/networking/getCorsHeaders";
+import { getSlackTagsHandler } from "@/lib/admins/coding-agent/getSlackTagsHandler";
+
+/**
+ * GET /api/admins/coding-agent/slack-tags
+ *
+ * Returns Slack tagging analytics for the Recoup Coding Agent bot.
+ * Pulls directly from the Slack API as the source of truth.
+ * Supports period filtering: all (default), daily, weekly, monthly.
+ * Requires admin authentication.
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+  return getSlackTagsHandler(request);
+}
+
+export async function OPTIONS(): Promise<NextResponse> {
+  return new NextResponse(null, { status: 204, headers: getCorsHeaders() });
+}

lib/admins/coding-agent/__tests__/getSlackTagsHandler.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest, NextResponse } from "next/server";
+import { getSlackTagsHandler } from "../getSlackTagsHandler";
+import { validateGetSlackTagsQuery } from "../validateGetSlackTagsQuery";
+import { fetchSlackMentions } from "../fetchSlackMentions";
+
+vi.mock("@/lib/networking/getCorsHeaders", () => ({
+  getCorsHeaders: vi.fn(() => ({ "Access-Control-Allow-Origin": "*" })),
+}));
+
+vi.mock("../validateGetSlackTagsQuery", () => ({
+  validateGetSlackTagsQuery: vi.fn(),
+}));
+
+vi.mock("../fetchSlackMentions", () => ({
+  fetchSlackMentions: vi.fn(),
+}));
+
+const mockTags = [
+  {
+    user_id: "U012AB3CD",
+    user_name: "Jane Smith",
+    user_avatar: "https://avatars.slack-edge.com/jane.jpg",
+    prompt: "add dark mode support",
+    timestamp: "2024-01-15T10:30:00.000Z",
+    channel_id: "C012AB3CD",
+    channel_name: "dev-team",
+  },
+  {
+    user_id: "U098ZY7WX",
+    user_name: "Bob Lee",
+    user_avatar: null,
+    prompt: "fix login bug",
+    timestamp: "2024-01-14T08:00:00.000Z",
+    channel_id: "C012AB3CD",
+    channel_name: "dev-team",
+  },
+];
+
+function makeRequest(period = "all") {
+  return new NextRequest(
+    `https://example.com/api/admins/coding-agent/slack-tags?period=${period}`,
+  );
+}
+
+describe("getSlackTagsHandler", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("successful cases", () => {
+    it("returns 200 with tags and total", async () => {
+      vi.mocked(validateGetSlackTagsQuery).mockResolvedValue({ period: "all" });
+      vi.mocked(fetchSlackMentions).mockResolvedValue(mockTags);
+
+      const response = await getSlackTagsHandler(makeRequest());
+      const body = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(body.status).toBe("success");
+      expect(body.total).toBe(2);
+      expect(body.tags).toEqual(mockTags);
+    });
+
+    it("returns 200 with empty tags when no mentions found", async () => {
+      vi.mocked(validateGetSlackTagsQuery).mockResolvedValue({ period: "daily" });
+      vi.mocked(fetchSlackMentions).mockResolvedValue([]);
+
+      const response = await getSlackTagsHandler(makeRequest("daily"));
+      const body = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(body.status).toBe("success");
+      expect(body.total).toBe(0);
+      expect(body.tags).toEqual([]);
+    });
+
+    it("passes the period to fetchSlackMentions", async () => {
+      vi.mocked(validateGetSlackTagsQuery).mockResolvedValue({ period: "weekly" });
+      vi.mocked(fetchSlackMentions).mockResolvedValue([]);
+
+      await getSlackTagsHandler(makeRequest("weekly"));
+
+      expect(fetchSlackMentions).toHaveBeenCalledWith("weekly");
+    });
+  });
+
+  describe("error cases", () => {
+    it("returns auth error when validateGetSlackTagsQuery returns NextResponse", async () => {
+      const errorResponse = NextResponse.json(
+        { status: "error", message: "Forbidden" },
+        { status: 403 },
+      );
+      vi.mocked(validateGetSlackTagsQuery).mockResolvedValue(errorResponse);
+
+      const response = await getSlackTagsHandler(makeRequest());
+
+      expect(response.status).toBe(403);
+    });
+
+    it("returns 500 when fetchSlackMentions throws", async () => {
+      vi.mocked(validateGetSlackTagsQuery).mockResolvedValue({ period: "all" });
+      vi.mocked(fetchSlackMentions).mockRejectedValue(new Error("Slack API error"));
+
+      const response = await getSlackTagsHandler(makeRequest());
+      const body = await response.json();
+
+      expect(response.status).toBe(500);
+      expect(body.status).toBe("error");
+    });
+  });
+});

lib/admins/coding-agent/__tests__/validateGetSlackTagsQuery.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { NextRequest, NextResponse } from "next/server";
+import { validateGetSlackTagsQuery } from "../validateGetSlackTagsQuery";
+import { validateAdminAuth } from "@/lib/admins/validateAdminAuth";
+
+vi.mock("@/lib/networking/getCorsHeaders", () => ({
+  getCorsHeaders: vi.fn(() => ({ "Access-Control-Allow-Origin": "*" })),
+}));
+
+vi.mock("@/lib/admins/validateAdminAuth", () => ({
+  validateAdminAuth: vi.fn(),
+}));
+
+const mockAuth = { accountId: "test-account", orgId: null, authToken: "token" };
+
+function makeRequest(period?: string) {
+  const url = period
+    ? `https://example.com/api/admins/coding-agent/slack-tags?period=${period}`
+    : "https://example.com/api/admins/coding-agent/slack-tags";
+  return new NextRequest(url);
+}
+
+describe("validateGetSlackTagsQuery", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("successful cases", () => {
+    it("returns all period by default", async () => {
+      vi.mocked(validateAdminAuth).mockResolvedValue(mockAuth);
+
+      const result = await validateGetSlackTagsQuery(makeRequest());
+
+      expect(result).toEqual({ period: "all" });
+    });
+
+    it("returns daily when period=daily", async () => {
+      vi.mocked(validateAdminAuth).mockResolvedValue(mockAuth);
+
+      const result = await validateGetSlackTagsQuery(makeRequest("daily"));
+
+      expect(result).toEqual({ period: "daily" });
+    });
+
+    it("returns weekly when period=weekly", async () => {
+      vi.mocked(validateAdminAuth).mockResolvedValue(mockAuth);
+
+      const result = await validateGetSlackTagsQuery(makeRequest("weekly"));
+
+      expect(result).toEqual({ period: "weekly" });
+    });
+
+    it("returns monthly when period=monthly", async () => {
+      vi.mocked(validateAdminAuth).mockResolvedValue(mockAuth);
+
+      const result = await validateGetSlackTagsQuery(makeRequest("monthly"));
+
+      expect(result).toEqual({ period: "monthly" });
+    });
+  });
+
+  describe("error cases", () => {
+    it("returns auth error when validateAdminAuth returns NextResponse", async () => {
+      const errorResponse = NextResponse.json(
+        { status: "error", message: "Unauthorized" },
+        { status: 401 },
+      );
+      vi.mocked(validateAdminAuth).mockResolvedValue(errorResponse);
+
+      const result = await validateGetSlackTagsQuery(makeRequest());
+
+      expect(result).toBeInstanceOf(NextResponse);
+      const body = await (result as NextResponse).json();
+      expect(body.status).toBe("error");
+    });
+
+    it("returns 400 for invalid period value", async () => {
+      vi.mocked(validateAdminAuth).mockResolvedValue(mockAuth);
+
+      const result = await validateGetSlackTagsQuery(makeRequest("yearly"));
+
+      expect(result).toBeInstanceOf(NextResponse);
+      const body = await (result as NextResponse).json();
+      expect(body.status).toBe("error");
+    });
+  });
+});