@localpulse/cli 0.0.1

package/src/lib/research-schema.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+  generateResearchSkeleton,
+  mapResearchToUploadFields,
+  stitchResearchContext,
+  validateResearchPayload,
+} from "./research-schema";
+
+describe("validateResearchPayload", () => {
+  it("accepts a full payload with all fields", () => {
+    const payload = validateResearchPayload({
+      performers: [
+        {
+          name: "DJ Nobu",
+          type: "DJ",
+          genre: "techno",
+          socials: ["https://instagram.com/djnobu"],
+          context: "Berlin-based Japanese DJ",
+        },
+        { name: "Objekt", genre: "electro" },
+      ],
+      organizer: {
+        name: "Dekmantel",
+        socials: ["https://instagram.com/dekmantel"],
+        context: "Amsterdam collective, running events since 2007",
+      },
+      venue: {
+        name: "Shelter",
+        city: "Amsterdam",
+        google_place_id: "ChIJ123",
+        context: "Underground club, 350 capacity",
+      },
+      event: {
+        title: "Reaktor Night",
+        date: "2026-03-14T22:00",
+        type: "club night",
+        price: "€15-25",
+        urls: ["https://ra.co/events/123"],
+        ticket_url: "https://tickets.example.com",
+        context: "Part of ADE week",
+      },
+      context: "Two rooms",
+    });
+    expect(payload.performers).toHaveLength(2);
+    expect(payload.performers![0].type).toBe("DJ");
+    expect(payload.venue?.context).toBe("Underground club, 350 capacity");
+    expect(payload.event?.type).toBe("club night");
+  });
+
+  it("accepts an empty object", () => {
+    expect(validateResearchPayload({})).toEqual({});
+  });
+
+  it("accepts a payload with only performers", () => {
+    const payload = validateResearchPayload({
+      performers: [{ name: "Objekt" }],
+    });
+    expect(payload.performers).toHaveLength(1);
+  });
+
+  it("rejects a payload where performers is not an array", () => {
+    expect(() => validateResearchPayload({ performers: "DJ Nobu" })).toThrow("Invalid research payload");
+  });
+
+  it("rejects a performer missing name", () => {
+    expect(() => validateResearchPayload({ performers: [{ genre: "techno" }] })).toThrow("Invalid research payload");
+  });
+});
+
+describe("stitchResearchContext", () => {
+  it("produces formatted output preserving entity context", () => {
+    const result = stitchResearchContext({
+      performers: [
+        {
+          name: "DJ Nobu",
+          type: "DJ",
+          genre: "techno",
+          socials: ["https://instagram.com/djnobu"],
+          context: "Berlin-based, known for long hypnotic sets",
+        },
+        { name: "Objekt" },
+      ],
+      organizer: {
+        name: "Dekmantel",
+        socials: ["https://instagram.com/dekmantel"],
+        context: "Amsterdam collective since 2007",
+      },
+      venue: {
+        name: "Shelter",
+        city: "Amsterdam",
+        context: "Underground club, 350 capacity, one room",
+      },
+      event: {
+        type: "club night",
+        price: "€15-25",
+        context: "Part of ADE week. Doors at 22:00.",
+      },
+      context: "Cash only at door",
+    });
+
+    expect(result).toContain("## Performers");
+    expect(result).toContain("- DJ Nobu (DJ, techno)");
+    expect(result).toContain("Berlin-based, known for long hypnotic sets");
+    expect(result).toContain("Profiles: https://instagram.com/djnobu");
+    expect(result).toContain("- Objekt");
+    expect(result).toContain("## Organizer");
+    expect(result).toContain("Amsterdam collective since 2007");
+    expect(result).toContain("## Venue");
+    expect(result).toContain("Underground club, 350 capacity, one room");
+    expect(result).toContain("## Event");
+    expect(result).toContain("Type: club night");
+    expect(result).toContain("Price: €15-25");
+    expect(result).toContain("Part of ADE week. Doors at 22:00.");
+    expect(result).toContain("## Additional context");
+    expect(result).toContain("Cash only at door");
+  });
+
+  it("returns empty string for empty payload", () => {
+    expect(stitchResearchContext({})).toBe("");
+  });
+
+  it("omits sections without data", () => {
+    const result = stitchResearchContext({
+      performers: [{ name: "Objekt" }],
+    });
+    expect(result).toContain("## Performers");
+    expect(result).not.toContain("## Organizer");
+    expect(result).not.toContain("## Venue");
+    expect(result).not.toContain("## Event");
+  });
+});
+
+describe("mapResearchToUploadFields", () => {
+  it("extracts direct fields", () => {
+    const mapped = mapResearchToUploadFields({
+      venue: { name: "Shelter", city: "Amsterdam", google_place_id: "ChIJ123" },
+      event: {
+        title: "Reaktor Night",
+        date: "2026-03-14T22:00",
+        urls: ["https://ra.co/events/123"],
+        ticket_url: "https://tickets.example.com",
+      },
+    });
+    expect(mapped).toEqual({
+      title: "Reaktor Night",
+      datetime: "2026-03-14T22:00",
+      city: "Amsterdam",
+      venue: "Shelter",
+      venuePlaceId: "ChIJ123",
+      urls: ["https://ra.co/events/123"],
+      ticketUrl: "https://tickets.example.com",
+    });
+  });
+
+  it("returns undefineds for empty payload", () => {
+    const mapped = mapResearchToUploadFields({});
+    expect(mapped.title).toBeUndefined();
+    expect(mapped.city).toBeUndefined();
+    expect(mapped.urls).toBeUndefined();
+  });
+});
+
+describe("generateResearchSkeleton", () => {
+  it("produces a payload that passes validation", () => {
+    const skeleton = generateResearchSkeleton();
+    expect(() => validateResearchPayload(skeleton)).not.toThrow();
+  });
+
+  it("includes all entity sections with example data", () => {
+    const skeleton = generateResearchSkeleton();
+    expect(skeleton.performers![0].name).toBeTruthy();
+    expect(skeleton.performers![0].type).toBeTruthy();
+    expect(skeleton.performers![0].context).toBeTruthy();
+    expect(skeleton.organizer!.context).toBeTruthy();
+    expect(skeleton.venue!.context).toBeTruthy();
+    expect(skeleton.event!.type).toBeTruthy();
+    expect(skeleton.event!.context).toBeTruthy();
+  });
+});

