ticketlens 0.1.0

package/skills/jtb/scripts/lib/interactive-list.mjs

@@ -0,0 +1,257 @@
+import { createStyler } from './ansi.mjs';
+import { spawn } from 'node:child_process';
+import { runSwitch } from './profile-switcher.mjs';
+import { timeAgo, truncate } from './config.mjs';
+
+const ESCAPE_RE = /\x1b\[[0-9;]*m|\x1b\]8;[^\x07]*\x07/g;
+const visLen = (str) => str.replace(ESCAPE_RE, '').length;
+
+function padRight(str, len) {
+  const pad = Math.max(0, len - visLen(str));
+  return str + ' '.repeat(pad);
+}
+
+/** Truncate a string to maxCols visible characters, preserving ANSI sequences. */
+function clipToWidth(str, maxCols) {
+  if (!maxCols || visLen(str) <= maxCols) return str;
+  let visible = 0;
+  let i = 0;
+  while (i < str.length && visible < maxCols) {
+    if (str[i] === '\x1b' && str[i + 1] === '[') {
+      const end = str.indexOf('m', i);
+      if (end !== -1) { i = end + 1; continue; }
+    }
+    if (str[i] === '\x1b' && str[i + 1] === ']') {
+      const end = str.indexOf('\x07', i);
+      if (end !== -1) { i = end + 1; continue; }
+    }
+    visible++;
+    i++;
+  }
+  return str.slice(0, i) + '\x1b[0m';
+}
+
+export function runInteractiveList(tickets, opts = {}) {
+  const { baseUrl, staleDays = 5, styled = true } = opts;
+  const browseUrl = baseUrl ? baseUrl.replace(/\/$/, '') + '/browse/' : null;
+  const s = createStyler({ forceColor: styled, noColor: !styled });
+
+  const actionable = tickets.filter(t => t.urgency !== 'clear');
+  if (actionable.length === 0) {
+    process.stdout.write(s.green('All clear — no tickets need your attention right now.') + '\n');
+    return Promise.resolve();
+  }
+
+  const needsResponse = actionable.filter(t => t.urgency === 'needs-response');
+  const aging = actionable.filter(t => t.urgency === 'aging');
+  const items = [...needsResponse, ...aging];
+
+  let selectedIndex = 0;
+  let scrollTop = 0;
+  let dynamicLineCount = 0; // track how many lines the dynamic section used last render
+
+  // Responsive column layout — re-evaluated on every render so terminal resizes are handled.
+  // Wide (≥150): all columns. Medium (≥100): no detail. Narrow (<100): key+title+status only.
+  function getColLayout() {
+    const w = process.stdout.columns || 120;
+    if (w >= 150) return { key: 12, title: 45, status: 14, from: 14, when: 8, detail: 35 };
+    if (w >= 100) return { key: 12, title: 35, status: 14, from: 14, when: 8, detail: 0  };
+    return            { key: 10, title: Math.max(20, w - 36), status: 12, from: 0, when: 0, detail: 0 };
+  }
+
+  function buildRow(ticket, index) {
+    const COL = getColLayout();
+    const isSelected = index === selectedIndex;
+    const isNR = ticket.urgency === 'needs-response';
+
+    const dot    = isNR ? s.red('\u25cf') : s.yellow('\u25cf');
+    const key    = padRight(ticket.ticketKey, COL.key);
+    const title  = padRight(truncate(ticket.summary, COL.title), COL.title);
+    const status = padRight(ticket.status, COL.status);
+
+    const parts = [`  ${dot}`, key, title, status];
+
+    if (COL.from > 0) {
+      const from = padRight(isNR ? (ticket.lastComment?.author ?? 'Unknown') : '', COL.from);
+      const when = padRight(isNR && ticket.lastComment ? timeAgo(ticket.lastComment.created) : '', COL.when);
+      parts.push(from, when);
+    }
+
+    if (COL.detail > 0) {
+      const detail = isNR
+        ? (ticket.lastComment?.body ? s.dim(truncate(ticket.lastComment.body, COL.detail)) : '')
+        : s.dim(`${ticket.daysSinceUpdate ?? '?'}d stale`);
+      parts.push(detail);
+    } else if (COL.from === 0 && !isNR) {
+      // Narrow, no detail col: append stale days compactly after status
+      parts.push(s.dim(`${ticket.daysSinceUpdate ?? '?'}d`));
+    }
+
+    const line = parts.join('   ');
+    return isSelected ? `\x1b[7m${line}\x1b[27m` : line;
+  }
+
+  function writeHeader() {
+    const COL = getColLayout();
+    const lines = [];
+
+    // Title
+    const countParts = [];
+    if (needsResponse.length > 0) countParts.push(`${needsResponse.length} need response`);
+    if (aging.length > 0) countParts.push(`${aging.length} aging`);
+    lines.push(s.bold(` ${items.length} tickets need attention`) + ` (${countParts.join(', ')})`);
+    lines.push('');
+
+    // Legend
+    if (needsResponse.length > 0) lines.push(` ${s.red('\u25cf')} needs response`);
+    if (aging.length > 0) lines.push(` ${s.yellow('\u25cf')} aging`);
+    lines.push('');
+
+    // Column headers + separator — mirrors buildRow column visibility
+    const hdrParts = [`  ${padRight('', 1)}`, padRight('Ticket', COL.key), padRight('Title', COL.title), padRight('Status', COL.status)];
+    const sepParts = [`  ${'\u2500'.repeat(1)}`, '\u2500'.repeat(COL.key), '\u2500'.repeat(COL.title), '\u2500'.repeat(COL.status)];
+
+    if (COL.from > 0) {
+      hdrParts.push(padRight('From', COL.from), padRight('When', COL.when));
+      sepParts.push('\u2500'.repeat(COL.from), '\u2500'.repeat(COL.when));
+    }
+    if (COL.detail > 0) {
+      hdrParts.push('Detail');
+      sepParts.push('\u2500'.repeat(COL.detail));
+    }
+
+    lines.push(s.dim(hdrParts.join('   ')));
+    lines.push(s.dim(sepParts.join('   ')));
+
+    const cols = process.stdout.columns || 120;
+    process.stderr.write(lines.map(l => clipToWidth(l, cols)).join('\n') + '\n');
+  }
+
+  function renderDynamic() {
+    const cols = process.stdout.columns || 120;
+    const termRows = process.stdout.rows || 24;
+
+    // Erase previous dynamic lines by moving up and clearing each line
+    if (dynamicLineCount > 0) {
+      // Move up dynamicLineCount lines, clearing each
+      for (let i = 0; i < dynamicLineCount; i++) {
+        process.stderr.write('\x1b[A'); // move up
+      }
+      // Now at the top of the dynamic section — erase from here down
+      for (let i = 0; i < dynamicLineCount; i++) {
+        process.stderr.write('\r\x1b[2K'); // erase line
+        if (i < dynamicLineCount - 1) process.stderr.write('\x1b[B'); // move down
+      }
+      // Move back up to the start of the dynamic section
+      for (let i = 0; i < dynamicLineCount - 1; i++) {
+        process.stderr.write('\x1b[A');
+      }
+      process.stderr.write('\r');
+    }
+
+    // Build dynamic lines: data rows + scroll indicator + footer
+    const lines = [];
+
+    // Header section uses ~8-9 lines, but we don't need to know exactly —
+    // we control how many data rows to show based on available space.
+    // Use a conservative fixed header height estimate.
+    const headerHeight = 8; // title + blank + legend1 + legend2 + blank + colhdr + sep + (written above)
+    const footerHeight = 2; // blank + keybind hint
+    const maxDataRows = Math.max(1, termRows - headerHeight - footerHeight - 1);
+
+    const maxVisible = Math.min(maxDataRows, items.length);
+    if (selectedIndex >= scrollTop + maxVisible) scrollTop = selectedIndex - maxVisible + 1;
+    if (selectedIndex < scrollTop) scrollTop = selectedIndex;
+
+    const visibleEnd = Math.min(scrollTop + maxVisible, items.length);
+    for (let i = scrollTop; i < visibleEnd; i++) {
+      lines.push(buildRow(items[i], i));
+    }
+
+    // Scroll indicator
+    if (items.length > maxVisible) {
+      const pos = `${scrollTop + 1}-${visibleEnd} of ${items.length}`;
+      lines.push(s.dim(`  ... ${pos}`));
+    }
+
+    // Footer
+    lines.push('');
+    lines.push(s.dim(' \u2191/\u2193 navigate   Enter open in browser   p switch profile   q/Esc exit'));
+
+    const clipped = lines.map(l => clipToWidth(l, cols));
+    process.stderr.write(clipped.join('\n') + '\n');
+    dynamicLineCount = clipped.length;
+  }
+
+  function openInBrowser(ticketKey) {
+    if (!browseUrl) return;
+    const url = browseUrl + ticketKey;
+    try {
+      const cmd = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'cmd'
+        : 'xdg-open';
+      const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+      const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+      child.unref();
+    } catch {
+      // Silently ignore if open fails
+    }
+  }
+
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+
+    function cleanup() {
+      process.removeListener('SIGWINCH', onResize);
+      process.stderr.write('\x1b[?25h'); // show cursor
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+      stdin.removeListener('data', onData);
+    }
+
+    function exit() {
+      cleanup();
+      resolve();
+    }
+
+    function onData(data) {
+      const key = data.toString();
+
+      if (key === '\x03') { exit(); return; } // Ctrl+C
+      if (key === 'q' || key === 'Q') { exit(); return; }
+      if (key === '\x1b') { exit(); return; } // Escape
+
+      if (key === '\x1b[A') { // Up
+        if (selectedIndex > 0) { selectedIndex--; renderDynamic(); }
+        return;
+      }
+      if (key === '\x1b[B') { // Down
+        if (selectedIndex < items.length - 1) { selectedIndex++; renderDynamic(); }
+        return;
+      }
+      if (key === '\r' || key === '\n') { // Enter
+        openInBrowser(items[selectedIndex].ticketKey);
+        return;
+      }
+      if (key === 'p' || key === 'P') { // Switch profile
+        cleanup();
+        runSwitch().then(switched => resolve(switched ? 'switch' : undefined));
+        return;
+      }
+    }
+
+    function onResize() { renderDynamic(); }
+
+    // Hide cursor, write static header once, then render dynamic rows
+    process.stderr.write('\x1b[?25l');
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    stdin.on('data', onData);
+    process.on('SIGWINCH', onResize);
+
+    writeHeader();
+    renderDynamic();
+  });
+}

