@skitterbyte/skitterspec-linear 8.0.1 → 8.0.2

package/assets/core/SETUP.md

@@ -168,3 +168,9 @@ With a linked spec, confirm push end-to-end:
   (`Backlog / Planned / In Progress / Completed / Canceled`).
 - **Reconnecting doesn't switch workspace** — Linear ties the OAuth session to one
   workspace. Remove and re-add the server to authenticate against another.
+- **Bold around an inline code span renders oddly in Linear** — Linear moves the
+  closing `**` before an inline code span on save (`**no unresolved `` `X` ``**`
+  → `**no unresolved** `` `X` ``). This is a Linear rendering quirk in the mirror
+  only; it never touches your repo (one-way sync never reads content back), so
+  it's cosmetic. Avoid wrapping a whole phrase that ends in code in bold if the
+  mirror's rendering matters to you.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skitterbyte/skitterspec-linear",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "description": "Spec-driven development for Claude Code, with one-way Linear sync — a superset of @skitterbyte/skitterspec: the base filesystem workflow plus /spec-status · /spec-push and the spec-sync CLI. The repo is canonical; Linear is a generated mirror. Install this OR the base, not both.",
   "keywords": [
     "claude",

package/src/vendor/sync-core/src/normalize.js

@@ -433,6 +433,19 @@ function remoteWorkflowState(project, config) {
   return name != null ? bucketForState(name, config) : null
 }
 
+// Trim a trailing parenthetical whose opener has no matching close — so a cut
+// title never ends on a dangling `(`/`[`.
+function dropUnclosedBracket(t) {
+  for (const [open, close] of [
+    ['(', ')'],
+    ['[', ']'],
+  ]) {
+    const o = t.lastIndexOf(open)
+    if (o !== -1 && t.indexOf(close, o) === -1) t = t.slice(0, o)
+  }
+  return t
+}
+
 // Derive a short Linear issue title from a task's full text: the first sentence,
 // falling back to the first `max` chars at a word boundary. A paragraph-length
 // task keeps its full text as the issue *description* (see the projection); this
@@ -457,8 +470,23 @@ function titleFromText(text, max = 100) {
   title = title.trim()
   if (title.length > max) {
     const cut = title.slice(0, max)
-    const sp = cut.lastIndexOf(' ')
-    title = (sp > 40 ? cut.slice(0, sp) : cut).trim()
+    // Prefer the last clause boundary before the limit — a terminator/separator
+    // to cut AFTER (`.`/`;`/`:`…) or a dash to cut BEFORE — over a bare word break.
+    const minCut = Math.floor(max * 0.4)
+    let boundary = -1
+    let mm
+    const after = /[.!?;:](?=\s|$)/g
+    while ((mm = after.exec(cut)) !== null) boundary = Math.max(boundary, mm.index + 1)
+    const before = /\s[—–]/g
+    while ((mm = before.exec(cut)) !== null) boundary = Math.max(boundary, mm.index)
+    let t
+    if (boundary > minCut) {
+      t = cut.slice(0, boundary)
+    } else {
+      const sp = cut.lastIndexOf(' ')
+      t = sp > 40 ? cut.slice(0, sp) : cut
+    }
+    title = dropUnclosedBracket(t).replace(/[\s.,:;—–([]+$/, '').trim()
   }
   return title
 }

package/src/vendor/sync-core/src/sanitise.js

@@ -36,6 +36,29 @@ function cleanLogicalLine(text) {
 const BULLET_RE = /^(\s*)((?:[-*+]|\d+\.)\s+(?:\[[ xX]\]\s+)?)(.*)$/
 // Structural blocks we never reflow.
 const PASSTHROUGH_RE = /^\s*(#{1,6}\s|>|\||[-*_]{3,}\s*$|<)/
+// A line that is its own structural block — a blockquote (`>`) or a table/pipe
+// row (`|`). A hard boundary a join must never reach across (else the markers get
+// absorbed into the preceding paragraph as literal text); copied verbatim.
+const STRUCT_LINE_RE = /^[ \t]*[>|]/
+// A fenced-code delimiter.
+const FENCE_RE = /^[ \t]*```/
+
+// A structural fingerprint of a document: the count of block-marker lines that a
+// safe reflow must leave untouched. Used as a self-check — if sanitising changes
+// any of these, the reflow corrupted structure (a blockquote absorbed, a fence
+// eaten, a bullet collapsed) and the write is refused. Cheap insurance against the
+// next corruption class, not just the ones we special-case.
+function structuralSignature(text) {
+  let struct = 0 // blockquote or pipe-row lines
+  let fence = 0
+  let bullets = 0
+  for (const l of String(text).split('\n')) {
+    if (STRUCT_LINE_RE.test(l)) struct++
+    if (FENCE_RE.test(l)) fence++
+    if (BULLET_RE.test(l)) bullets++
+  }
+  return `${struct}|${fence}|${bullets}`
+}
 // A GFM table separator row (only pipes/colons/dashes/spaces, with a pipe AND a
 // dash). Detecting a table by this — not by any stray `|` — so a pipe inside an
 // inline `code|span` doesn't make us treat a whole list as an untouchable table.
@@ -99,21 +122,28 @@ function sanitizeSpecMarkdown(text, { width } = {}) {
   while (i < lines.length) {
     const line = lines[i]
     // Fenced code — copy verbatim through the closing fence.
-    if (/^[ \t]*```/.test(line)) {
+    if (FENCE_RE.test(line)) {
       out.push(line)
       i++
-      while (i < lines.length && !/^[ \t]*```/.test(lines[i])) out.push(lines[i++])
+      while (i < lines.length && !FENCE_RE.test(lines[i])) out.push(lines[i++])
       if (i < lines.length) out.push(lines[i++])
       continue
     }
+    // Blockquote / table row — copy the whole run verbatim. A hard boundary: a
+    // join must never reach across it, so it also terminates any preceding block.
+    if (STRUCT_LINE_RE.test(line)) {
+      while (i < lines.length && STRUCT_LINE_RE.test(lines[i])) out.push(lines[i++])
+      continue
+    }
     if (!line.trim()) {
       out.push(line)
       i++
       continue
     }
-    // Gather a block of consecutive non-blank, non-fence lines.
+    // Gather a block of consecutive non-blank lines, stopping at any structural
+    // boundary (fence, blockquote, table row) so a reflow can't absorb one.
     let j = i
-    while (j < lines.length && lines[j].trim() && !/^[ \t]*```/.test(lines[j])) j++
+    while (j < lines.length && lines[j].trim() && !FENCE_RE.test(lines[j]) && !STRUCT_LINE_RE.test(lines[j])) j++
     const block = lines.slice(i, j)
     i = j
 
@@ -137,7 +167,13 @@ function sanitizeSpecMarkdown(text, { width } = {}) {
     }
   }
   const result = out.join('\n')
+  // Self-check: a safe reflow never changes the count of structural markers. If it
+  // did, we corrupted something (a blockquote, fence, or bullet) — refuse the write
+  // and hand back the original untouched, flagged for the caller to report.
+  if (result !== src && structuralSignature(result) !== structuralSignature(src)) {
+    return { text: src, changed: false, fixes: 0, refused: true }
+  }
   return { text: result, changed: result !== src, fixes }
 }
 
-module.exports = { sanitizeSpecMarkdown, hasStraddle }
+module.exports = { sanitizeSpecMarkdown, hasStraddle, structuralSignature }