ticketlens 0.1.0

package/skills/jtb/scripts/lib/profile-resolver.mjs

@@ -0,0 +1,236 @@
+/**
+ * Resolves Jira connection config from profiles or env vars.
+ * Resolution order: --profile flag → ticket prefix match → default profile → env vars
+ */
+
+import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { DEFAULT_CONFIG_DIR } from './config.mjs';
+
+/** Simple Levenshtein distance for "did you mean" suggestions. */
+function levenshtein(a, b) {
+  const m = a.length, n = b.length;
+  const dp = Array.from({ length: m + 1 }, (_, i) => i);
+  for (let j = 1; j <= n; j++) {
+    let prev = dp[0];
+    dp[0] = j;
+    for (let i = 1; i <= m; i++) {
+      const tmp = dp[i];
+      dp[i] = a[i - 1] === b[j - 1] ? prev : 1 + Math.min(prev, dp[i], dp[i - 1]);
+      prev = tmp;
+    }
+  }
+  return dp[m];
+}
+
+function findClosest(input, candidates) {
+  if (candidates.length === 0) return null;
+  const lower = input.toLowerCase();
+  let best = null;
+  let bestDist = Infinity;
+  for (const c of candidates) {
+    const d = levenshtein(lower, c.toLowerCase());
+    if (d < bestDist) { bestDist = d; best = c; }
+  }
+  // Only suggest if reasonably close (within half the input length + 2)
+  return bestDist <= Math.floor(input.length / 2) + 2 ? best : null;
+}
+
+// Module-level cache keyed by configDir — avoids redundant readFileSync+JSON.parse per run.
+// Invalidated automatically by every write function.
+const _profilesCache = new Map();
+const _credentialsCache = new Map();
+
+export function invalidateProfilesCache(configDir = DEFAULT_CONFIG_DIR) {
+  _profilesCache.delete(configDir);
+  _credentialsCache.delete(configDir);
+}
+
+export function saveDefault(name, configDir = DEFAULT_CONFIG_DIR) {
+  const profilesPath = join(configDir, 'profiles.json');
+  const config = loadProfiles(configDir) || { profiles: {} };
+  config.default = name;
+  writeFileSync(profilesPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  chmodSync(profilesPath, 0o600);
+  invalidateProfilesCache(configDir);
+}
+
+export function saveProfile(name, profileData, credData, configDir = DEFAULT_CONFIG_DIR) {
+  mkdirSync(configDir, { recursive: true });
+  const profilesPath = join(configDir, 'profiles.json');
+  const config = loadProfiles(configDir) || { profiles: {} };
+  config.profiles[name] = profileData;
+  writeFileSync(profilesPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  chmodSync(profilesPath, 0o600);
+  if (credData && Object.keys(credData).length > 0) {
+    const credPath = join(configDir, 'credentials.json');
+    const creds = loadCredentials(configDir);
+    creds[name] = credData;
+    writeFileSync(credPath, JSON.stringify(creds, null, 2) + '\n', 'utf8');
+    chmodSync(credPath, 0o600);
+  }
+  invalidateProfilesCache(configDir);
+}
+
+export function deleteProfile(name, configDir = DEFAULT_CONFIG_DIR) {
+  const profilesPath = join(configDir, 'profiles.json');
+  const config = loadProfiles(configDir);
+  if (!config?.profiles[name]) return { deleted: false, reason: 'not-found' };
+
+  delete config.profiles[name];
+  if (config.default === name) delete config.default;
+
+  writeFileSync(profilesPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+  chmodSync(profilesPath, 0o600);
+
+  // Remove credentials entry
+  const credPath = join(configDir, 'credentials.json');
+  if (existsSync(credPath)) {
+    const creds = loadCredentials(configDir);
+    if (creds[name]) {
+      delete creds[name];
+      writeFileSync(credPath, JSON.stringify(creds, null, 2) + '\n', 'utf8');
+      chmodSync(credPath, 0o600);
+    }
+  }
+
+  invalidateProfilesCache(configDir);
+  return { deleted: true };
+}
+
+export function loadProfiles(configDir = DEFAULT_CONFIG_DIR) {
+  if (_profilesCache.has(configDir)) return _profilesCache.get(configDir);
+  const profilesPath = join(configDir, 'profiles.json');
+  if (!existsSync(profilesPath)) return null;
+  const data = JSON.parse(readFileSync(profilesPath, 'utf8'));
+  _profilesCache.set(configDir, data);
+  return data;
+}
+
+export function loadCredentials(configDir = DEFAULT_CONFIG_DIR) {
+  if (_credentialsCache.has(configDir)) return _credentialsCache.get(configDir);
+  const credPath = join(configDir, 'credentials.json');
+  if (!existsSync(credPath)) {
+    _credentialsCache.set(configDir, {});
+    return {};
+  }
+  const data = JSON.parse(readFileSync(credPath, 'utf8'));
+  _credentialsCache.set(configDir, data);
+  return data;
+}
+
+export function expandTilde(p) {
+  if (p.startsWith('~/')) return join(homedir(), p.slice(2));
+  if (p === '~') return homedir();
+  return p;
+}
+
+export function resolveProfileByPath(cwd, configDir = DEFAULT_CONFIG_DIR) {
+  const config = loadProfiles(configDir);
+  if (!config) return null;
+
+  let bestMatch = null;
+  let bestLen = 0;
+
+  for (const [name, profile] of Object.entries(config.profiles)) {
+    if (!profile.projectPaths) continue;
+    for (const p of profile.projectPaths) {
+      const expanded = expandTilde(p);
+      if (cwd.startsWith(expanded) && expanded.length > bestLen) {
+        bestMatch = { name, ...profile };
+        bestLen = expanded.length;
+      }
+    }
+  }
+
+  return bestMatch;
+}
+
+export function resolveProfile(ticketKey, opts = {}) {
+  const { profileName, configDir = DEFAULT_CONFIG_DIR, cwd } = opts;
+  const config = loadProfiles(configDir);
+  if (!config) return null;
+
+  // 1. Explicit --profile flag
+  if (profileName && config.profiles[profileName]) {
+    return { name: profileName, ...config.profiles[profileName] };
+  }
+
+  // 1b. Profile name given but not found — suggest closest match
+  if (profileName) {
+    const available = Object.keys(config.profiles);
+    const suggestion = findClosest(profileName, available);
+    if (opts.onProfileNotFound) {
+      opts.onProfileNotFound({ profileName, suggestion, available });
+    }
+    return null;
+  }
+
+  // 2. Match ticket prefix (skip if no ticket key)
+  if (ticketKey) {
+    const prefix = ticketKey.split('-')[0];
+    const matches = [];
+    for (const [name, profile] of Object.entries(config.profiles)) {
+      if (profile.ticketPrefixes?.includes(prefix)) {
+        matches.push({ name, ...profile });
+      }
+    }
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) {
+      const warning = `Warning: Prefix "${prefix}" matches multiple profiles: ${matches.map(m => m.name).join(', ')}. Using ${matches[0].name}. Use --profile=NAME to override.`;
+      if (opts.onWarning) opts.onWarning(warning);
+      return matches[0];
+    }
+  }
+
+  // 3. Project path match
+  if (cwd) {
+    const pathMatch = resolveProfileByPath(cwd, configDir);
+    if (pathMatch) return pathMatch;
+  }
+
+  // 4. Default profile
+  if (config.default && config.profiles[config.default]) {
+    return { name: config.default, ...config.profiles[config.default] };
+  }
+
+  return null;
+}
+
+export function resolveConnection(ticketKey, opts = {}) {
+  const { env = process.env, configDir = DEFAULT_CONFIG_DIR, profileName, onWarning, onProfileNotFound, cwd } = opts;
+
+  const profile = resolveProfile(ticketKey, { profileName, configDir, onWarning, onProfileNotFound, cwd });
+
+  if (profile) {
+    const creds = loadCredentials(configDir);
+    const profileCreds = creds[profile.name] || {};
+    return {
+      baseUrl: profile.baseUrl,
+      auth: profile.auth || null,
+      email: profile.email || null,
+      apiToken: profileCreds.apiToken || null,
+      pat: profileCreds.pat || null,
+      triageStatuses: profile.triageStatuses || null,
+      ticketPrefixes: profile.ticketPrefixes || null,
+      source: 'profile',
+      profileName: profile.name,
+    };
+  }
+
+  // Explicit --profile was given but not found — don't fall back to env vars
+  if (profileName) {
+    return { baseUrl: null, source: 'profile-not-found', profileName };
+  }
+
+  // Fall back to env vars
+  return {
+    baseUrl: env.JIRA_BASE_URL || null,
+    auth: null,
+    email: env.JIRA_EMAIL || null,
+    apiToken: env.JIRA_API_TOKEN || null,
+    pat: env.JIRA_PAT || null,
+    source: 'env',
+  };
+}

package/skills/jtb/scripts/lib/profile-switcher.mjs

@@ -0,0 +1,147 @@
+/**
+ * ticketlens switch — Titled panel profile switcher (Option B).
+ * Used by `ticketlens switch` subcommand and as the final step in `ticketlens init`.
+ */
+
+import { createStyler } from './ansi.mjs';
+import { fetchCurrentUser } from './jira-client.mjs';
+import { classifyError } from './error-classifier.mjs';
+import { loadProfiles, loadCredentials, saveDefault } from './profile-resolver.mjs';
+import { runRawSelect } from './select-prompt.mjs';
+import { DEFAULT_CONFIG_DIR } from './config.mjs';
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const visLen = (str) => str.replace(ANSI_RE, '').length;
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+/**
+ * Show the titled profile switcher panel and optionally test the connection on switch.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.configDir]
+ * @param {NodeJS.WriteStream} [opts.stream=process.stderr]
+ * @param {boolean} [opts.testConnection=true] - false skips connection test (e.g. in init wizard)
+ * @returns {Promise<string|null>} chosen profile name, or null if cancelled/failed
+ */
+export async function runSwitch({ configDir = DEFAULT_CONFIG_DIR, stream = process.stderr, testConnection = true } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  const config = loadProfiles(configDir);
+
+  if (!config || Object.keys(config.profiles).length === 0) {
+    stream.write(`  ${s.red('✖')} No profiles configured. Run ${s.cyan('ticketlens init')} first.\n`);
+    return null;
+  }
+
+  const names = Object.keys(config.profiles);
+  const creds = loadCredentials(configDir);
+  const currentDefault = config.default || names[0];
+  const initialIndex = Math.max(0, names.indexOf(currentDefault));
+
+  if (names.length === 1) {
+    await saveDefault(names[0], configDir);
+    stream.write(`  ${s.dim('Only one profile:')} ${s.bold(s.cyan(names[0]))}\n`);
+    return names[0];
+  }
+
+  // Build rows: name + hostname + active badge state
+  const rows = names.map(name => {
+    const profile = config.profiles[name];
+    let hostname = '';
+    try { hostname = new URL(profile.baseUrl).hostname; } catch {}
+    return { name, hostname, isActive: name === currentDefault };
+  });
+
+  // Compute box inner width to fit all rows cleanly
+  const TITLE = ' Profile ';
+  const contentWidth = rows.reduce((max, r) => {
+    const nameRow = `  ❯ ${r.name}${r.isActive ? '  ● active' : ''}`.length + 2;
+    const subRow = `    ${r.hostname}`.length + 2;
+    return Math.max(max, nameRow, subRow);
+  }, TITLE.length + 4);
+  const innerWidth = Math.max(contentWidth, TITLE.length + 4);
+
+  const bc = s.cyan;
+
+  function padInner(line) {
+    const pad = innerWidth - visLen(line) - 1;
+    return ' ' + line + ' '.repeat(Math.max(0, pad));
+  }
+
+  // Full panel in renderFn so runRawSelect erases it cleanly on selection
+  const titleFill = innerWidth - 1 - TITLE.length; // -1 for leading ─
+  const topBorder = bc('╭') + bc('─') + s.bold(s.cyan(TITLE)) + bc('─'.repeat(Math.max(0, titleFill))) + bc('╮');
+
+  function renderFn(selected) {
+    const lines = [];
+    lines.push(topBorder);
+    lines.push(bc('│') + padInner('') + bc('│'));
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const isSelected = i === selected;
+      const marker = isSelected ? s.cyan('❯') : ' ';
+      const name = isSelected ? s.bold(s.cyan(row.name)) : row.name;
+      const badge = row.isActive ? `  ${s.green('● active')}` : '';
+      lines.push(bc('│') + padInner(`  ${marker} ${name}${badge}`) + bc('│'));
+      lines.push(bc('│') + padInner(s.dim(`    ${row.hostname}`)) + bc('│'));
+      lines.push(bc('│') + padInner('') + bc('│'));
+    }
+    lines.push(bc('╰') + bc('─'.repeat(innerWidth)) + bc('╯'));
+    lines.push('');
+    lines.push(`  ${s.dim('↑/↓ select   Enter switch   Esc back')}`);
+    stream.write(lines.join('\n') + '\n');
+    return lines.length;
+  }
+
+  const selectedIndex = await runRawSelect({ count: rows.length, initialIndex, renderFn, stream });
+  if (selectedIndex === null) return null;
+
+  const chosen = rows[selectedIndex];
+
+  // No-op if the user selected the already-active profile
+  if (chosen.name === currentDefault) {
+    stream.write(`  ${s.dim('Already on')} ${s.bold(s.cyan(chosen.name))}.\n`);
+    return chosen.name;
+  }
+
+  if (!testConnection) {
+    await saveDefault(chosen.name, configDir);
+    stream.write(`  ${s.green('✔')} Active profile set to ${s.bold(s.cyan(chosen.name))}\n`);
+    return chosen.name;
+  }
+
+  // Test connection with inline spinner
+  const profile = config.profiles[chosen.name];
+  const profileCreds = creds[chosen.name] || {};
+  const env = {
+    JIRA_BASE_URL: profile.baseUrl,
+    JIRA_EMAIL: profile.email || '',
+    JIRA_API_TOKEN: profileCreds.apiToken || '',
+    JIRA_PAT: profileCreds.pat || '',
+  };
+  const apiVersion = profile.auth === 'cloud' ? 3 : 2;
+
+  let frame = 0;
+  const spinLine = () => `  ${s.cyan(SPINNER_FRAMES[frame])} Connecting to ${s.bold(chosen.name)}...`;
+  stream.write(spinLine() + '\n');
+  const timer = setInterval(() => {
+    frame = (frame + 1) % SPINNER_FRAMES.length;
+    stream.write('\r\x1b[2K\x1b[A\r\x1b[2K');
+    stream.write(spinLine() + '\n');
+  }, 80);
+
+  try {
+    await fetchCurrentUser({ env, apiVersion });
+    clearInterval(timer);
+    stream.write('\r\x1b[2K\x1b[A\r\x1b[2K');
+    await saveDefault(chosen.name, configDir);
+    stream.write(`  ${s.green('✔')} Switched to ${s.bold(s.cyan(chosen.name))}\n`);
+    return chosen.name;
+  } catch (err) {
+    clearInterval(timer);
+    stream.write('\r\x1b[2K\x1b[A\r\x1b[2K');
+    const classified = classifyError(err, { baseUrl: profile.baseUrl, profileName: chosen.name });
+    stream.write(`  ${s.red('●')} Connection to ${chosen.name} failed.\n`);
+    stream.write(`  ${s.dim(classified.message)}\n`);
+    if (classified.hint) stream.write(`  ${s.dim(classified.hint)}\n`);
+    return null;
+  }
+}

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

@@ -0,0 +1,122 @@
+/**
+ * Shared interactive prompt helpers for wizard flows.
+ * Used by init-wizard.mjs and config-wizard.mjs.
+ */
+
+import { createInterface } from 'node:readline';
+import { createStyler } from './ansi.mjs';
+
+export const ANSI_RE = /\x1b\[[0-9;]*m/g;
+export const visLen = (str) => str.replace(ANSI_RE, '').length;
+
+export const SERVER_AUTH_TYPES = [
+  { label: 'PAT  (personal access token)', sublabel: 'Jira Server/DC 8.14+', value: 'pat' },
+  { label: 'Basic  (username + password)', sublabel: 'Jira Server/DC older versions', value: 'basic' },
+];
+
+/**
+ * Text prompt. If `defaultValue` is provided, empty input keeps it (shown as [current: …]).
+ */
+export async function promptText(label, { validate, defaultValue = '', stream = process.stderr } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  while (true) {
+    const raw = await new Promise(res => {
+      const rl = createInterface({ input: process.stdin, output: stream });
+      rl.question(`  ${label}  `, (a) => { rl.close(); res(a.trim()); });
+    });
+    const answer = raw || defaultValue;
+    if (validate) {
+      const err = validate(answer);
+      if (err) { stream.write(`  ${s.red('✖')} ${err}\n`); continue; }
+    }
+    return answer;
+  }
+}
+
+/**
+ * Masked password prompt. If `existingValue` is provided, Enter with no input keeps it.
+ */
+export async function promptSecret(label, { stream = process.stderr, existingValue = '' } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  while (true) {
+    stream.write(`  ${label}  `);
+    const value = await new Promise(res => {
+      let buf = '';
+      const stdin = process.stdin;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding('utf8');
+      function onData(char) {
+        if (char === '\r' || char === '\n') {
+          stdin.setRawMode(false);
+          stdin.pause();
+          stdin.removeListener('data', onData);
+          stream.write('\n');
+          res(buf);
+        } else if (char === '\x7f' || char === '\x08') {
+          if (buf.length > 0) { buf = buf.slice(0, -1); stream.write('\b \b'); }
+        } else if (char === '\x03') {
+          process.exit(0);
+        } else {
+          buf += char;
+          stream.write('*');
+        }
+      }
+      stdin.on('data', onData);
+    });
+    if (!value) {
+      if (existingValue) return existingValue; // Enter = keep existing
+      stream.write(`  ${s.red('✖')} Cannot be empty.\n`);
+      continue;
+    }
+    return value;
+  }
+}
+
+/**
+ * Gather schedule wizard answers interactively.
+ * Returns { time, email, timezone }.
+ */
+export async function promptScheduleAnswers(args = [], { stream = process.stderr } = {}) {
+  // Allow pre-filling via flags: --time=07:00 --email=dev@example.com --timezone=UTC
+  const timeArg = args.find(a => a.startsWith('--time='))?.split('=')[1];
+  const emailArg = args.find(a => a.startsWith('--email='))?.split('=')[1];
+  const tzArg = args.find(a => a.startsWith('--timezone='))?.split('=')[1];
+
+  const time = timeArg ?? await promptText('Delivery time (HH:MM, 24h):', {
+    stream,
+    validate: (v) => /^\d{1,2}:\d{2}$/.test(v) ? null : 'Enter time as HH:MM (e.g. 07:00)',
+  });
+
+  const email = emailArg ?? await promptText('Delivery email:', {
+    stream,
+    validate: (v) => v.includes('@') ? null : 'Enter a valid email address',
+  });
+
+  const timezone = tzArg ?? await promptText('Timezone (e.g. America/New_York):', {
+    stream,
+    defaultValue: Intl.DateTimeFormat().resolvedOptions().timeZone,
+  });
+
+  return { time, email, timezone };
+}
+
+export function promptYN(question, { stream = process.stderr } = {}) {
+  const s = createStyler({ isTTY: stream.isTTY });
+  stream.write(`\n  ${question}  ${s.dim('y/N')}  `);
+  return new Promise(res => {
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    function onData(char) {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener('data', onData);
+      stream.write('\n');
+      if (char === '\x03') process.exit(0);
+      res(char === 'y' || char === 'Y');
+    }
+    stdin.on('data', onData);
+  });
+}

package/skills/jtb/scripts/lib/requirement-extractor.mjs

@@ -0,0 +1,52 @@
+/**
+ * Extracts acceptance criteria / requirements from Jira ticket text.
+ * Recognises: Given/When/Then, must/should/shall/ensure/verify bullets,
+ * Acceptance Criteria sections, and numbered imperative items.
+ */
+
+const RE_GWT        = /^\s*(given|when|then)\s+(.+)/i;
+const RE_MUST_ITEM  = /^\s*[-*•]\s+((?:must|should|shall|ensure|verify)\b.+|.+(?:must|should|shall|ensure|verify).+)/i;
+const RE_NUM_MUST   = /^\s*\d+\.\s+((?:must|should|shall|ensure|verify)\b.+|.+(?:must|should|shall|ensure|verify).+)/i;
+const RE_AC_HEADER  = /^\s*#+\s*acceptance criteria\s*$/i;
+const RE_BULLET     = /^\s*[-*•]\s+(.+)/;
+const RE_NUM_ITEM   = /^\s*\d+\.\s+(.+)/;
+
+export function extractRequirements(text) {
+  if (!text) return [];
+
+  const lines = text.split('\n');
+  const results = [];
+  let inAcSection = false;
+
+  for (const line of lines) {
+    // Given/When/Then
+    const gwt = RE_GWT.exec(line);
+    if (gwt) { results.push(line.trim()); continue; }
+
+    // Acceptance Criteria section header
+    if (RE_AC_HEADER.test(line)) { inAcSection = true; continue; }
+
+    // Exit AC section on next heading
+    if (inAcSection && /^\s*#+\s/.test(line) && !RE_AC_HEADER.test(line)) {
+      inAcSection = false;
+    }
+
+    // must/should/shall in bullet
+    const mustItem = RE_MUST_ITEM.exec(line);
+    if (mustItem) { results.push(mustItem[1].trim()); continue; }
+
+    // must/should/shall in numbered item
+    const numMust = RE_NUM_MUST.exec(line);
+    if (numMust) { results.push(numMust[1].trim()); continue; }
+
+    // Inside AC section: capture all bullet and numbered items
+    if (inAcSection) {
+      const bullet = RE_BULLET.exec(line);
+      if (bullet) { results.push(bullet[1].trim()); continue; }
+      const numItem = RE_NUM_ITEM.exec(line);
+      if (numItem) { results.push(numItem[1].trim()); continue; }
+    }
+  }
+
+  return [...new Set(results)];
+}

package/skills/jtb/scripts/lib/resolve-adapter.mjs

@@ -0,0 +1,28 @@
+import { createJiraAdapter } from './adapters/jira-adapter.mjs';
+import { createGitHubAdapter } from './adapters/github-adapter.mjs';
+
+/**
+ * Detects the tracker type from a baseUrl string.
+ * @param {string|null|undefined} baseUrl
+ * @returns {'jira'|'github'|'linear'}
+ */
+export function detectTrackerType(baseUrl) {
+  if (!baseUrl) return 'jira';
+  const lower = baseUrl.toLowerCase();
+  if (lower.includes('github.com')) return 'github';
+  if (lower.includes('linear.app')) return 'linear';
+  return 'jira';
+}
+
+/**
+ * Instantiates the correct tracker adapter for a resolved connection.
+ * @param {{ baseUrl: string, auth?: string, email?: string, apiToken?: string, pat?: string }} conn
+ * @param {{ fetcher?: Function }} [opts]
+ * @returns {{ type: string, fetchTicket: Function, fetchCurrentUser: Function, searchTickets: Function, fetchStatuses: Function }}
+ */
+export function resolveAdapter(conn, opts = {}) {
+  const type = detectTrackerType(conn?.baseUrl);
+  if (type === 'jira') return createJiraAdapter(conn, opts);
+  if (type === 'github') return createGitHubAdapter(conn, opts);
+  throw new Error(`Tracker type '${type}' is not yet supported. Supported: jira, github.`);
+}