ticketlens 0.21.4 → 0.21.6

package/bin/ticketlens.mjs

@@ -37,6 +37,7 @@ import { checkForUpdate, getUpdateHint } from '../skills/jtb/scripts/lib/update-
 import { incrementInvocation, incrementCommand } from '../skills/jtb/scripts/lib/activity-counter.mjs';
 import { DEFAULT_CONFIG_DIR } from '../skills/jtb/scripts/lib/config.mjs';
 import { checkTeamJiraConfigUpdate } from '../skills/jtb/scripts/lib/team-jira-sync.mjs';
+import { maybeAutoFlush } from '../skills/jtb/scripts/lib/recall-queue.mjs';
 
 const TRACKED_COMMANDS = new Set([
   'triage', 'fetch', 'get', 'compliance', 'review', 'standup',
@@ -60,6 +61,26 @@ revalidateIfStale();
 // Fire-and-forget: refresh the cached latest npm version once per 24h
 checkForUpdate();
 
+// Best-effort: retry any Recall notes still queued from a prior failed push —
+// on every command now, not just note add/recall, so a backlog from a burst
+// of transient failures doesn't just sit until the user happens to run one
+// of those two again. Cheap no-op when the queue is empty (one local file
+// read); maybeAutoFlush's own cooldown still protects a down backend from
+// being hit by every single command.
+try {
+  const cliToken = readCliToken(DEFAULT_CONFIG_DIR);
+  if (cliToken) {
+    // Short timeout — this runs before every command, unrelated to Recall or
+    // not, so it must never be the reason an unrelated command feels slow.
+    const result = await maybeAutoFlush({ cliToken, configDir: DEFAULT_CONFIG_DIR, timeoutMs: 4000 });
+    if (result?.flushed) {
+      process.stderr.write(`  ✔ Synced ${result.flushed} pending Recall note${result.flushed === 1 ? '' : 's'}.\n`);
+    }
+  }
+} catch {
+  // Never let a background sync check break the actual command.
+}
+
 // Show a one-line update hint on stderr after the command exits (never blocks stdout)
 process.on('exit', () => {
   try {
@@ -630,6 +651,16 @@ switch (command) {
       });
       break;
     }
+    if (cmdArgs[0] === 'delete') {
+      const { runNoteDelete } = await import('../skills/jtb/scripts/lib/note-command.mjs');
+      runNoteDelete(cmdArgs.slice(1)).then(({ deleted }) => {
+        if (!deleted) process.exitCode = 1;
+      }).catch(err => {
+        process.stderr.write(`Error: ${err.message}\n`);
+        process.exitCode = 1;
+      });
+      break;
+    }
     process.stderr.write('Usage: ticketlens note add --title="..." [--ticket=KEY] [--tags=a,b]\n');
     process.exitCode = 1;
     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ticketlens",
-  "version": "0.21.4",
+  "version": "0.21.6",
   "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/help.mjs

@@ -520,6 +520,12 @@ export function printNoteHelp({ stream = process.stdout } = {}) {
     `  Code session — not typically invoked by hand. Every note it writes gets the`,
     `  same structural and secret-scan checks ${s.brand('note add')} applies to user input.`,
     '',
+    `  ${s.bold('ticketlens note delete')} ${s.dim('--id="..." [--ticket=KEY]')}  ${s.dim('[Pro]')}`,
+    '',
+    `  Removes a note from your local vault. Local only — if this note was already`,
+    `  pushed to a team, teammates who pulled it keep their copy; deleting it there`,
+    `  too is a manager action from the Console (Admin > Recall).`,
+    '',
   ];
   stream.write(lines.join('\n') + '\n');
 }

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

@@ -11,7 +11,7 @@ import { DEFAULT_CONFIG_DIR } from './config.mjs';
 import { isLicensed, showUpgradePrompt } from './license.mjs';
 import { scanForSecrets } from './secret-scanner.mjs';
 import { checkNoteStructure } from './note-structural-check.mjs';
-import { writeNote, patchNoteBody } from './recall-vault.mjs';
+import { writeNote, patchNoteBody, deleteNote } from './recall-vault.mjs';
 import { readCliToken } from './cli-auth.mjs';
 import { pushNote } from './recall-sync.mjs';
 import { enqueueNote, isRetryableFailure, maybeAutoFlush } from './recall-queue.mjs';
@@ -210,3 +210,45 @@ export async function runNotePatch(cmdArgs, {
   stream.write(patched ? `  Updated note (${id})\n` : `  Note not updated — (${id}) not found or already changed.\n`);
   return { patched };
 }
+
+/**
+ * Implements `tl note delete` — removes a note from the local vault only.
+ *
+ * Local-only, same limitation `note patch` already documents: if this note
+ * was already pushed to a team (Team Recall enabled), teammates who already
+ * pulled it keep their copy — this does not push a tombstone. Deleting a
+ * note everywhere it's synced is a manager action from the Console today
+ * (Admin > Recall), which does propagate a tombstone on next pull.
+ *
+ * @param {string[]} cmdArgs
+ * @returns {Promise<{ deleted: boolean }>}
+ */
+export async function runNoteDelete(cmdArgs, {
+  configDir = DEFAULT_CONFIG_DIR,
+  stream = process.stderr,
+  isLicensedFn = isLicensed,
+  deleteNoteFn = deleteNote,
+} = {}) {
+  if (!isLicensedFn('pro', configDir)) {
+    showUpgradePrompt('pro', 'ticketlens note', { stream });
+    return { deleted: false };
+  }
+
+  const id = parseFlag(cmdArgs, 'id');
+  if (!id) {
+    stream.write('Usage: ticketlens note delete --id="..." [--ticket=KEY]\n');
+    return { deleted: false };
+  }
+
+  const ticketKey = parseFlag(cmdArgs, 'ticket');
+  if (ticketKey && !TICKET_KEY_PATTERN.test(ticketKey)) {
+    stream.write(`  Invalid --ticket value "${ticketKey}" — expected a ticket key like PROJ-123.\n`);
+    return { deleted: false };
+  }
+
+  const { deleted } = deleteNoteFn({ external_id: id, tickets: ticketKey ? [ticketKey] : [] }, { configDir });
+  stream.write(deleted
+    ? `  Deleted note (${id}) — local vault only; see help for team-synced notes.\n`
+    : `  Note not deleted — (${id}) not found.\n`);
+  return { deleted };
+}

package/skills/jtb/scripts/lib/recall-queue.mjs

@@ -141,6 +141,7 @@ export async function flushQueue({
   isRetryableFailureFn = isRetryableFailure,
   warn = () => {},
   now = () => Date.now(),
+  timeoutMs,
 } = {}) {
   const nowMs = now();
   const currentHash = hashToken(cliToken);
@@ -154,7 +155,9 @@ export async function flushQueue({
       continue;
     }
 
-    const result = await pushNoteFn(entry.notePayload, { cliToken, configDir, warn });
+    const result = await pushNoteFn(entry.notePayload, {
+      cliToken, configDir, warn, ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+    });
     if (result.ok) {
       flushed++;
       continue;
@@ -191,36 +194,52 @@ function writeLastFlushAttemptAt(configDir, isoTimestamp) {
 }
 
 /**
- * Time-gated background flush, attempted from the CLI's existing
- * Recall-touching entry points (note add's push, recall's pull) rather than
- * on every invocation — a no-op unless the queue is non-empty AND at least
- * AUTO_FLUSH_INTERVAL_MS has passed since the last attempt. The attempt
- * timestamp is recorded even on failure, so a down backend can't be hammered
- * once per command within the window.
+ * Time-gated background flush. Called from every command's entry point
+ * (bin/ticketlens.mjs), not just Recall-specific ones — a note added during
+ * a burst of failures (e.g. a debugging session) would otherwise sit queued
+ * until the user happens to run `note add`/`recall` again, or runs
+ * `recall sync` by hand. A no-op unless the queue is non-empty AND at least
+ * AUTO_FLUSH_INTERVAL_MS has passed since the last attempt — the interval is
+ * a single global cooldown, not per-entry, so a burst of failures in one
+ * short window still only gets one automatic retry pass, by design: this
+ * runs on every command now, so the next opportunity is never far away, and
+ * the cooldown exists specifically to stop a down backend from being hit by
+ * every single command in the meantime. The attempt timestamp is recorded
+ * even on failure, so a down backend can't be hammered once per command
+ * within the window.
  *
  * @param {object}   opts
  * @param {string}   opts.cliToken
  * @param {string}   [opts.configDir]
  * @param {() => number} [opts.now]
  * @param {Function} [opts.flushQueueFn]
+ * @param {number}   [opts.timeoutMs] - per-request timeout, passed through to
+ *   pushNote. Callers running this unconditionally on every command (as
+ *   opposed to an explicit `recall sync`) should pass something short — this
+ *   must feel instant, not stall an unrelated command behind a slow network.
+ * @returns {Promise<{flushed: number, remaining: number}|null>} null if skipped
+ *   (empty queue or still cooling down) — distinguishes "nothing to report"
+ *   from "attempted, flushed 0" for a caller that wants to print a summary.
  */
 export async function maybeAutoFlush({
   cliToken,
   configDir = DEFAULT_CONFIG_DIR,
   now = () => Date.now(),
   flushQueueFn = flushQueue,
+  timeoutMs,
 } = {}) {
-  if (readQueue(configDir).length === 0) return;
+  if (readQueue(configDir).length === 0) return null;
 
   const lastAttemptAt = readLastFlushAttemptAt(configDir);
   const nowMs = now();
-  if (lastAttemptAt && nowMs - new Date(lastAttemptAt).getTime() < AUTO_FLUSH_INTERVAL_MS) return;
+  if (lastAttemptAt && nowMs - new Date(lastAttemptAt).getTime() < AUTO_FLUSH_INTERVAL_MS) return null;
 
   try {
-    await flushQueueFn({ cliToken, configDir, now });
+    return await flushQueueFn({ cliToken, configDir, now, ...(timeoutMs !== undefined ? { timeoutMs } : {}) });
   } catch {
     // A down backend or a thrown network error must never crash the command
     // that opportunistically triggered this background attempt.
+    return null;
   } finally {
     writeLastFlushAttemptAt(configDir, new Date(nowMs).toISOString());
   }

package/skills/jtb/scripts/lib/secret-scanner.mjs

@@ -101,25 +101,41 @@ function hasInternalCaseSwitch(token) {
 /**
  * True for a token that stops a joined-chunk run: either a recognized git/
  * checksum label word ("commit", "sha256", "md5sum", ...), or an ordinary
- * English word (letters only, no base64-style case switching). Anything else —
- * a fragment containing a digit/symbol, or an all-letter chunk that still reads
- * as random content — stays eligible to join, so a secret split by whitespace
- * can still be reassembled for the entropy check.
+ * English word (letters only, optionally with an internal possessive/
+ * contraction apostrophe — "relay's", "doesn't" — but no base64-style case
+ * switching). Anything else — a fragment containing a digit or other symbol,
+ * a hyphenated compound, or an all-letter chunk that still reads as random
+ * content — stays eligible to join, so a secret split by whitespace can still
+ * be reassembled for the entropy check.
  *
- * Known accepted gap: this can't tell a genuine dictionary word from one an
+ * The apostrophe allowance matters because without it, an ordinary possessive
+ * next to another non-label token (e.g. a hyphenated compound: "relay's
+ * decision-lookup") never gets a chance to stop the run — both fail to
+ * qualify, so they concatenate into one artificial blob whose mixed
+ * punctuation trips the entropy threshold. A real false positive, not a
+ * hypothetical one (see the regression test below). Hyphenated tokens are
+ * deliberately NOT given the same allowance: a short prefix + hyphen + long
+ * letter-run is indistinguishable from a real compound word by shape alone
+ * (e.g. "sk-abcdefghijklmnop", the letters-only half of a whitespace-split
+ * API key) — see the adjacent regression test for exactly this shape. Once
+ * the apostrophe fix lets "relay's" stop the run on its own, an adjacent
+ * hyphenated compound is short enough on its own to fall under
+ * MIN_RANDOM_TOKEN_LENGTH anyway, so it never needed the same allowance.
+ *
+ * Known accepted gap: this can't tell a genuine possessive from one an
  * attacker deliberately chose as a separator to defeat the scanner (e.g.
- * splitting a secret around the word "wall"). Closing that would require
- * treating ordinary prose words as joinable too, which in turn re-joins real
- * sentence text into false-positive "random" strings (verified empirically —
- * see the regression test for "PROD-123456 for background"). Entropy-based
- * detection is a safety net, not a cryptographic guarantee; the well-known
- * secret shapes in HARD_REJECT_PATTERNS are the layer that's fully whitespace-
- * and word-insertion-proof, since they match a specific literal prefix.
+ * splitting a secret around "user's"). Closing that would require treating
+ * ordinary prose words as joinable too, which in turn re-joins real sentence
+ * text into false-positive "random" strings (verified empirically — see the
+ * regression test for "PROD-123456 for background"). Entropy-based detection
+ * is a safety net, not a cryptographic guarantee; the well-known secret
+ * shapes in HARD_REJECT_PATTERNS are the layer that's fully whitespace- and
+ * word-insertion-proof, since they match a specific literal prefix.
  */
 function isLabelWord(token) {
   const stripped = stripEdgePunctuation(token);
   if (GIT_REFERENCE_WORD_RE.test(stripped)) return true;
-  return /^[A-Za-z]+$/.test(stripped) && !hasInternalCaseSwitch(stripped);
+  return /^[A-Za-z]+(?:'[A-Za-z]+)*$/.test(stripped) && !hasInternalCaseSwitch(stripped);
 }
 
 /**