package/src/lib/research-schema.ts

@@ -0,0 +1,160 @@
+import { Type, type Static } from "@sinclair/typebox";
+import Ajv from "ajv";
+
+const PerformerSchema = Type.Object({
+  name: Type.String(),
+  type: Type.Optional(Type.String()),
+  genre: Type.Optional(Type.String()),
+  socials: Type.Optional(Type.Array(Type.String())),
+  context: Type.Optional(Type.String()),
+});
+
+const OrganizerSchema = Type.Object({
+  name: Type.String(),
+  socials: Type.Optional(Type.Array(Type.String())),
+  context: Type.Optional(Type.String()),
+});
+
+const VenueSchema = Type.Object({
+  name: Type.Optional(Type.String()),
+  city: Type.Optional(Type.String()),
+  google_place_id: Type.Optional(Type.String()),
+  context: Type.Optional(Type.String()),
+});
+
+const EventSchema = Type.Object({
+  title: Type.Optional(Type.String()),
+  date: Type.Optional(Type.String()),
+  type: Type.Optional(Type.String()),
+  price: Type.Optional(Type.String()),
+  urls: Type.Optional(Type.Array(Type.String())),
+  ticket_url: Type.Optional(Type.String()),
+  context: Type.Optional(Type.String()),
+});
+
+export const ResearchPayloadSchema = Type.Object({
+  performers: Type.Optional(Type.Array(PerformerSchema)),
+  organizer: Type.Optional(OrganizerSchema),
+  venue: Type.Optional(VenueSchema),
+  event: Type.Optional(EventSchema),
+  context: Type.Optional(Type.String()),
+});
+
+export type ResearchPayload = Static<typeof ResearchPayloadSchema>;
+
+const ajv = new Ajv({ allErrors: true });
+const validate = ajv.compile(ResearchPayloadSchema);
+
+export function validateResearchPayload(data: unknown): ResearchPayload {
+  if (validate(data)) {
+    return data;
+  }
+  const messages = (validate.errors ?? []).map((e) => `${e.instancePath || "/"}: ${e.message}`);
+  throw new Error(`Invalid research payload:\n${messages.join("\n")}`);
+}
+
+export function generateResearchSkeleton(): ResearchPayload {
+  return {
+    performers: [
+      {
+        name: "DJ Nobu",
+        type: "DJ",
+        genre: "techno",
+        socials: ["https://instagram.com/djnobu", "https://ra.co/dj/djnobu"],
+        context: "Berlin-based Japanese DJ, known for long hypnotic sets",
+      },
+    ],
+    organizer: {
+      name: "Dekmantel",
+      socials: ["https://instagram.com/daboratorium"],
+      context: "Amsterdam-based collective, running events since 2007",
+    },
+    venue: {
+      name: "Shelter Amsterdam",
+      city: "Amsterdam",
+      google_place_id: "",
+      context: "Underground club beneath A'DAM Tower, 350 capacity, one room",
+    },
+    event: {
+      title: "Shelter Presents: DJ Nobu",
+      date: "2026-03-14T22:00:00+01:00",
+      type: "club night",
+      price: "€15-25",
+      urls: ["https://ra.co/events/1234567"],
+      ticket_url: "https://tickets.example.com/shelter-nobu",
+      context: "Part of ADE week. Doors at 22:00. Cash only at door.",
+    },
+    context: "",
+  };
+}
+
+export function mapResearchToUploadFields(
+  payload: ResearchPayload,
+): {
+  title?: string;
+  datetime?: string;
+  city?: string;
+  venue?: string;
+  venuePlaceId?: string;
+  urls?: string[];
+  ticketUrl?: string;
+} {
+  return {
+    title: payload.event?.title || undefined,
+    datetime: payload.event?.date || undefined,
+    city: payload.venue?.city || undefined,
+    venue: payload.venue?.name || undefined,
+    venuePlaceId: payload.venue?.google_place_id || undefined,
+    urls: payload.event?.urls?.length ? payload.event.urls : undefined,
+    ticketUrl: payload.event?.ticket_url || undefined,
+  };
+}
+
+export function stitchResearchContext(payload: ResearchPayload): string {
+  const sections: string[] = [];
+
+  if (payload.performers?.length) {
+    const lines = payload.performers.map((p) => {
+      const parts = [`- ${p.name}`];
+      const attrs: string[] = [];
+      if (p.type) attrs.push(p.type);
+      if (p.genre) attrs.push(p.genre);
+      if (attrs.length) parts[0] += ` (${attrs.join(", ")})`;
+      if (p.socials?.length) parts.push(`  Profiles: ${p.socials.join(", ")}`);
+      if (p.context) parts.push(`  ${p.context}`);
+      return parts.join("\n");
+    });
+    sections.push(`## Performers\n${lines.join("\n")}`);
+  }
+
+  if (payload.organizer?.name) {
+    const lines = [`- ${payload.organizer.name}`];
+    if (payload.organizer.socials?.length) {
+      lines.push(`  Profiles: ${payload.organizer.socials.join(", ")}`);
+    }
+    if (payload.organizer.context) {
+      lines.push(`  ${payload.organizer.context}`);
+    }
+    sections.push(`## Organizer\n${lines.join("\n")}`);
+  }
+
+  if (payload.venue?.context) {
+    sections.push(`## Venue\n${payload.venue.context}`);
+  }
+
+  if (payload.event) {
+    const eventParts: string[] = [];
+    if (payload.event.type) eventParts.push(`Type: ${payload.event.type}`);
+    if (payload.event.price) eventParts.push(`Price: ${payload.event.price}`);
+    if (payload.event.context) eventParts.push(payload.event.context);
+    if (eventParts.length) {
+      sections.push(`## Event\n${eventParts.join("\n")}`);
+    }
+  }
+
+  if (payload.context?.trim()) {
+    sections.push(`## Additional context\n${payload.context.trim()}`);
+  }
+
+  return sections.join("\n\n");
+}

