ticketlens 0.1.0

package/skills/jtb/scripts/lib/schedule-wizard.mjs

@@ -0,0 +1,153 @@
+import { writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, platform as osPlatform } from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+const SCHEDULE_URL = 'https://api.ticketlens.dev/v1/schedule';
+
+/**
+ * Build a macOS LaunchAgent plist string.
+ */
+export function buildPlist({ hour, minute, ticketlensBin }) {
+  if (!Number.isInteger(hour) || !Number.isInteger(minute)) {
+    throw new Error('hour and minute must be integers');
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>io.ticketlens.digest</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${ticketlensBin}</string>
+    <string>triage</string>
+    <string>--digest</string>
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>${hour}</integer>
+    <key>Minute</key>
+    <integer>${minute}</integer>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>/tmp/ticketlens-digest.log</string>
+  <key>StandardErrorPath</key>
+  <string>/tmp/ticketlens-digest.log</string>
+</dict>
+</plist>`;
+}
+
+/**
+ * Build a crontab line for Linux.
+ */
+export function buildCronLine({ hour, minute, ticketlensBin }) {
+  return `${minute} ${hour} * * * ${ticketlensBin} triage --digest >> /tmp/ticketlens-digest.log 2>&1`;
+}
+
+/**
+ * Register a digest schedule with the backend and create a local cron/LaunchAgent job.
+ */
+export async function runScheduleWizard({
+  answers,
+  fetcher = globalThis.fetch,
+  licenseKey,
+  configDir,
+  platform = osPlatform(),
+  writeLocalJob = defaultWriteLocalJob,
+  timeoutMs = 10_000,
+}) {
+  const { time, email, timezone } = answers;
+  const [hourStr, minuteStr] = time.split(':');
+  const hour = parseInt(hourStr, 10);
+  const minute = parseInt(minuteStr, 10);
+
+  const res = await fetcher(SCHEDULE_URL, {
+    method: 'POST',
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${licenseKey}`,
+    },
+    body: JSON.stringify({ email, timezone, deliverAt: time }),
+  });
+
+  if (!res.ok) {
+    const err = new Error(`Schedule API error ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
+
+  const data = await res.json();
+
+  const ticketlensBin = resolveTicketlensBin();
+  const content = platform === 'darwin'
+    ? buildPlist({ hour, minute, ticketlensBin })
+    : buildCronLine({ hour, minute, ticketlensBin });
+
+  writeLocalJob(content, platform);
+
+  return data;
+}
+
+export async function runScheduleStop({ fetcher = globalThis.fetch, licenseKey, platform = osPlatform() }) {
+  const res = await fetcher(SCHEDULE_URL, {
+    method: 'DELETE',
+    signal: AbortSignal.timeout(10_000),
+    headers: { 'Authorization': `Bearer ${licenseKey}` },
+  });
+  if (!res.ok) throw new Error(`Schedule API error ${res.status}`);
+
+  if (platform === 'darwin') {
+    const plistPath = join(homedir(), 'Library', 'LaunchAgents', 'io.ticketlens.digest.plist');
+    spawnSync('launchctl', ['unload', plistPath], { encoding: 'utf8' });
+    try { unlinkSync(plistPath); } catch { /* already removed */ }
+  } else {
+    const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8' }).stdout ?? '';
+    const updated = existing.replace(/.*ticketlens triage --digest.*\n?/g, '');
+    const tmp = `/tmp/ticketlens-crontab-${Date.now()}`;
+    writeFileSync(tmp, updated, 'utf8');
+    spawnSync('crontab', [tmp], { encoding: 'utf8' });
+  }
+
+  process.stdout.write('✔ Digest schedule removed.\n');
+}
+
+export async function runScheduleStatus({ fetcher = globalThis.fetch, licenseKey }) {
+  const res = await fetcher(SCHEDULE_URL, {
+    method: 'GET',
+    signal: AbortSignal.timeout(10_000),
+    headers: { 'Authorization': `Bearer ${licenseKey}` },
+  });
+  if (!res.ok) {
+    process.stdout.write('No active digest schedule found.\n');
+    return;
+  }
+  const data = await res.json();
+  process.stdout.write(`Digest schedule: ${data.deliverAt} ${data.timezone}\n`);
+  process.stdout.write(`Last delivered:  ${data.lastDeliveredAt ?? 'never'}\n`);
+  process.stdout.write(`Next delivery:   ${data.nextDelivery}\n`);
+}
+
+function resolveTicketlensBin() {
+  const which = spawnSync('which', ['ticketlens'], { encoding: 'utf8' });
+  if (which.status === 0 && which.stdout.trim()) return which.stdout.trim();
+  return `${homedir()}/.npm/bin/ticketlens`;
+}
+
+function defaultWriteLocalJob(content, platform) {
+  if (platform === 'darwin') {
+    const launchAgentsDir = join(homedir(), 'Library', 'LaunchAgents');
+    mkdirSync(launchAgentsDir, { recursive: true });
+    const plistPath = join(launchAgentsDir, 'io.ticketlens.digest.plist');
+    writeFileSync(plistPath, content, 'utf8');
+    spawnSync('launchctl', ['load', plistPath], { encoding: 'utf8' });
+  } else {
+    const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8' }).stdout ?? '';
+    const updated = existing.replace(/.*ticketlens triage --digest.*/g, '').trimEnd() + '\n' + content + '\n';
+    const tmp = `/tmp/ticketlens-crontab-${Date.now()}`;
+    writeFileSync(tmp, updated, 'utf8');
+    spawnSync('crontab', [tmp], { encoding: 'utf8' });
+  }
+}

package/skills/jtb/scripts/lib/select-prompt.mjs

@@ -0,0 +1,106 @@
+/**
+ * Reusable raw-mode selector primitive and simple promptSelect helper.
+ * Used by profile-picker.mjs, profile-switcher.mjs, and init-wizard.mjs.
+ */
+
+import { createStyler } from './ansi.mjs';
+
+/**
+ * Low-level raw-mode selector. Handles stdin lifecycle, arrow keys, Enter/Esc.
+ * Calls renderFn(selectedIndex) on each state change; renderFn must write its
+ * output to the stream and return the number of lines written.
+ *
+ * @param {object} opts
+ * @param {number} opts.count
+ * @param {number} [opts.initialIndex=0]
+ * @param {(index: number) => number} opts.renderFn
+ * @param {NodeJS.WriteStream} [opts.stream=process.stderr]
+ * @returns {Promise<number|null>} selected index, or null if cancelled
+ */
+export function runRawSelect({ count, initialIndex = 0, renderFn, stream = process.stderr }) {
+  if (!stream.isTTY || !process.stdin.setRawMode) return Promise.resolve(null);
+
+  let selected = initialIndex;
+  let lineCount = 0;
+
+  function erase() {
+    for (let i = 0; i < lineCount; i++) stream.write('\x1b[A\r\x1b[2K');
+  }
+
+  function render() {
+    erase();
+    lineCount = renderFn(selected);
+  }
+
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+
+    function cleanup() {
+      stream.write('\x1b[?25h');
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener('data', onData);
+    }
+
+    function onData(buf) {
+      const key = buf.toString();
+      if (key === '\x03' || key === '\x1b' || key === 'q' || key === 'Q') {
+        cleanup(); erase(); resolve(null); return;
+      }
+      if (key === '\x1b[A' && selected > 0) { selected--; render(); return; }
+      if (key === '\x1b[B' && selected < count - 1) { selected++; render(); return; }
+      if (key === '\r' || key === '\n') { cleanup(); erase(); resolve(selected); return; }
+    }
+
+    stream.write('\x1b[?25l');
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    stdin.on('data', onData);
+    lineCount = renderFn(selected);
+  });
+}
+
+/**
+ * Simple arrow-key list selector with ❯ marker and optional sublabels.
+ *
+ * @param {Array<{label: string, sublabel?: string}>} items
+ * @param {object} [opts]
+ * @param {number} [opts.initialIndex=0]
+ * @param {string} [opts.hint]
+ * @param {NodeJS.WriteStream} [opts.stream]
+ * @returns {Promise<number|null>}
+ */
+export function promptSelect(items, opts = {}) {
+  const {
+    stream = process.stderr,
+    hint = '↑/↓ select   Enter confirm   Esc cancel',
+    initialIndex = 0,
+  } = opts;
+
+  const s = createStyler({ isTTY: stream.isTTY });
+
+  if (!stream.isTTY || !process.stdin.setRawMode) {
+    for (const item of items) stream.write(`    ${s.cyan('›')} ${item.label}\n`);
+    return Promise.resolve(null);
+  }
+
+  function renderFn(selected) {
+    const lines = [];
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const isSelected = i === selected;
+      const marker = isSelected ? s.blue('❯') : ' ';
+      const label = isSelected ? s.bold(s.blue(item.label)) : item.label;
+      lines.push(`    ${marker} ${label}`);
+      if (item.sublabel) lines.push(`      ${s.dim(item.sublabel)}`);
+    }
+    lines.push('');
+    lines.push(`  ${s.dim(hint)}`);
+    stream.write(lines.join('\n') + '\n');
+    return lines.length;
+  }
+
+  return runRawSelect({ count: items.length, initialIndex, renderFn, stream });
+}

package/skills/jtb/scripts/lib/spinner.mjs

@@ -0,0 +1,44 @@
+/**
+ * Zero-dependency terminal spinner for CLI progress feedback.
+ * Writes to stderr so stdout stays clean for piped output.
+ * Only animates when stderr is a TTY; silently no-ops otherwise.
+ */
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const INTERVAL = 80; // ms per frame
+
+export function createSpinner(message, { stream = process.stderr } = {}) {
+  const isTTY = stream.isTTY;
+  let timer = null;
+  let frame = 0;
+
+  return {
+    start() {
+      if (!isTTY || timer) return this;
+      stream.write('\x1b[?25l'); // hide cursor
+      timer = setInterval(() => {
+        stream.write(`\r\x1b[K${FRAMES[frame]} ${message}`);
+        frame = (frame + 1) % FRAMES.length;
+      }, INTERVAL);
+      return this;
+    },
+
+    update(newMessage) {
+      message = newMessage;
+      return this;
+    },
+
+    stop(finalMessage) {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+        stream.write('\r\x1b[K'); // clear line
+        stream.write('\x1b[?25h'); // show cursor
+      }
+      if (finalMessage && isTTY) {
+        stream.write(finalMessage + '\n');
+      }
+      return this;
+    },
+  };
+}

package/skills/jtb/scripts/lib/styled-assembler.mjs

@@ -0,0 +1,183 @@
+import { createStyler } from './ansi.mjs';
+import { formatTable } from './table-formatter.mjs';
+import { formatSize } from './attachment-downloader.mjs';
+import { timeAgo, truncate, stripCr } from './config.mjs';
+
+function divWidth() {
+  return 30;
+}
+function halfDivWidth() {
+  return 15;
+}
+function statusColor(s, status) {
+  const st = (status || '').toLowerCase();
+  if (/done|closed|resolved|complete/.test(st)) return s.green(status);
+  if (/progress|review|testing|qa/.test(st)) return s.yellow(status);
+  return status;
+}
+
+export function styleTriageSummary(scoredTickets, opts = {}) {
+  const { staleDays = 5, baseUrl, styled = true } = opts;
+  const s = createStyler({ forceColor: styled, noColor: !styled });
+  const browseUrl = baseUrl ? baseUrl.replace(/\/$/, '') + '/browse/' : null;
+  const actionable = scoredTickets.filter(t => t.urgency !== 'clear');
+
+  if (actionable.length === 0) {
+    return s.green('All clear — no tickets need your attention right now.');
+  }
+
+  const needsResponse = actionable.filter(t => t.urgency === 'needs-response');
+  const aging = actionable.filter(t => t.urgency === 'aging');
+
+  const parts = [];
+  if (needsResponse.length > 0) parts.push(`${needsResponse.length} need response`);
+  if (aging.length > 0) parts.push(`${aging.length} aging`);
+
+  const sections = [];
+  sections.push(s.bold(`${actionable.length} tickets need attention`) + ' ' + s.dim(`(${parts.join(', ')})`) );
+
+  // Legend + base URL hint
+  const legendParts = [];
+  if (needsResponse.length > 0) legendParts.push(`${s.red('●')} needs response`);
+  if (aging.length > 0) legendParts.push(`${s.yellow('●')} aging`);
+  let legend = legendParts.join('    ');
+  if (browseUrl) legend += `\n${s.dim('Open:')} ${browseUrl}${s.dim('<key>')}`;
+  sections.push(legend);
+
+  const ticketCell = (key, colorFn) => {
+    return colorFn('●') + ' ' + key;
+  };
+
+  if (needsResponse.length > 0) {
+    const tableRows = needsResponse.map((t, i) => {
+      const ago = t.lastComment ? timeAgo(t.lastComment.created) : '';
+      const commenter = t.lastComment?.author ?? 'Unknown';
+      const snippet = t.lastComment?.body ? truncate(t.lastComment.body, 40) : '';
+      return [String(i + 1), ticketCell(t.ticketKey, s.red), truncate(t.summary, 45), t.status, commenter, ago, snippet];
+    });
+    const table = formatTable(
+      ['#', 'Ticket', 'Title', 'Status', 'From', 'When', 'Comment'],
+      tableRows,
+      { maxWidths: { 2: 45, 6: 40 } },
+    );
+    sections.push(table);
+  }
+
+  if (aging.length > 0) {
+    const agingOffset = needsResponse.length;
+    const tableRows = aging.map((t, i) => {
+      const days = t.daysSinceUpdate ?? '?';
+      return [String(agingOffset + i + 1), ticketCell(t.ticketKey, s.yellow), truncate(t.summary, 45), t.status, `${days}d`];
+    });
+    const table = formatTable(
+      ['#', 'Ticket', 'Title', 'Status', 'Stale'],
+      tableRows,
+      { maxWidths: { 2: 45 } },
+    );
+    sections.push(table);
+  }
+
+  return sections.join('\n\n');
+}
+
+export function styleBrief(ticket, codeRefs = null, opts = {}) {
+  const { styled = true } = opts;
+  const s = createStyler({ forceColor: styled, noColor: !styled });
+
+  const sections = [];
+
+  // Header: ticket key + summary
+  sections.push(s.bold(s.brand(`${ticket.key}: ${ticket.summary}`)));
+
+  // Metadata line
+  const meta = [
+    `${s.dim('Type:')} ${ticket.type}`,
+    `${s.dim('Status:')} ${statusColor(s, ticket.status)}`,
+    `${s.dim('Priority:')} ${ticket.priority}`,
+    `${s.dim('Assignee:')} ${ticket.assignee ?? 'Unassigned'}`,
+  ];
+  if (ticket.created) meta.push(`${s.dim('Created:')} ${ticket.created.split('T')[0]}`);
+  if (ticket.updated) meta.push(`${s.dim('Updated:')} ${ticket.updated.split('T')[0]}`);
+  sections.push(meta.join(s.dim('  ·  ')));
+
+  // Description
+  if (ticket.description) {
+    sections.push(`${s.bold(s.brand('Description'))}\n${s.dim('─'.repeat(divWidth()))}\n${stripCr(ticket.description)}`);
+  }
+
+  // Comments
+  if (ticket.comments?.length > 0) {
+    const commentLines = ticket.comments.map(c => {
+      const date = c.created ? c.created.split('T')[0] : 'unknown';
+      return `${s.brand(c.author)} ${s.dim(`(${date})`)}\n${stripCr(c.body)}`;
+    });
+    sections.push(`${s.bold(s.brand('Comments'))}\n${s.dim('─'.repeat(divWidth()))}\n${commentLines.join(`\n\n${s.dim('─'.repeat(halfDivWidth()))}\n`)}`);
+  }
+
+  // Linked tickets
+  if (ticket.linkedTicketDetails?.length > 0) {
+    const linkedSections = ticket.linkedTicketDetails.map(lt => {
+      const parts = [`${s.brand(lt.key)}: ${lt.summary}`, `${s.dim('Type:')} ${lt.type} | ${s.dim('Status:')} ${statusColor(s, lt.status)}`];
+      if (lt.description) parts.push(stripCr(lt.description));
+      if (lt.comments?.length > 0) {
+        const cmts = lt.comments.map(c => {
+          const date = c.created ? c.created.split('T')[0] : 'unknown';
+          return `${s.brand(c.author)} ${s.dim(`(${date})`)}: ${stripCr(c.body)}`;
+        });
+        parts.push(cmts.join('\n'));
+      }
+      return parts.join('\n');
+    });
+    sections.push(`${s.bold(s.brand('Linked Tickets'))}\n${s.dim('─'.repeat(divWidth()))}\n${linkedSections.join(`\n\n${s.dim('─'.repeat(halfDivWidth()))}\n`)}`);
+  }
+
+  // Code references
+  if (codeRefs) {
+    const categories = [
+      ['File Paths', codeRefs.filePaths],
+      ['Methods', codeRefs.methods],
+      ['Classes', codeRefs.classes],
+      ['Git SHAs', codeRefs.shas],
+      ['SVN Revisions', codeRefs.svnRevisions],
+      ['Branches', codeRefs.branches],
+      ['Namespaces', codeRefs.namespaces],
+    ];
+    const filled = categories
+      .filter(([, items]) => items?.length > 0)
+      .map(([label, items]) => `${s.dim(label + ':')} ${items.map(i => s.brand(i)).join(', ')}`);
+    if (filled.length > 0) {
+      sections.push(`${s.bold(s.brand('Code References'))}\n${s.dim('─'.repeat(divWidth()))}\n${filled.join('\n')}`);
+    }
+  }
+
+  if (ticket.attachments?.length > 0) {
+    const lines = ticket.attachments.map(a => {
+      const r = (ticket.localAttachments ?? []).find(x => x.filename === a.filename);
+      const sz = formatSize(a.size);
+      if (r?.localPath) {
+        const note = r.skipReason === 'cached' ? s.dim(', cached') : '';
+        return `  ${s.brand(r.localPath)}${note}  ${s.dim(a.filename + ', ' + sz)}`;
+      }
+      if (r?.skipReason === 'too-large') return `  ${a.filename}  ${s.dim(sz + ' — exceeds 10 MB limit')}`;
+      if (r?.skipReason === 'limit')     return `  ${a.filename}  ${s.dim(sz + ' — attachment limit reached')}`;
+      if (r?.skipReason === 'error')     return `  ${a.filename}  ${s.red('download failed: ' + r.error)}`;
+      return `  ${a.filename}  ${s.dim(sz)}`;
+    });
+    sections.push(`${s.bold(s.brand('Attachments'))}\n${s.dim('─'.repeat(divWidth()))}\n${lines.join('\n')}`);
+  }
+
+  const out = sections.join('\n\n');
+
+  if (!styled) return out;
+
+  const ANSI_RE = /\x1b\[[0-9;]*m/g;
+  const plainTextLength = out.replace(ANSI_RE, '').length;
+  const briefTokens = Math.ceil(plainTextLength / 4);
+  const ticketCount = 1 + (ticket.linkedTicketDetails?.length ?? 1);
+  const rawTokenEstimate = Math.max(12000, ticketCount * 8000);
+  const savings = Math.round((1 - briefTokens / rawTokenEstimate) * 100);
+  const savingsStr = savings > 0 ? ` · ~${savings}% vs raw API` : '';
+  const footer = s.dim(`  ○ ~${briefTokens} tokens loaded${savingsStr}  ·  --plain for pipe-safe output`);
+
+  return out + '\n\n' + footer;
+}

package/skills/jtb/scripts/lib/summarizer.mjs

@@ -0,0 +1,109 @@
+const ANTHROPIC_URL = 'https://api.anthropic.com/v1/messages';
+const OPENAI_URL = 'https://api.openai.com/v1/chat/completions';
+const CLOUD_URL = 'https://api.ticketlens.dev/v1/summarize';
+const PROMPT = 'Summarize this Jira ticket in 3 sentences. Focus on what matters most for implementation. Be concrete.\n\n';
+
+/**
+ * Summarize a ticket brief using BYOK or cloud mode.
+ * @param {object} opts
+ * @param {string} opts.brief - Markdown brief text
+ * @param {'byok'|'cloud'} opts.mode
+ * @param {object} [opts.credentials] - { anthropicApiKey?, openaiApiKey? }
+ * @param {string} [opts.licenseKey] - Required for cloud mode
+ * @param {Function} [opts.fetcher] - Injectable for tests (defaults to globalThis.fetch)
+ * @param {number} [opts.timeoutMs]
+ * @returns {Promise<string>} Summary text
+ */
+export async function summarize({ brief, mode, credentials = null, licenseKey = null, fetcher = globalThis.fetch, timeoutMs = 30_000 }) {
+  if (mode === 'byok') {
+    return byok({ brief, credentials, fetcher, timeoutMs });
+  }
+  return cloud({ brief, licenseKey, fetcher, timeoutMs });
+}
+
+async function byok({ brief, credentials, fetcher, timeoutMs }) {
+  const anthropicKey = credentials?.anthropicApiKey;
+  const openaiKey = credentials?.openaiApiKey;
+
+  if (!anthropicKey && !openaiKey) {
+    throw new Error('No API key found. Add ANTHROPIC_API_KEY or OPENAI_API_KEY to ~/.ticketlens/credentials.json');
+  }
+
+  if (anthropicKey) {
+    return callAnthropic({ brief, apiKey: anthropicKey, fetcher, timeoutMs });
+  }
+
+  return callOpenAi({ brief, apiKey: openaiKey, fetcher, timeoutMs });
+}
+
+async function callAnthropic({ brief, apiKey, fetcher, timeoutMs }) {
+  const res = await fetcher(ANTHROPIC_URL, {
+    method: 'POST',
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: {
+      'Content-Type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model: 'claude-haiku-4-5-20251001',
+      max_tokens: 256,
+      messages: [{ role: 'user', content: PROMPT + brief }],
+    }),
+  });
+
+  if (!res.ok) {
+    const err = new Error(`Anthropic API error ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
+
+  const data = await res.json();
+  return data.content[0].text;
+}
+
+async function callOpenAi({ brief, apiKey, fetcher, timeoutMs }) {
+  const res = await fetcher(OPENAI_URL, {
+    method: 'POST',
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model: 'gpt-4o-mini',
+      max_tokens: 256,
+      messages: [{ role: 'user', content: PROMPT + brief }],
+    }),
+  });
+
+  if (!res.ok) {
+    const err = new Error(`OpenAI API error ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
+
+  const data = await res.json();
+  return data.choices[0].message.content;
+}
+
+async function cloud({ brief, licenseKey, fetcher, timeoutMs }) {
+  const res = await fetcher(CLOUD_URL, {
+    method: 'POST',
+    signal: AbortSignal.timeout(timeoutMs),
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${licenseKey}`,
+    },
+    body: JSON.stringify({ brief }),
+  });
+
+  if (!res.ok) {
+    const err = new Error(`TicketLens API error ${res.status}`);
+    err.status = res.status;
+    throw err;
+  }
+
+  const data = await res.json();
+  return data.summary;
+}