ticketlens 0.33.0 → 0.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.33.0",
+  "version": "0.35.0",
   "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/compliance-checker.mjs

@@ -7,7 +7,7 @@ import { analyzeDiff } from './diff-analyzer.mjs';
 import { DEFAULT_CONFIG_DIR } from './config.mjs';
 import { appendLedger } from './ledger.mjs';
 
-const STATUS_ICON = { FOUND: '✔', PARTIAL: '~', NOT_FOUND: '✖' };
+export const STATUS_ICON = { FOUND: '✔', PARTIAL: '~', NOT_FOUND: '✖' };
 
 function formatReport({ ticketKey, requirements, analysis, usage, isPro }) {
   const { results, coveragePercent } = analysis;
@@ -92,5 +92,5 @@ export async function runComplianceCheck({
     );
   }
 
-  return { report, coveragePercent, noCriteria: requirements.length === 0 };
+  return { report, results: analysis.results, coveragePercent, noCriteria: requirements.length === 0 };
 }

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

@@ -8,7 +8,7 @@ import { spawnSync } from 'node:child_process';
 import { fetchTicket } from './jira-client.mjs';
 import { extractRequirements } from './requirement-extractor.mjs';
 import { findLinkedCommits } from './commit-linker.mjs';
-import { runComplianceCheck } from './compliance-checker.mjs';
+import { runComplianceCheck, STATUS_ICON } from './compliance-checker.mjs';
 import { DEFAULT_CONFIG_DIR } from './config.mjs';
 
 /**
@@ -63,26 +63,13 @@ function buildCoverageSection(complianceResult, requirements) {
     return lines.join('\n');
   }
 
-  const { coveragePercent, report } = complianceResult;
+  const { coveragePercent, results } = complianceResult;
   const lines = [``, `### Requirements coverage (${coveragePercent}%)`];
 
-  for (const entry of report) {
-    if (entry.covered) {
-      const loc = entry.location ? ` (${entry.location})` : '';
-      lines.push(`- ✔ ${entry.req}${loc}`);
-    } else {
-      lines.push(`- ✖ ${entry.req}`);
-    }
-  }
-
-  // Include any missing reqs not already in report
-  if (complianceResult.missing && complianceResult.missing.length > 0) {
-    const reportedReqs = new Set(report.map(r => r.req));
-    for (const missed of complianceResult.missing) {
-      if (!reportedReqs.has(missed)) {
-        lines.push(`- ✖ ${missed}`);
-      }
-    }
+  for (const { requirement, status, evidence } of results) {
+    const icon = STATUS_ICON[status] ?? '?';
+    const suffix = evidence ? ` (${evidence})` : '';
+    lines.push(`- ${icon} ${requirement}${suffix}`);
   }
 
   return lines.join('\n');

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

@@ -1,25 +1,101 @@
 /**
  * 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.
+ * Acceptance Criteria sections, and numbered imperative items — both
+ * newline-separated ("1. ..." / "1) ...") and inline enumerations flattened
+ * into one paragraph ("... 1) foo 2) bar 3) baz"), as produced by Jira ADF.
  */
 