package/src/lib/token.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "bun:test";
+
+import { isLikelyCliToken } from "./token";
+
+describe("token", () => {
+  it("accepts current cli token format", () => {
+    expect(
+      isLikelyCliToken("lp_cli_11111111-1111-4111-8111-111111111111_secret"),
+    ).toBe(true);
+  });
+
+  it("accepts legacy mcp token format", () => {
+    expect(
+      isLikelyCliToken("lp_mcp_11111111-1111-4111-8111-111111111111_secret"),
+    ).toBe(true);
+  });
+});

package/src/lib/token.ts

@@ -0,0 +1,8 @@
+const CLI_TOKEN_PATTERNS = [
+  /^lp_cli_[0-9a-fA-F-]{36}_.+$/,
+  /^lp_mcp_[0-9a-fA-F-]{36}_.+$/,
+];
+
+export function isLikelyCliToken(token: string): boolean {
+  return CLI_TOKEN_PATTERNS.some((pattern) => pattern.test(token.trim()));
+}

package/src/lib/upload-client.test.ts

@@ -0,0 +1,82 @@
+import { afterEach, describe, expect, it, mock } from "bun:test";
+
+import { CliApiError, verifyCliToken } from "./upload-client";
+
+const ORIGINAL_FETCH = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = ORIGINAL_FETCH;
+});
+
+describe("upload-client", () => {
+  it("calls the token verification endpoint", async () => {
+    globalThis.fetch = mock(async (input, init) => {
+      expect(String(input)).toBe("https://localpulse.nl/api/v1/token/verify");
+      expect(init?.headers).toEqual({
+        accept: "application/json",
+        authorization: "Bearer lp_cli_11111111-1111-4111-8111-111111111111_secret",
+      });
+
+      return new Response(
+        JSON.stringify({
+          authenticated: true,
+          email: "user@example.com",
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }) as typeof fetch;
+
+    const result = await verifyCliToken(
+      "https://localpulse.nl",
+      "lp_cli_11111111-1111-4111-8111-111111111111_secret",
+    );
+
+    expect(result).toEqual({
+      authenticated: true,
+      email: "user@example.com",
+    });
+  });
+
+  it("surfaces structured HTTP errors", async () => {
+    globalThis.fetch = mock(async () => {
+      return new Response(
+        JSON.stringify({
+          detail: "Invalid CLI token",
+        }),
+        { status: 401, headers: { "Content-Type": "application/json" } },
+      );
+    }) as typeof fetch;
+
+    try {
+      await verifyCliToken(
+        "https://localpulse.nl",
+        "lp_cli_11111111-1111-4111-8111-111111111111_secret",
+      );
+      throw new Error("expected verifyCliToken to throw");
+    } catch (error) {
+      expect(error).toBeInstanceOf(CliApiError);
+      expect((error as CliApiError).httpStatus).toBe(401);
+      expect((error as CliApiError).message).toBe("Invalid CLI token");
+    }
+  });
+
+  it("fails fast on non-json API error responses", async () => {
+    globalThis.fetch = mock(async () => {
+      return new Response("<html>bad gateway</html>", {
+        status: 502,
+        headers: { "Content-Type": "text/html" },
+      });
+    }) as typeof fetch;
+
+    await expect(
+      verifyCliToken(
+        "https://localpulse.nl",
+        "lp_cli_11111111-1111-4111-8111-111111111111_secret",
+      ),
+    ).rejects.toMatchObject({
+      message: "API returned a non-JSON error response",
+      httpStatus: 502,
+      body: { bodySnippet: "<html>bad gateway</html>" },
+    });
+  });
+});