package/skills/jtb/scripts/lib/jira-client.mjs

@@ -0,0 +1,169 @@
+/**
+ * Jira REST API client supporting Cloud and Server/Data Center.
+ * Normalizes responses into a consistent shape.
+ * Supports v2 (Server/DC) and v3 (Cloud) API versions.
+ */
+
+import { adfToText } from './adf-converter.mjs';
+
+function toText(value) {
+  if (value == null) return null;
+  if (typeof value === 'string') return value;
+  return adfToText(value);
+}
+
+export function normalizeTicket(raw) {
+  const f = raw.fields;
+  return {
+    key: raw.key,
+    summary: f.summary,
+    type: f.issuetype?.name ?? null,
+    status: f.status?.name ?? null,
+    priority: f.priority?.name ?? null,
+    assignee: f.assignee?.displayName ?? null,
+    reporter: f.reporter?.displayName ?? null,
+    description: toText(f.description),
+    created: f.created ?? null,
+    updated: f.updated ?? null,
+    labels: f.labels ?? [],
+    components: (f.components ?? []).map(c => c.name),
+    comments: (f.comment?.comments ?? []).map(c => ({
+      author: c.author?.displayName ?? c.author?.name ?? null,
+      authorAccountId: c.author?.accountId ?? null,
+      authorName: c.author?.name ?? null,
+      body: toText(c.body),
+      created: c.created,
+    })),
+    linkedIssues: (f.issuelinks ?? []).map(link => {
+      const direction = link.outwardIssue ? 'outward' : 'inward';
+      const issue = link.outwardIssue ?? link.inwardIssue;
+      return {
+        direction,
+        linkType: link.type.name,
+        key: issue.key,
+        summary: issue.fields.summary,
+        status: issue.fields.status?.name ?? null,
+        type: issue.fields.issuetype?.name ?? null,
+      };
+    }),
+    attachments: (f.attachment ?? []).map(a => ({
+      id: a.id ?? null,
+      filename: a.filename,
+      mimeType: a.mimeType ?? null,
+      size: a.size,
+      content: a.content ?? null,
+    })),
+  };
+}
+
+export function buildAuthHeader(env) {
+  if (env.JIRA_PAT) {
+    return { Authorization: `Bearer ${env.JIRA_PAT}` };
+  }
+  const encoded = Buffer.from(`${env.JIRA_EMAIL}:${env.JIRA_API_TOKEN}`).toString('base64');
+  return { Authorization: `Basic ${encoded}` };
+}
+
+export async function fetchCurrentUser(opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, apiVersion = 2, timeoutMs = 10_000 } = opts;
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
+
+  const url = `${baseUrl}/rest/api/${apiVersion}/myself`;
+  const fetchOpts = { headers };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+  const response = await fetcher(url, fetchOpts);
+
+  if (!response.ok) {
+    throw new Error(`Jira API error ${response.status} (${response.statusText}) fetching current user`);
+  }
+
+  const raw = await response.json();
+  return {
+    accountId: raw.accountId ?? null,
+    name: raw.name ?? null,
+    displayName: raw.displayName ?? null,
+    emailAddress: raw.emailAddress ?? null,
+  };
+}
+
+export async function fetchStatuses(opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, apiVersion = 2, timeoutMs = 10_000 } = opts;
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
+
+  const url = `${baseUrl}/rest/api/${apiVersion}/status`;
+  const fetchOpts = { headers };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+  const response = await fetcher(url, fetchOpts);
+
+  if (!response.ok) {
+    throw new Error(`Jira API error ${response.status} (${response.statusText}) fetching statuses`);
+  }
+
+  const raw = await response.json();
+  return [...new Set(raw.map(s => s.name))].sort();
+}
+
+export async function searchTickets(jql, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, maxResults = 50, apiVersion = 2, timeoutMs = 10_000 } = opts;
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
+
+  const fields = 'summary,status,assignee,priority,issuetype,comment,updated,statuscategorychangedate';
+  const params = new URLSearchParams({ jql, fields, maxResults: String(maxResults) });
+  const endpoint = apiVersion >= 3 ? `/rest/api/3/search/jql` : `/rest/api/2/search`;
+  const url = `${baseUrl}${endpoint}?${params}`;
+  const fetchOpts = { headers };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+  const response = await fetcher(url, fetchOpts);
+
+  if (!response.ok) {
+    let detail = '';
+    try { const body = await response.json(); detail = (body.errorMessages || []).join('; '); } catch {}
+    const err = new Error(`Jira API error ${response.status} (${response.statusText}) searching tickets${detail ? ': ' + detail : ''}`);
+    err.status = response.status;
+    err.detail = detail;
+    throw err;
+  }
+
+  const raw = await response.json();
+  return (raw.issues ?? []).map(normalizeTicket);
+}
+
+export async function fetchTicket(ticketKey, opts = {}) {
+  const { env = process.env, fetcher = globalThis.fetch, depth = 1, apiVersion = 2, timeoutMs = 10_000, _visited = new Set(), _currentDepth = 0 } = opts;
+  const baseUrl = env.JIRA_BASE_URL.replace(/\/$/, '');
+  const headers = { ...buildAuthHeader(env), 'Content-Type': 'application/json' };
+
+  const url = `${baseUrl}/rest/api/${apiVersion}/issue/${encodeURIComponent(ticketKey)}`;
+  const fetchOpts = { headers };
+  if (timeoutMs) fetchOpts.signal = AbortSignal.timeout(timeoutMs);
+  const response = await fetcher(url, fetchOpts);
+
+  if (!response.ok) {
+    throw new Error(`Jira API error ${response.status} (${response.statusText}) fetching ${ticketKey}`);
+  }
+
+  const raw = await response.json();
+  const ticket = normalizeTicket(raw);
+  _visited.add(ticketKey);
+
+  if (_currentDepth < depth) {
+    const MAX_TICKETS = 15;
+    const linkedKeys = ticket.linkedIssues
+      .map(l => l.key)
+      .filter(k => !_visited.has(k))
+      .slice(0, Math.max(0, MAX_TICKETS - _visited.size));
+
+    // Pre-mark all siblings before launching parallel fetches to prevent duplicate fetches
+    // when the same key appears in multiple link lists at the same depth.
+    linkedKeys.forEach(k => _visited.add(k));
+
+    ticket.linkedTicketDetails = await Promise.all(
+      linkedKeys.map(k => fetchTicket(k, { ...opts, _visited, _currentDepth: _currentDepth + 1 }))
+    );
+  }
+
+  return ticket;
+}

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