-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*|h[1-6]\.\s*)?acceptance criteria\s*:?\s*$/i;
-const RE_HEADING    = /^\s*(?:#+|h[1-6]\.)\s+/i;
-const RE_BULLET     = /^\s*[-*•]\s+(.+)/;
-const RE_NUM_ITEM   = /^\s*\d+\.\s+(.+)/;
+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*|h[1-6]\.\s*)?acceptance criteria\s*:?\s*$/i;
+const RE_HEADING       = /^\s*(?:#+|h[1-6]\.)\s+/i;
+const RE_BULLET        = /^\s*[-*•]\s+(.+)/;
+const RE_NUM_ITEM      = /^\s*\d+[.)]\s+(.+)/;
+const RE_NUM_MARKER    = /^\s*(\d+)[.)]/;
+// A numbered marker preceded by start-of-line or whitespace/punctuation — excludes
+// things like "v1." or "2.1" where the digit is glued to a letter or another digit.
+// Known limitation: doesn't catch mid-sentence prose like "item 1. Then item 2." —
+// narrowing further risks new false negatives on genuine short list items.
+const RE_INLINE_MARKER = /(?:^|(?<=[\s:;,]))(\d+)[.)]\s+/g;
+// Headings that introduce a numbered list which is NOT acceptance criteria (e.g. bug
+// repro steps) — a plain numbered list under one of these must never be extracted.
+const RE_NON_AC_HEADER = /^\s*(?:#+\s*|h[1-6]\.\s*)?(?:steps to reproduce|repro(?:duction)? steps|how to reproduce)\s*:?\s*$/i;
+
+// True if numbers is a run starting at 1 with no gaps or repeats (1,2,3,...).
+// Shared by findValidNumberedRuns and splitInlineNumbered as the one signal both
+// use to tell a genuine enumeration apart from stray numbers elsewhere in prose.
+function isSequentialFrom1(numbers) {
+  return numbers[0] === 1 && numbers.every((n, i) => i === 0 || n === numbers[i - 1] + 1);
+}
+
+// Finds line indices that form a genuine numbered enumeration outside any AC/non-AC
+// section: 2+ consecutive numbered lines, sequential starting at 1. A single numbered
+// line, or numbers that skip/repeat, are too weak a signal on their own (they're just
+// as likely to be a "Steps to Reproduce" list, a version note, or an unrelated aside).
+// Known limitation: a blank line between items breaks the run (items must be on
+// strictly consecutive lines), so a list formatted with blank lines between items
+// and no AC header is not recognised — narrower than the AC-header path, which does
+// tolerate that (see the "plain sentences" fallback below).
+function findValidNumberedRuns(lines) {
+  const valid = new Set();
+  let inAc = false;
+  let inNonAc = false;
+  let run = [];
+
+  const flushRun = () => {
+    if (run.length >= 2 && isSequentialFrom1(run.map(r => r.num))) {
+      for (const r of run) valid.add(r.index);
+    }
+    run = [];
+  };
+
+  lines.forEach((line, index) => {
+    if (RE_AC_HEADER.test(line)) { inAc = true; inNonAc = false; flushRun(); return; }
+    if (RE_NON_AC_HEADER.test(line)) { inNonAc = true; inAc = false; flushRun(); return; }
+
+    if ((inAc || inNonAc) && RE_HEADING.test(line)) { inAc = false; inNonAc = false; }
+
+    if (inAc || inNonAc) { flushRun(); return; }
+
+    const marker = RE_NUM_MARKER.exec(line);
+    if (marker) { run.push({ index, num: Number(marker[1]) }); } else { flushRun(); }
+  });
+  flushRun();
+
+  return valid;
+}
+
+// Splits a line on sequential inline numbered markers ("1) ... 2) ... 3) ...").
+// Requires 2+ markers starting at 1 and incrementing by 1, so stray numbers
+// elsewhere in prose (versions, dates, prices) don't get misread as a list.
+function splitInlineNumbered(line) {
+  const markers = [...line.matchAll(RE_INLINE_MARKER)];
+  if (markers.length < 2) return [];
+
+  const numbers = markers.map(m => Number(m[1]));
+  if (!isSequentialFrom1(numbers)) return [];
+
+  const items = [];
+  for (let i = 0; i < markers.length; i++) {
+    const start = markers[i].index + markers[i][0].length;
+    const end = i + 1 < markers.length ? markers[i + 1].index : line.length;
+    const item = line.slice(start, end).trim();
+    if (item) items.push(item);
+  }
+  return items;
+}
 
 export function extractRequirements(text) {
   if (!text) return [];
 
   const lines = text.split('\n');
+  const validNumberedLines = findValidNumberedRuns(lines);
   const results = [];
   let inAcSection = false;
 
-  for (const line of lines) {
+  for (const [index, line] of lines.entries()) {
     const gwt = RE_GWT.exec(line);
     if (gwt) { results.push(line.trim()); continue; }
 
@@ -36,6 +112,9 @@ export function extractRequirements(text) {
     const numMust = RE_NUM_MUST.exec(line);
     if (numMust) { results.push(numMust[1].trim()); continue; }
 
+    const inlineItems = splitInlineNumbered(line);
+    if (inlineItems.length > 0) { results.push(...inlineItems); continue; }
+
     if (inAcSection) {
       const bullet = RE_BULLET.exec(line);
       if (bullet) { results.push(bullet[1].trim()); continue; }
@@ -45,6 +124,13 @@ export function extractRequirements(text) {
       const plain = line.trim();
       if (plain) { results.push(plain); continue; }
     }
+
+    // Plain numbered enumeration outside an explicit AC section, no modal verb required —
+    // only for a validated run (2+ sequential items, see findValidNumberedRuns)
+    if (!inAcSection && validNumberedLines.has(index)) {
+      const numItem = RE_NUM_ITEM.exec(line);
+      if (numItem) { results.push(numItem[1].trim()); continue; }
+    }
   }
 
   return [...new Set(results)];

package/skills/jtb/scripts/lib/ticket-command.mjs

@@ -21,6 +21,7 @@ import { detectProjectOrTypeError, enrichCreateFailure } from './ticket-create-e
 import { TICKET_KEY_PATTERN } from './cli.mjs';
 import { scoreCandidates } from './duplicate-scorer.mjs';
 import { MAX_ATTACHMENTS } from './attachment-uploader.mjs';
+import { createStyler } from './ansi.mjs';
 
 function parseFlag(cmdArgs, name) {
   return cmdArgs.find(a => a.startsWith(`--${name}=`))?.slice(name.length + 3);
@@ -123,6 +124,18 @@ function formatDuplicatesFailure(ticketKey, err) {
   return formatReadFailure(ticketKey, err, 'for duplicates');
 }
 
+/**
+ * Match-confidence color tier for a duplicates result: ≥70% reads as a strong
+ * signal, 50-69% as worth a look, below that as a weak, low-confidence nudge.
+ * Exported standalone so the boundary values are pinned by a direct test
+ * rather than reverse-engineered from real Jaccard scores in a fixture.
+ */
+export function matchColor(pct, s) {
+  if (pct >= 70) return s.green;
+  if (pct >= 50) return s.yellow;
+  return s.dim;
+}
+
 function formatLinkListFailure(ticketKey, err) {
   return formatReadFailure(ticketKey, err, 'for link options');
 }
@@ -478,13 +491,18 @@ export async function runTicketDuplicates(cmdArgs, {
     const scoreOpts = threshold !== undefined ? { threshold } : {};
     const results = scoreCandidates({ key: ticketKey, summary: source.summary, description: source.description }, candidates, scoreOpts);
 
+    const s = createStyler({ isTTY: stream.isTTY });
+    stream.write(`  ${s.brand(s.bold(ticketKey))}: ${s.bold(source.summary ?? '')}\n\n`);
+
     if (results.length === 0) {
-      stream.write(`  No likely duplicates found for ${ticketKey}.\n`);
+      stream.write(`  No likely duplicates found.\n`);
       return { ok: true, results: [] };
     }
-    stream.write(`  Possible duplicates of ${ticketKey}:\n`);
+    stream.write(`  Possible duplicates:\n\n`);
     for (const r of results) {
-      stream.write(`    ${r.key} (${Math.round(r.score * 100)}% match) — ${r.summary}\n`);
+      const pct = Math.round(r.score * 100);
+      const pctColor = matchColor(pct, s);
+      stream.write(`    ${s.brand('●')} ${s.bold(r.key)} (${pctColor(`${pct}% match`)}) — ${r.summary}\n`);
     }
     return { ok: true, results };
   } catch (err) {