@localpulse/cli 0.0.5 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@localpulse/cli",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Local Pulse CLI — ingest event posters, search events, manage credentials",
   "type": "module",
   "license": "MIT",

package/src/index.test.ts

@@ -153,20 +153,84 @@ describe("localpulse", () => {
     const { exitCode, stdout } = runCli("ingest", "../../README.md", "--research", researchFile, "--dry-run");
     expect(exitCode).toBe(0);
     expect(stdout).toContain("Dry run passed");
+    expect(stdout).toContain("Title:     Test Night");
+    expect(stdout).toContain("Date:      2026-03-14T22:00:00+01:00");
+    expect(stdout).toContain("Venue:     Shelter (Amsterdam) [ChIJ123]");
+    expect(stdout).toContain("Featured:  1 (DJ Nobu)");
+    expect(stdout).toContain("Organizer: Dekmantel");
+    expect(stdout).toContain("URLs:      2 source(s)");
+    expect(stdout).toContain("Ticket:    https://tickets.example.com");
+    expect(stdout).toContain("Audit:     passed (0 issues)");
   });
 
-  it("rejects thin research payload with audit findings", async () => {
+  it("includes parsed fields in --dry-run --json output", async () => {
+    const researchFile = join(tmpdir(), `lp-test-${Date.now()}.json`);
+    await writeFile(researchFile, JSON.stringify({
+      featured: [
+        { name: "DJ Nobu", type: "DJ", socials: ["https://instagram.com/djnobu"], context: "Berlin-based" },
+        { name: "Nene H", type: "DJ", socials: ["https://instagram.com/neneh"], context: "Tehran-born" },
+      ],
+      organizer: { name: "Dekmantel", socials: ["https://instagram.com/dekmantel"] },
+      venue: { name: "Shelter", city: "Amsterdam", google_place_id: "ChIJ123" },
+      event: {
+        title: "Test Night",
+        date: "2026-03-14T22:00:00+01:00",
+        type: "club night",
+        urls: ["https://ra.co/events/123", "https://example.com/event"],
+        ticket_url: "https://tickets.example.com",
+      },
+    }));
+
+    const { exitCode, stdout } = runCli("ingest", "../../README.md", "--research", researchFile, "--dry-run", "--json");
+    expect(exitCode).toBe(0);
+    const result = JSON.parse(stdout);
+    expect(result.dry_run).toBe(true);
+    expect(result.valid).toBe(true);
+    expect(result.parsed.title).toBe("Test Night");
+    expect(result.parsed.datetime).toBe("2026-03-14T22:00:00+01:00");
+    expect(result.parsed.venue).toBe("Shelter");
+    expect(result.parsed.city).toBe("Amsterdam");
+    expect(result.parsed.venue_place_id).toBe("ChIJ123");
+    expect(result.parsed.featured_count).toBe(2);
+    expect(result.parsed.featured_names).toEqual(["DJ Nobu", "Nene H"]);
+    expect(result.parsed.organizer).toBe("Dekmantel");
+    expect(result.parsed.urls_count).toBe(2);
+    expect(result.parsed.ticket_url).toBe("https://tickets.example.com");
+    expect(result.audit.pass).toBe(true);
+    expect(result.audit.issues).toBe(0);
+  });
+
+  it("shows required annotations in ingest help", () => {
+    const { exitCode, stdout } = runCli("ingest", "--help");
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("Who is featured (required, at least one)");
+    expect(stdout).toContain("Their role (required per person)");
+    expect(stdout).toContain("Profile URLs (required per person)");
+    expect(stdout).toContain("Bio and background (required per person)");
+    expect(stdout).toContain("Venue name (required)");
+    expect(stdout).toContain("City name (required)");
+    expect(stdout).toContain("Google Places ID (required)");
+    expect(stdout).toContain("Event name (required)");
+    expect(stdout).toContain("ISO 8601 datetime (required)");
+    expect(stdout).toContain("Kind of event (required)");
+    expect(stdout).toContain("Source pages (required, 2+)");
+    expect(stdout).toContain('required unless price is "Free"');
+  });
+
+  it("rejects thin research payload with audit findings in dry-run", async () => {
     const researchFile = join(tmpdir(), `lp-test-${Date.now()}.json`);
     await writeFile(researchFile, JSON.stringify({
       featured: [],
       event: { title: "Test" },
     }));
 
-    const { exitCode, stderr } = runCli("ingest", "../../README.md", "--research", researchFile, "--dry-run");
+    const { exitCode, stdout } = runCli("ingest", "../../README.md", "--research", researchFile, "--dry-run");
     expect(exitCode).toBe(1);
-    expect(stderr).toContain("audit failed");
-    expect(stderr).toContain("featured");
-    expect(stderr).toContain("Fix these issues");
+    expect(stdout).toContain("Dry run failed");
+    expect(stdout).toContain("Title:     Test");
+    expect(stdout).toContain("audit failed");
+    expect(stdout).toContain("featured");
+    expect(stdout).toContain("Fix these issues");
   });
 
   it("outputs structured audit findings with --json", async () => {

package/src/index.ts

@@ -5,9 +5,9 @@ import { stdin, stdout } from "node:process";
 import { hasOption, parseArgv, readNumberOption, readStringArrayOption, readStringOption } from "./lib/argv";
 import { requireToken } from "./lib/auth";
 import { toFrontendBaseUrl } from "./lib/api-url";
-import { fetchDrafts, searchCliEvents } from "./lib/cli-read-client";
+import { fetchDrafts, fetchEditable, patchEntity, patchEvent, searchCliEvents } from "./lib/cli-read-client";
 import { DRAFT_STATUSES } from "./lib/cli-read-types";
-import type { DraftListItem, DraftStatus, SearchEventCard } from "./lib/cli-read-types";
+import type { DraftListItem, DraftStatus, EditableEntity, EditableResult, SearchEventCard } from "./lib/cli-read-types";
 import {
   deleteCredentials,
   getCredentialsPath,
@@ -17,7 +17,7 @@ import {
 } from "./lib/credentials";
 import { loginWithToken } from "./lib/login";
 import { exitCodeForError, printError } from "./lib/output";
-import { auditResearchPayload, formatAuditFindings } from "./lib/research-audit";
+import { type AuditResult, auditResearchPayload, formatAuditFindings } from "./lib/research-audit";
 import { readResearchPayload } from "./lib/research-reader";
 import {
   generateResearchSkeleton,
@@ -25,8 +25,10 @@ import {
   stitchResearchContext,
 } from "./lib/research-schema";
 import { isLikelyCliToken } from "./lib/token";
+import type { ResearchPayload } from "./lib/research-schema";
 import {
   type UploadPosterResult,
+  type UploadDryRunResult,
   type DraftResult,
   uploadPoster,
   createDraft,
@@ -66,6 +68,9 @@ async function main(argv: string[]): Promise<void> {
       case "drafts":
         await runDrafts(parsed);
         break;
+      case "edit":
+        await runEdit(parsed);
+        break;
       default:
         throw new Error(`Unknown command: ${command}. Run \`localpulse --help\` for usage.`);
     }
@@ -191,8 +196,38 @@ async function runIngest(parsed: ReturnType<typeof parseArgv>): Promise<void> {
 
   const payload = await readResearchPayload(researchPath);
   const jsonOutput = hasOption(parsed, "json");
+  const dryRun = hasOption(parsed, "dry-run");
+
+  const mapped = mapResearchToUploadFields(payload);
+  const uploadFields = {
+    urls: readStringArrayOption(parsed, "urls") ?? mapped.urls,
+    city: readStringOption(parsed, "city") ?? mapped.city,
+    venuePlaceId: readStringOption(parsed, "google-place-id") ?? mapped.venuePlaceId,
+    ticketUrl: readStringOption(parsed, "ticket-url") ?? mapped.ticketUrl,
+    title: readStringOption(parsed, "title") ?? mapped.title,
+    datetime: readStringOption(parsed, "date") ?? mapped.datetime,
+    venue: readStringOption(parsed, "venue") ?? mapped.venue,
+  };
 
   const audit = auditResearchPayload(payload);
+
+  if (dryRun) {
+    const result = {
+      dry_run: true as const,
+      valid: true as const,
+      file,
+      extra_media_count: readStringArrayOption(parsed, "extra-media")?.length ?? 0,
+      api_url: (await resolveApiUrl()),
+    };
+    if (jsonOutput) {
+      stdout.write(`${JSON.stringify(buildDryRunJsonResult(payload, uploadFields, result, audit))}\n`);
+    } else {
+      stdout.write(formatDryRunSummary(payload, uploadFields, result, audit));
+    }
+    if (!audit.pass) process.exitCode = 1;
+    return;
+  }
+
   if (!audit.pass) {
     if (jsonOutput) {
       stdout.write(`${JSON.stringify({ audit_failed: true, findings: audit.findings })}\n`);
@@ -203,42 +238,21 @@ async function runIngest(parsed: ReturnType<typeof parseArgv>): Promise<void> {
     return;
   }
 
-  const mapped = mapResearchToUploadFields(payload);
   const stitched = stitchResearchContext(payload);
   const explicitContext = readStringOption(parsed, "context");
   const context = [stitched, explicitContext].filter(Boolean).join("\n\n") || undefined;
 
   const apiUrl = await resolveApiUrl();
-  const dryRun = hasOption(parsed, "dry-run");
   const force = hasOption(parsed, "force");
-  const token = dryRun ? "" : await requireToken();
+  const token = await requireToken();
 
   const uploadOptions = {
     file,
-    urls: readStringArrayOption(parsed, "urls") ?? mapped.urls,
-    city: readStringOption(parsed, "city") ?? mapped.city,
-    venuePlaceId: readStringOption(parsed, "google-place-id") ?? mapped.venuePlaceId,
+    ...uploadFields,
     context,
-    ticketUrl: readStringOption(parsed, "ticket-url") ?? mapped.ticketUrl,
-    title: readStringOption(parsed, "title") ?? mapped.title,
-    datetime: readStringOption(parsed, "date") ?? mapped.datetime,
-    venue: readStringOption(parsed, "venue") ?? mapped.venue,
     extraMedia: readStringArrayOption(parsed, "extra-media"),
-    dryRun,
   };
 
-  if (dryRun) {
-    const result = await uploadPoster(apiUrl, token, uploadOptions);
-    if ("dry_run" in result) {
-      if (jsonOutput) {
-        stdout.write(`${JSON.stringify(result)}\n`);
-      } else {
-        stdout.write(`Dry run passed: ${result.file} (${result.extra_media_count} extra media)\n`);
-      }
-    }
-    return;
-  }
-
   if (force) {
     const result = await uploadPoster(apiUrl, token, uploadOptions);
     if (!("dry_run" in result)) {
@@ -309,6 +323,92 @@ function printIngestResult(result: UploadPosterResult): void {
   }
 }
 
+type DryRunUploadOptions = {
+  title?: string;
+  datetime?: string;
+  venue?: string;
+  city?: string;
+  venuePlaceId?: string;
+  urls?: string[];
+  ticketUrl?: string;
+};
+
+function formatDryRunSummary(
+  payload: ResearchPayload,
+  opts: DryRunUploadOptions,
+  result: UploadDryRunResult,
+  audit: AuditResult,
+): string {
+  const header = audit.pass
+    ? `Dry run passed: ${result.file} (${result.extra_media_count} extra media)`
+    : `Dry run failed: ${result.file} (${audit.findings.length} issue${audit.findings.length === 1 ? "" : "s"})`;
+
+  const lines: string[] = [header];
+
+  if (opts.title) lines.push(`  Title:     ${opts.title}`);
+  if (opts.datetime) lines.push(`  Date:      ${opts.datetime}`);
+
+  if (opts.venue) {
+    let venueStr = opts.venue;
+    if (opts.city) venueStr += ` (${opts.city})`;
+    if (opts.venuePlaceId) venueStr += ` [${opts.venuePlaceId}]`;
+    lines.push(`  Venue:     ${venueStr}`);
+  }
+
+  if (payload.featured?.length) {
+    const names = payload.featured.map((p) => p.name).join(", ");
+    lines.push(`  Featured:  ${payload.featured.length} (${names})`);
+  }
+
+  if (payload.organizer?.name) {
+    lines.push(`  Organizer: ${payload.organizer.name}`);
+  }
+
+  if (opts.urls?.length) {
+    lines.push(`  URLs:      ${opts.urls.length} source(s)`);
+  }
+
+  if (opts.ticketUrl) lines.push(`  Ticket:    ${opts.ticketUrl}`);
+
+  if (audit.pass) {
+    lines.push("  Audit:     passed (0 issues)");
+  } else {
+    lines.push("");
+    lines.push(formatAuditFindings(audit.findings));
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+function buildDryRunJsonResult(
+  payload: ResearchPayload,
+  opts: DryRunUploadOptions,
+  result: UploadDryRunResult,
+  audit: AuditResult,
+): Record<string, unknown> {
+  return {
+    ...result,
+    parsed: {
+      title: opts.title ?? null,
+      datetime: opts.datetime ?? null,
+      venue: opts.venue ?? null,
+      city: opts.city ?? null,
+      venue_place_id: opts.venuePlaceId ?? null,
+      featured_count: payload.featured?.length ?? 0,
+      featured_names: payload.featured?.map((p) => p.name) ?? [],
+      organizer: payload.organizer?.name ?? null,
+      urls_count: opts.urls?.length ?? 0,
+      ticket_url: opts.ticketUrl ?? null,
+    },
+    audit: {
+      pass: audit.pass,
+      issues: audit.findings.length,
+      ...(audit.findings.length ? { findings: audit.findings } : {}),
+    },
+  };
+}
+
 async function runSearch(parsed: ReturnType<typeof parseArgv>): Promise<void> {
   if (hasOption(parsed, "help")) {
     stdout.write(searchHelp());
@@ -425,6 +525,143 @@ function printDraftListItem(draft: DraftListItem, baseUrl: string): void {
   stdout.write(`  ${baseUrl}/publish/edit/${draft.id}\n`);
 }
 
+// ---------------------------------------------------------------------------
+// edit command
+// ---------------------------------------------------------------------------
+
+async function runEdit(parsed: ReturnType<typeof parseArgv>): Promise<void> {
+  if (hasOption(parsed, "help")) {
+    stdout.write(editHelp());
+    return;
+  }
+
+  const subcommand = parsed.positionals[0];
+
+  if (!subcommand) {
+    throw new Error("Usage: localpulse edit <poster_id> [options]. Run `localpulse edit --help` for details.");
+  }
+
+  const jsonOutput = hasOption(parsed, "json");
+  const apiUrl = await resolveApiUrl();
+  const token = await requireToken();
+  const posterId = subcommand;
+
+  // If --set is present, this is an update; otherwise show editable fields
+  const setValues = readStringArrayOption(parsed, "set");
+  const entityId = readStringOption(parsed, "entity");
+
+  if (setValues && setValues.length > 0) {
+    const fields = parseSetFlags(setValues);
+
+    if (entityId) {
+      const result = await patchEntity(apiUrl, token, posterId, entityId, fields);
+      if (jsonOutput) {
+        stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      } else {
+        stdout.write(`Entity ${entityId} updated.\n`);
+      }
+    } else {
+      const result = await patchEvent(apiUrl, token, posterId, fields);
+      if (jsonOutput) {
+        stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+      } else {
+        stdout.write("Event updated.\n");
+      }
+    }
+    return;
+  }
+
+  // Default: show editable fields
+  const editable = await fetchEditable(apiUrl, token, posterId);
+  if (jsonOutput) {
+    stdout.write(`${JSON.stringify(editable, null, 2)}\n`);
+    return;
+  }
+  printEditable(editable);
+}
+
+function parseSetFlags(pairs: string[]): Record<string, unknown> {
+  const fields: Record<string, unknown> = {};
+  for (const pair of pairs) {
+    const eqIdx = pair.indexOf("=");
+    if (eqIdx === -1) {
+      throw new Error(`Invalid --set format: "${pair}". Expected key=value (e.g. --set title="New Title").`);
+    }
+    const key = pair.slice(0, eqIdx).trim();
+    const rawValue = pair.slice(eqIdx + 1);
+    if (!key) {
+      throw new Error(`Empty key in --set: "${pair}".`);
+    }
+    fields[key] = parseFieldValue(rawValue);
+  }
+  return fields;
+}
+
+function parseFieldValue(raw: string): unknown {
+  // Boolean
+  if (raw === "true") return true;
+  if (raw === "false") return false;
+  // Null
+  if (raw === "null") return null;
+  // JSON array or object
+  if ((raw.startsWith("[") && raw.endsWith("]")) || (raw.startsWith("{") && raw.endsWith("}"))) {
+    try { return JSON.parse(raw); } catch { /* fall through to string */ }
+  }
+  // String (default)
+  return raw;
+}
+
+function printEditable(editable: EditableResult): void {
+  const { event, entities, media } = editable;
+
+  stdout.write(`Event: ${event.title ?? "(no title)"}\n`);
+  stdout.write(`Poster: ${editable.poster_id}\n\n`);
+
+  stdout.write("Event fields:\n");
+  const fieldOrder: (keyof typeof event)[] = [
+    "title", "description", "event_datetime", "event_datetimes",
+    "location", "venue_city", "ticketing_url", "pricing",
+    "is_cancelled", "is_sold_out", "is_postponed",
+    "event_type", "overall_theme",
+    "atmosphere_tags", "genre_tags", "vibe_tags", "type_tags",
+    "lineup_text", "description_paragraphs", "embed_urls",
+  ];
+  for (const key of fieldOrder) {
+    const value = event[key];
+    if (value === null || value === undefined) continue;
+    const display = Array.isArray(value) ? JSON.stringify(value) :
+      typeof value === "object" ? JSON.stringify(value) : String(value);
+    // Truncate long values for readability
+    const truncated = display.length > 120 ? `${display.slice(0, 117)}...` : display;
+    stdout.write(`  ${key}: ${truncated}\n`);
+  }
+
+  if (entities.length > 0) {
+    stdout.write("\nEntities:\n");
+    for (const entity of entities) {
+      const role = entity.event_role ? ` (${entity.event_role})` : "";
+      stdout.write(`  ${entity.entity_id}  ${entity.name}${role}  [${entity.entity_type}]\n`);
+    }
+  }
+
+  if (media.length > 0) {
+    stdout.write("\nMedia:\n");
+    for (const item of media) {
+      const primary = item.is_primary ? " [primary]" : "";
+      stdout.write(`  ${item.id}  ${item.media_type}${primary}\n`);
+    }
+  }
+
+  stdout.write("\nTo update, use --set:\n");
+  stdout.write(`  localpulse edit ${editable.poster_id} --set title="New Title"\n`);
+  stdout.write(`  localpulse edit ${editable.poster_id} --set is_sold_out=true\n`);
+  stdout.write(`  localpulse edit ${editable.poster_id} --set 'genre_tags=["techno","house"]'\n`);
+  if (entities.length > 0) {
+    const first = entities[0];
+    stdout.write(`  localpulse edit ${editable.poster_id} --entity ${first.entity_id} --set event_role="headliner"\n`);
+  }
+}
+
 async function resolveLoginToken(explicitToken?: string): Promise<string> {
   if (explicitToken?.trim()) {
     return explicitToken.trim();
@@ -469,6 +706,7 @@ Commands:
   ingest   Ingest an event poster into Local Pulse
   search   Search upcoming events
   drafts   List your submission drafts
+  edit     View and update published event fields
   auth     Login and logout
 
 Options:
@@ -484,6 +722,8 @@ Quick start:
   localpulse auth login --token <token>
   localpulse search "amsterdam"
   localpulse ingest poster.jpg --research data.json
+  localpulse edit <poster_id>
+  localpulse edit <poster_id> --set title="New Title"
 `;
 }
 
@@ -571,34 +811,38 @@ Research payload:
   ✓ All featured people as separate entries (support acts, guest chefs, co-hosts)
   ✓ Discover unlisted performers via Instagram tags (support acts, guest hosts)
 
-  featured[]              Who is featured — performers, chefs, hosts, speakers
+  featured[]              Who is featured (required, at least one)
     .name                 Full name (required per person)
-    .type                 Their role: "DJ", "chef", "band", "host", "speaker",
-                          "visual artist", "cook"
+    .type                 Their role (required per person): "DJ", "chef", "band",
+                          "host", "speaker", "visual artist", "cook"
     .genre                Style, genre, or cuisine: "techno", "jazz", "Kerala"
-    .socials[]            Profile URLs: Instagram, RA, Bandcamp, personal site
-    .context              Anything else: bio, notable work, affiliations
+    .socials[]            Profile URLs (required per person): Instagram, RA,
+                          Bandcamp, personal site
+    .context              Bio and background (required per person): notable work,
+                          affiliations, links from their profiles
 
   organizer               Who is putting on the event
     .name                 Collective, promoter, or brand name (required)
-    .socials[]            Profile URLs
+    .socials[]            Profile URLs (required)
     .context              History, reputation, previous events, affiliation
 
   venue                   Where the event happens
-    .name                 Venue name
-    .city                 City name
-    .google_place_id      Google Places ID (skips venue matching if provided)
+    .name                 Venue name (required)
+    .city                 City name (required)
+    .google_place_id      Google Places ID (required); search Google Maps for
+                          "{venue} {city}" and extract place ID from share URL
     .context              Capacity, room layout, vibe, accessibility, location tips
 
   event                   What the event is
-    .title                Event name
-    .date                 ISO 8601 datetime (e.g. "2026-03-14T22:00:00+01:00")
-    .type                 Kind of event: "club night", "festival", "exhibition",
-                          "workshop", "concert", "open air", "listening session",
-                          "pop-up dinner", "food event", "tasting", "market"
+    .title                Event name (required)
+    .date                 ISO 8601 datetime (required), e.g. "2026-03-14T22:00:00+01:00"
+    .type                 Kind of event (required): "club night", "festival",
+                          "exhibition", "workshop", "concert", "open air",
+                          "listening session", "pop-up dinner", "food event",
+                          "tasting", "market"
     .price                Ticket price info: "€15-25", "Free", "Sold out"
-    .urls[]               Source pages: RA, venue site, Facebook event
-    .ticket_url           Direct ticketing / purchase URL
+    .urls[]               Source pages (required, 2+): RA, venue site, Facebook event
+    .ticket_url           Direct ticketing URL (required unless price is "Free")
     .context              Schedule, door policy, age restrictions, special notes
 
   context                 Anything that doesn't fit above: background on the
@@ -664,6 +908,69 @@ Examples:
 `;
 }
 
+function editHelp(): string {
+  return `Usage: localpulse edit <poster_id> [options]
+
+View and update published event fields. Without --set, prints the current
+editable values. With --set, applies partial updates to the event or entity.
+
+Arguments:
+  poster_id               Poster UUID of the published event
+
+View current fields:
+  localpulse edit <poster_id>              Show all editable fields
+  localpulse edit <poster_id> --json       Output as structured JSON
+
+Update event fields:
+  --set key=value         Set a field (repeatable for multiple fields)
+  --json                  Output full updated event detail as JSON
+
+  Values are auto-parsed: true/false → boolean, null → null,
+  JSON arrays/objects → parsed, everything else → string.
+
+Update entity fields:
+  --entity <entity_id>    Target a specific entity (performer/venue)
+  --set key=value         Set entity field (description, event_role, social_media)
+
+Options:
+  --json                  Output structured JSON
+  --help                  Show this help
+
+Event fields:
+  title, description, event_datetime, event_datetimes, location,
+  ticketing_url, pricing, is_cancelled, is_sold_out, is_postponed,
+  atmosphere_tags, genre_tags, vibe_tags, type_tags, event_type,
+  overall_theme, venue_city, lineup_text, embed_urls,
+  description_paragraphs
+
+Entity fields:
+  description, event_role, social_media
+
+Examples:
+  # View editable fields
+  localpulse edit abc-123
+
+  # Update event title
+  localpulse edit abc-123 --set title="Updated Event Name"
+
+  # Mark as sold out
+  localpulse edit abc-123 --set is_sold_out=true
+
+  # Update multiple fields
+  localpulse edit abc-123 --set title="New Name" --set is_cancelled=false
+
+  # Set genre tags (JSON array)
+  localpulse edit abc-123 --set 'genre_tags=["techno","house"]'
+
+  # Update entity
+  localpulse edit abc-123 --entity 42 --set event_role="headliner"
+
+  # JSON output for programmatic use
+  localpulse edit abc-123 --json
+  localpulse edit abc-123 --set title="X" --json
+`;
+}
+
 function draftsHelp(): string {
   return `Usage: localpulse drafts [options]
 

package/src/lib/cli-read-client.ts

@@ -9,6 +9,7 @@ import type {
   CliInfoResult,
   DraftListItem,
   DraftStatus,
+  EditableResult,
   SearchEventsResult,
 } from "./cli-read-types";
 
@@ -122,6 +123,78 @@ export async function fetchDrafts(
   return parsed as DraftListItem[];
 }
 
+export async function fetchEditable(
+  apiUrl: string,
+  token: string,
+  posterId: string,
+): Promise<EditableResult> {
+  const payload = await authedJson(
+    apiUrl, token, "GET",
+    `/api/cli/events/${encodeURIComponent(posterId)}/editable`,
+    "Fetch editable failed",
+  );
+  return payload as unknown as EditableResult;
+}
+
+export async function patchEvent(
+  apiUrl: string,
+  token: string,
+  posterId: string,
+  fields: Record<string, unknown>,
+): Promise<ApiResponseBody> {
+  return authedJson(
+    apiUrl, token, "PATCH",
+    `/api/events/${encodeURIComponent(posterId)}`,
+    "Patch event failed",
+    fields,
+  );
+}
+
+export async function patchEntity(
+  apiUrl: string,
+  token: string,
+  posterId: string,
+  entityId: string,
+  fields: Record<string, unknown>,
+): Promise<ApiResponseBody> {
+  return authedJson(
+    apiUrl, token, "PATCH",
+    `/api/poster/${encodeURIComponent(posterId)}/entity/${encodeURIComponent(entityId)}`,
+    "Patch entity failed",
+    fields,
+  );
+}
+
+async function authedJson(
+  apiUrl: string,
+  token: string,
+  method: string,
+  path: string,
+  fallbackMessage: string,
+  body?: Record<string, unknown>,
+): Promise<ApiResponseBody> {
+  const headers: Record<string, string> = {
+    accept: "application/json",
+    authorization: `Bearer ${token}`,
+  };
+  if (body) headers["content-type"] = "application/json";
+
+  const response = await fetch(buildApiUrl(apiUrl, path), {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  const payload = await parseApiJsonBody(response);
+  if (!response.ok) {
+    throw new CliApiError(
+      extractApiErrorMessage(payload, `${fallbackMessage} (${response.status})`),
+      { httpStatus: response.status, body: payload },
+    );
+  }
+  return payload;
+}
+
 function parseSearchEventsResult(payload: ApiResponseBody): SearchEventsResult {
   const result = payload as Partial<SearchEventsResult>;
   if (

package/src/lib/cli-read-types.ts

@@ -37,3 +37,57 @@ export type DraftListItem = {
   created_at: string;
   updated_at: string;
 };
+
+// ---------------------------------------------------------------------------
+// Edit types
+// ---------------------------------------------------------------------------
+
+export type EditableEventFields = {
+  title: string | null;
+  description: string | null;
+  event_datetime: string | null;
+  event_datetimes: string[] | null;
+  location: string | null;
+  ticketing_url: string | null;
+  pricing: Record<string, unknown> | null;
+  is_cancelled: boolean;
+  is_sold_out: boolean;
+  is_postponed: boolean;
+  atmosphere_tags: string[] | null;
+  genre_tags: string[] | null;
+  vibe_tags: string[] | null;
+  type_tags: string[] | null;
+  event_type: string | null;
+  overall_theme: string | null;
+  venue_city: string | null;
+  description_paragraphs: string[] | null;
+  lineup_text: string | null;
+  embed_urls: Array<{ url: string; platform: string; context?: string }> | null;
+};
+
+export type EditableEntity = {
+  entity_id: string | number;
+  name: string;
+  entity_type: string;
+  description: string | null;
+  event_role: string | null;
+  social_media: Record<string, string> | null;
+};
+
+export type EditableMediaItem = {
+  id: string;
+  poster_id: string;
+  media_type: string;
+  sort_order: number;
+  is_primary: boolean;
+  media_url: string | null;
+  preview_url: string | null;
+};
+
+export type EditableResult = {
+  poster_id: string;
+  event: EditableEventFields;
+  entities: EditableEntity[];
+  media: EditableMediaItem[];
+  endpoints: Record<string, string>;
+};