@@ -0,0 +1,96 @@
+/**
+ * Compliance Ledger — append-only JSONL audit trail for compliance checks (Pro tier).
+ * Named exports only. All fs operations accept an injectable fsModule param.
+ */
+
+import * as _fs from 'node:fs';
+import { join } from 'node:path';
+import { createHmac, randomBytes } from 'node:crypto';
+import { DEFAULT_CONFIG_DIR } from './config.mjs';
+
+const LEDGER_FILE = 'ledger.jsonl';
+const KEY_FILE    = 'ledger-key';
+
+/**
+ * Append one compliance record to ledger.jsonl.
+ * No-op when isPro is false.
+ *
+ * @param {{ ticketKey: string, commitSha: string, author: string, coverage: number, missing: string[] }} record
+ * @param {{ configDir?: string, fsModule?: object, isPro?: boolean }} opts
+ */
+export function appendLedger(record, { configDir = DEFAULT_CONFIG_DIR, fsModule = _fs, isPro = false } = {}) {
+  if (!isPro) return;
+
+  fsModule.mkdirSync(configDir, { recursive: true });
+
+  const line = JSON.stringify({ ts: new Date().toISOString(), ...record }) + '\n';
+  fsModule.appendFileSync(join(configDir, LEDGER_FILE), line, 'utf8');
+}
+
+/**
+ * Read all records from ledger.jsonl, optionally filtered by a since date.
+ *
+ * @param {{ configDir?: string, fsModule?: object, since?: string }} opts
+ * @returns {object[]}
+ */
+export function readLedger({ configDir = DEFAULT_CONFIG_DIR, fsModule = _fs, since } = {}) {
+  const ledgerPath = join(configDir, LEDGER_FILE);
+  let raw;
+  try {
+    raw = fsModule.readFileSync(ledgerPath, 'utf8');
+  } catch {
+    return [];
+  }
+
+  const sinceMs = since ? new Date(since).getTime() : null;
+
+  return raw
+    .split('\n')
+    .filter(line => line.trim().length > 0)
+    .map(line => JSON.parse(line))
+    .filter(record => sinceMs === null || new Date(record.ts).getTime() >= sinceMs);
+}
+
+/**
+ * Export the ledger in the specified format.
+ *
+ * @param {'json'|'csv'} format
+ * @param {{ configDir?: string, fsModule?: object }} opts
+ * @returns {object|string}  Object for 'json', string for 'csv'
+ */
+export function exportLedger(format, { configDir = DEFAULT_CONFIG_DIR, fsModule = _fs } = {}) {
+  const records = readLedger({ configDir, fsModule });
+
+  if (format === 'csv') {
+    const header = 'ts,ticketKey,commitSha,author,coverage,missing';
+    const rows = records.map(r => {
+      const missing = Array.isArray(r.missing) ? r.missing.join('|') : (r.missing ?? '');
+      return [r.ts, r.ticketKey, r.commitSha, r.author, r.coverage, missing]
+        .map(v => `"${String(v ?? '').replace(/"/g, '""')}"`)
+        .join(',');
+    });
+    return [header, ...rows].join('\n');
+  }
+
+  // JSON format
+  const key = _getOrCreateKey(configDir, fsModule);
+  const exportedAt = new Date().toISOString();
+  const payload = JSON.stringify({ records, exportedAt });
+  const signature = createHmac('sha256', key).update(payload).digest('hex');
+
+  return { records, exportedAt, signature };
+}
+
+// ── Internal helpers ─────────────────────────────────────────────────────────
+
+function _getOrCreateKey(configDir, fsModule) {
+  const keyPath = join(configDir, KEY_FILE);
+  try {
+    return fsModule.readFileSync(keyPath, 'utf8').trim();
+  } catch {
+    const key = randomBytes(32).toString('hex');
+    fsModule.mkdirSync(configDir, { recursive: true });
+    fsModule.writeFileSync(keyPath, key, { encoding: 'utf8', mode: 0o600 });
+    return key;
+  }
+}