ticketlens 0.1.7 → 0.1.9

package/README.md

@@ -190,6 +190,19 @@ Stores the schedule as a cron entry. Delivers your triage digest at the configur
 
 ---
 
+### Login
+
+```bash
+ticketlens login           # Open browser → authorize in Console → token saved automatically
+ticketlens login --manual  # Paste a token instead (CI/headless environments)
+```
+
+`ticketlens login` opens the TicketLens Console in your default browser. Click **Authorize**, and the CLI receives your token via a one-shot localhost callback — no copy-pasting. Cancelling in the browser exits the CLI cleanly.
+
+Use `--manual` when there is no GUI (CI runners, SSH sessions, containers).
+
+---
+
 ### License
 
 ```bash
@@ -308,6 +321,10 @@ ticketlens schedule                           # Interactive wizard — set time,
 ticketlens schedule --stop                    # Cancel the scheduled digest [Pro]
 ticketlens schedule --status                  # Show current schedule [Pro]
 
+# ── Login ─────────────────────────────────────────────────────────────────────
+ticketlens login                              # Browser flow — opens Console, token saved automatically
+ticketlens login --manual                     # Paste flow — for CI/headless environments
+
 # ── License and account ────────────────────────────────────────────────────────
 ticketlens license                            # Show license tier and status
 ticketlens activate <LICENSE-KEY>             # Activate a license key

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Jira CLI for developers — fetch ticket context, triage your queue, and stop tab-switching. Zero dependencies, all local.",
   "type": "module",
   "bin": {

package/skills/jtb/scripts/lib/adapters/linear-adapter.mjs

@@ -0,0 +1,132 @@
+const LINEAR_API = 'https://api.linear.app/graphql';
+
+const PRIORITY_LABELS = { 1: 'Urgent', 2: 'High', 3: 'Medium', 4: 'Low' };
+
+const ISSUE_FIELDS = `
+  identifier
+  title
+  description
+  state { name }
+  priority
+  assignee { name email }
+  creator { name email }
+  createdAt
+  updatedAt
+  labels { nodes { name } }
+  comments { nodes { body createdAt user { name email } } }
+`;
+
+/**
+ * Maps a raw Linear GraphQL issue node to the normalized ticket shape.
+ */
+export function normalizeLinearIssue(raw) {
+  return {
+    key: raw.identifier,
+    summary: raw.title,
+    type: 'Issue',
+    status: raw.state?.name ?? null,
+    priority: PRIORITY_LABELS[raw.priority] ?? null,
+    assignee: raw.assignee?.name ?? null,
+    reporter: raw.creator?.name ?? null,
+    description: raw.description ?? null,
+    created: raw.createdAt ?? null,
+    updated: raw.updatedAt ?? null,
+    labels: (raw.labels?.nodes ?? []).map(l => l.name),
+    components: [],
+    comments: (raw.comments?.nodes ?? []).map(c => ({
+      author: c.user?.name ?? null,
+      authorAccountId: null,
+      authorName: c.user?.name ?? null,
+      body: c.body ?? '',
+      created: c.createdAt ?? null,
+    })),
+    linkedIssues: [],
+    attachments: [],
+  };
+}
+
+async function gql(query, variables, { token, fetcher, signal }) {
+  const res = await fetcher(LINEAR_API, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(Object.keys(variables).length ? { query, variables } : { query }),
+    signal,
+  });
+  if (!res.ok) {
+    throw new Error(`Linear API error ${res.status} (${res.statusText})`);
+  }
+  const { data, errors } = await res.json();
+  if (errors?.length) throw new Error(`Linear GraphQL error: ${errors[0].message}`);
+  return data;
+}
+
+/**
+ * Returns a tracker adapter backed by the Linear GraphQL API.
+ * Profile baseUrl must contain linear.app. Auth token stored as apiToken in credentials.json.
+ */
+export function createLinearAdapter(conn, { fetcher = globalThis.fetch } = {}) {
+  const token = conn.apiToken || conn.pat;
+
+  return {
+    type: 'linear',
+
+    async fetchTicket(key, opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 10_000);
+      const data = await gql(
+        `query IssueByIdentifier($id: String!) {
+          issues(filter: { identifier: { eq: $id } }, first: 1) {
+            nodes { ${ISSUE_FIELDS} }
+          }
+        }`,
+        { id: key },
+        { token, fetcher, signal },
+      );
+      const node = data.issues?.nodes?.[0];
+      if (!node) throw new Error(`Linear issue not found: ${key}`);
+      return normalizeLinearIssue(node);
+    },
+
+    async fetchCurrentUser(opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 10_000);
+      const data = await gql(
+        `query Me { viewer { name email } }`,
+        {},
+        { token, fetcher, signal },
+      );
+      const v = data.viewer;
+      return { displayName: v.name, email: v.email ?? null };
+    },
+
+    async searchTickets(_query, opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 10_000);
+      const data = await gql(
+        `query MyIssues {
+          viewer {
+            assignedIssues(
+              filter: { state: { type: { nin: ["completed", "cancelled"] } } }
+              first: 50
+            ) {
+              nodes { ${ISSUE_FIELDS} }
+            }
+          }
+        }`,
+        {},
+        { token, fetcher, signal },
+      );
+      return (data.viewer?.assignedIssues?.nodes ?? []).map(normalizeLinearIssue);
+    },
+
+    async fetchStatuses(opts = {}) {
+      const signal = AbortSignal.timeout(opts.timeoutMs ?? 10_000);
+      const data = await gql(
+        `query WorkflowStates { workflowStates(first: 50) { nodes { name } } }`,
+        {},
+        { token, fetcher, signal },
+      );
+      return (data.workflowStates?.nodes ?? []).map(s => s.name);
+    },
+  };
+}

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

@@ -40,9 +40,14 @@ export function createSession(conn, { stream = process.stderr } = {}) {
   const profileLabel = conn.profileName || 'default';
   const userLabel = conn.email || (conn.pat ? 'token auth' : 'unknown');
 
-  const jiraLabel = conn.profileName
-    ? conn.profileName.charAt(0).toUpperCase() + conn.profileName.slice(1) + ' Jira'
-    : hostname;
+  const trackerName = hostname.includes('linear.app') ? 'Linear'
+    : hostname.includes('github.com') ? 'GitHub'
+    : 'Jira';
+  const jiraLabel = (trackerName !== 'Jira')
+    ? trackerName
+    : conn.profileName
+      ? conn.profileName.charAt(0).toUpperCase() + conn.profileName.slice(1) + ' Jira'
+      : hostname;
 
   // Pre-build the info lines to calculate box width including status line.
   const infoLines = [

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

@@ -109,6 +109,7 @@ async function _run({ configDir, stream, s }) {
     const TRACKER_TYPES = [
       { label: 'Jira',   sublabel: 'Jira Cloud, Server, or Data Center', value: 'jira'   },
       { label: 'GitHub', sublabel: 'GitHub Issues (github.com)',          value: 'github' },
+      { label: 'Linear', sublabel: 'Linear (linear.app)',                 value: 'linear' },
     ];
     stream.write(`\n  ${s.dim('Tracker type:')}\n\n`);
     const trackerIndex = await promptSelect(TRACKER_TYPES, { stream, hint: '↑/↓ select   Enter confirm' });
@@ -230,6 +231,96 @@ async function _run({ configDir, stream, s }) {
       }
     }
 
+    if (trackerType === 'linear') {
+      let linToken = '';
+
+      linearLoop: while (true) {
+        const tokenHint = linToken ? s.dim('  [keep existing]') : '';
+        linToken = await promptSecret(
+          s.dim('Linear API key') + tokenHint + s.dim(':'),
+          { stream, existingValue: linToken }
+        );
+
+        const linConn = { baseUrl: 'https://linear.app', apiToken: linToken };
+        const linSession = createSession({ baseUrl: 'https://linear.app', profileName }, { stream });
+        stream.write('\n');
+        linSession.spin('Testing connection...');
+
+        try {
+          const linAdapter = resolveAdapter(linConn);
+          await linAdapter.fetchCurrentUser();
+          linSession.connected();
+          connected = true;
+          break linearLoop;
+        } catch (err) {
+          linSession.failed();
+          const classified = classifyError(err, { baseUrl: 'https://linear.app', profileName });
+          linSession.footer(classified.message, 'error', classified.hint);
+        }
+
+        const LIN_RETRY = [
+          { label: 'Retry',     sublabel: 'Try again — same key',          value: 'retry' },
+          { label: 'Edit key',  sublabel: 'Change API key',                 value: 'creds' },
+          { label: 'Skip',      sublabel: 'Abandon — move to next step',    value: 'skip'  },
+        ];
+        stream.write(`\n  ${s.dim('What would you like to do?')}\n\n`);
+        const linRetryIndex = await promptSelect(LIN_RETRY, { stream, hint: '↑/↓ select   Enter confirm' });
+        if (linRetryIndex === null || LIN_RETRY[linRetryIndex].value === 'skip') break linearLoop;
+        const lHint = linToken ? s.dim('  [keep existing]') : '';
+        linToken = await promptSecret(
+          s.dim('Linear API key') + lHint + s.dim(':'),
+          { stream, existingValue: linToken }
+        );
+      }
+
+      if (connected) {
+        stream.write(`\n  ${s.dim('──── Optional  (press Enter to skip) ────')}\n\n`);
+
+        const prefixRaw = await promptText(s.dim('Team identifier') + s.dim('  (e.g. ENG):'), { stream });
+        const ticketPrefixes = prefixRaw
+          ? prefixRaw.split(',').map(v => v.trim().toUpperCase()).filter(Boolean)
+          : [];
+
+        const home = homedir();
+        const cwd = process.cwd();
+        const cwdDisplay = cwd.startsWith(home) ? '~' + cwd.slice(home.length) : cwd;
+        const pathInput = await promptText(
+          s.dim('Project path') + s.dim(`  [${cwdDisplay}]:`), { stream }
+        );
+        const rawPath = (pathInput.trim() || cwdDisplay).replace(/\/+$/, '');
+        const projectPaths = [];
+        if (rawPath) {
+          const expanded = rawPath.startsWith('~') ? join(home, rawPath.slice(1)) : rawPath;
+          if (existsSync(expanded)) {
+            projectPaths.push(rawPath);
+            stream.write(`  ${s.green('✔')} ${rawPath}\n`);
+          } else {
+            stream.write(`  ${s.yellow('○')} ${s.dim(rawPath)} — directory not found\n`);
+            const doCreate = await promptYN(`Create ${rawPath}?`, { stream });
+            if (doCreate) {
+              try {
+                mkdirSync(expanded, { recursive: true });
+                projectPaths.push(rawPath);
+                stream.write(`  ${s.green('✔')} Created\n`);
+              } catch (mkErr) {
+                stream.write(`  ${s.red('✖')} Could not create: ${mkErr.message}\n`);
+              }
+            }
+          }
+        }
+
+        const profileData = {
+          baseUrl: 'https://linear.app',
+          auth: 'linear',
+          ...(ticketPrefixes.length > 0 ? { ticketPrefixes } : {}),
+          ...(projectPaths.length > 0 ? { projectPaths } : {}),
+        };
+        saveProfile(profileName, profileData, { apiToken: linToken }, configDir);
+        addedCount++;
+        stream.write(`\n  ${s.green('✔')} Profile ${s.bold(s.cyan(`"${profileName}"`))} saved.\n`);
+      }
+    }
+
     if (trackerType === 'jira') {
     // ── Setup loop — URL → auth → credentials → test → retry ─────────────────
     //

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

@@ -1,5 +1,6 @@
 import { createJiraAdapter } from './adapters/jira-adapter.mjs';
 import { createGitHubAdapter } from './adapters/github-adapter.mjs';
+import { createLinearAdapter } from './adapters/linear-adapter.mjs';
 
 /**
  * Detects the tracker type from a baseUrl string.
@@ -24,5 +25,6 @@ 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.`);
+  if (type === 'linear') return createLinearAdapter(conn, opts);
+  throw new Error(`Tracker type '${type}' is not yet supported. Supported: jira, github, linear.`);
 }