ticketlens 0.34.0 → 0.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.34.0",
+  "version": "0.36.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/SKILL.md

@@ -1,4 +1,4 @@
-<!-- jtb-skill-version: 0.28.0 -->
+<!-- jtb-skill-version: 0.29.0 -->
 ---
 name: jtb
 description: Fetch a Jira ticket's full context (description, comments, linked issues, code references) and assemble a structured TicketBrief for implementation planning. Use when user types /jtb, mentions a Jira ticket key, or wants to plan work from a Jira ticket.
@@ -284,7 +284,7 @@ ticketlens duplicates PROD-1234                               # find likely dupl
 
 `assign` is self-assign only — `--to` must be `me`. There is no way to assign to anyone else yet; don't attempt a workaround (e.g. via `comment`) if the user asks for that — tell them it isn't supported.
 
-`duplicates` lists likely-duplicate tickets in the same project, ranked by local title/description overlap — no tracker scores similarity server-side, so treat a match as a nudge for the user to check manually, never as a confirmed duplicate to act on unprompted (e.g. don't auto-close or auto-comment based on a match). `--threshold=N` (0–1, default 0.35) tightens or loosens what counts as a match.
+`duplicates` lists likely-duplicate tickets in the same project. On Jira, any ticket already linked as a "Duplicate" is always listed first — that's a confirmed relationship a human already recorded, not a heuristic. Everything else is ranked by local title/description overlap — no tracker scores similarity server-side, so treat those as a nudge for the user to check manually, never as a confirmed duplicate to act on unprompted (e.g. don't auto-close or auto-comment based on a match). `--threshold=N` (0–1, default 0.35) tightens or loosens what counts as a text-match — it has no effect on Jira-linked duplicates, which are always shown.
 
 The three write actions (comment/transition/assign) have a short local debounce (10s) against an accidental double-fire, and every write is appended to a local audit log (`~/.ticketlens/ticket-action-log.jsonl`). A write that times out is never retried automatically — surface the failure to the user rather than silently re-attempting, since a ticket write isn't naturally idempotent the way a Recall note save is. `duplicates` has neither, since nothing is written.
 

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

@@ -751,8 +751,10 @@ export function printDuplicatesHelp({ stream = process.stdout } = {}) {
     '',
     `  Find likely duplicate tickets in the same project (Jira/GitHub/Linear). ${s.dim('[Pro]')}`,
     `  Read-only — lists possible matches, never links or changes anything.`,
-    `  No tracker scores similarity server-side, so ranking happens locally`,
-    `  from title/description overlap. Not exact — treat it as a nudge to check.`,
+    `  On Jira, any ticket already linked as a "Duplicate" is always listed first —`,
+    `  that's a confirmed relationship, not a guess. Everything else comes from a`,
+    `  local title/description overlap score (no tracker scores similarity`,
+    `  server-side) — not exact, treat those as a nudge to check.`,
     '',
     `  ${s.bold('OPTIONS')}`,
     '',

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

@@ -93,6 +93,10 @@ export function normalizeTicket(raw) {
       return {
         direction,
         linkType: link.type.name,
+        // The actual directional wording ("is duplicated by" / "duplicates") as
+        // named in Jira itself, not just the link type's generic name — lets
+        // callers show the user's own words instead of inventing new phrasing.
+        linkPhrase: direction === 'outward' ? link.type.outward : link.type.inward,
         key: issue.key,
         summary: issue.fields.summary,
         status: issue.fields.status?.name ?? null,

package/skills/jtb/scripts/lib/mcp-server.mjs

@@ -93,7 +93,7 @@ const TOOLS = [
   },
   {
     name: 'ticket_duplicates',
-    description: 'Find likely duplicate tickets in the same project (Jira/GitHub/Linear). Read-only — never links or changes anything; no tracker scores similarity server-side, so ranking is local and approximate. Requires a TicketLens Pro license.',
+    description: 'Find likely duplicate tickets in the same project (Jira/GitHub/Linear). Read-only — never links or changes anything. On Jira, any ticket already linked as a "Duplicate" is always included first (a confirmed relationship, not a guess); everything else comes from a local, approximate title/description overlap score, since no tracker scores similarity server-side. Requires a TicketLens Pro license.',
     inputSchema: {
       type: 'object',
       properties: {

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');
 }
@@ -472,19 +485,44 @@ export async function runTicketDuplicates(cmdArgs, {
   if (!adapter) return { ok: false };
 
   try {
-    const source = await adapter.fetchTicket(ticketKey);
+    // depth: 0 — only the shallow linkedIssues list is needed (for explicit
+    // Duplicate links, below); the default depth:1 would also recursively
+    // fetch full details of every linked ticket just to discard them here.
+    const source = await adapter.fetchTicket(ticketKey, { depth: 0 });
     const searchText = [source.summary, source.description].filter(Boolean).join(' ');
     const candidates = await adapter.findCandidates(searchText, ticketKey);
     const scoreOpts = threshold !== undefined ? { threshold } : {};
-    const results = scoreCandidates({ key: ticketKey, summary: source.summary, description: source.description }, candidates, scoreOpts);
+    const textMatches = scoreCandidates({ key: ticketKey, summary: source.summary, description: source.description }, candidates, scoreOpts);
+
+    // A human already said these are duplicates — always include them,
+    // regardless of --threshold, ahead of anything the local scorer finds.
+    // Jira doesn't enforce uniqueness of link-type+target pairs, so the same
+    // key could appear via two separately-typed "duplicate-ish" links —
+    // de-duped against itself here, not just against textMatches below.
+    const seenLinkedKeys = new Set();
+    const linkedDuplicates = (source.linkedIssues ?? [])
+      .filter(l => /duplicate/i.test(l.linkType))
+      .filter(l => !seenLinkedKeys.has(l.key) && seenLinkedKeys.add(l.key))
+      .map(l => ({ key: l.key, summary: l.summary, linked: true, linkPhrase: l.linkPhrase }));
+    const linkedKeys = new Set(linkedDuplicates.map(l => l.key));
+    const results = [...linkedDuplicates, ...textMatches.filter(r => !linkedKeys.has(r.key))];
+
+    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`);
+      if (r.linked) {
+        stream.write(`    ${s.brand('●')} ${s.bold(r.key)} (${s.green(`Jira-linked — ${r.linkPhrase}`)}) — ${r.summary}\n`);
+        continue;
+      }
+      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) {