@skitterbyte/skitterspec-linear 8.0.3 → 8.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skitterbyte/skitterspec-linear",
-  "version": "8.0.3",
+  "version": "8.0.5",
   "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

@@ -16,7 +16,7 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
-const { findTaskBlocks, collapse, collapseHyphenAware } = require('./task-block.js')
+const { fenceMask, findTaskBlocks, collapse, collapseHyphenAware } = require('./task-block.js')
 
 // --- markdown / frontmatter parsing -----------------------------------------
 
@@ -57,6 +57,7 @@ function parseScalar(v) {
 // heading text → its content (until the next `## `). The H1 `# ` is the title.
 function parseSections(body) {
   const lines = body.split('\n')
+  const inFence = fenceMask(lines)
   let title = null
   const sections = {}
   let current = null
@@ -64,9 +65,12 @@ function parseSections(body) {
   const flush = () => {
     if (current !== null) sections[current] = buf.join('\n').trim()
   }
-  for (const line of lines) {
-    const h1 = /^#\s+(.*)$/.exec(line)
-    const h2 = /^##\s+(.*)$/.exec(line)
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    // A `#`/`##` inside a fenced code block is example text, not a real heading —
+    // treat it as body content so it can't start a phantom section.
+    const h1 = inFence[i] ? null : /^#\s+(.*)$/.exec(line)
+    const h2 = inFence[i] ? null : /^##\s+(.*)$/.exec(line)
     if (h1 && title === null) {
       title = h1[1].trim()
       continue

package/src/vendor/sync-core/src/task-block.js

@@ -19,6 +19,41 @@ const DEFAULT_WIDTH = 80
 const TASK_START_RE = /^([ \t]*)-\s*\[([ xX])\]\s*(.*)$/
 const CONTINUATION_RE = /^[ \t]+\S/
 const BLOCK_BREAK_RE = /^[ \t]*(?:[-*+]\s|\d+\.\s|#{1,6}\s|>|\||```)/
+// A list-marker line (unordered or ordered). Distinguished from other block
+// breaks because a wrapped continuation can legitimately begin with one.
+const LIST_MARKER_RE = /^[ \t]*(?:[-*+]|\d+\.)\s/
+// A checkbox bullet — unambiguously a task, so it always starts its own block,
+// at any indent. (A bare list marker is ambiguous; a checkbox never is.)
+const CHECKBOX_RE = /^[ \t]*[-*+]\s*\[[ xX]\]/
+
+// Mark every line that lies inside a fenced code block — the opening fence, its
+// content, and the closing fence all count as `true`. Line scanners that hunt
+// for markdown structure (task bullets, section headings) use this to ignore an
+// EXAMPLE of that structure shown inside a fence: a spec that documents a
+// checklist format in a ``` block must not have those example bullets harvested
+// as real tasks (and pushed as real tracker issues). Supports ``` and ~~~ fences
+// of any length ≥ 3; a closing fence is a bare marker (no info string) of the
+// same character and at least the opening length.
+function fenceMask(lines) {
+  const mask = new Array(lines.length).fill(false)
+  let open = null // the opening marker string (``` or ~~~ …), or null
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim()
+    if (open) {
+      mask[i] = true
+      if (/^(`{3,}|~{3,})$/.test(trimmed) && trimmed[0] === open[0] && trimmed.length >= open.length) {
+        open = null
+      }
+      continue
+    }
+    const m = /^[ \t]*(`{3,}|~{3,})/.exec(lines[i])
+    if (m) {
+      open = m[1]
+      mask[i] = true
+    }
+  }
+  return mask
+}
 
 // Collapse a wrapped bullet's lines into the single logical line the rest of the
 // sync engine (and Linear) works in.
@@ -78,16 +113,35 @@ function spanMask(body) {
  */
 function findTaskBlocks(lines) {
   const blocks = []
+  const inFence = fenceMask(lines)
   for (let i = 0; i < lines.length; i++) {
+    if (inFence[i]) continue // an example bullet inside a ``` block is not a task
     const m = TASK_START_RE.exec(lines[i])
     if (!m) continue
     const parts = [m[3]]
+    // The hanging indent: where the bullet's text starts (marker width). A
+    // wrapped continuation aligns exactly AT this column.
+    const hang = lines[i].length - m[3].length
     let j = i + 1
     for (; j < lines.length; j++) {
       const l = lines[j]
       if (!l.trim()) break
+      if (inFence[j]) break // a fence opening ends the bullet, never continues it
       if (!CONTINUATION_RE.test(l)) break
-      if (BLOCK_BREAK_RE.test(l)) break
+      if (BLOCK_BREAK_RE.test(l)) {
+        // Indent alone can't tell a nested child from a wrapped continuation —
+        // both sit at the hanging indent. The *marker* is the reliable signal:
+        //   - a checkbox (- [ ] / - [x]) is unambiguously a task → always break;
+        //   - a bare marker (-/*/+/N.) is wrapped continuation prose ONLY when it
+        //     sits exactly at the hang; shallower or deeper it's a real sub/
+        //     sibling list → break. (Keeping the at-hang continuation preserves
+        //     the task's stamped id, so the next push updates instead of
+        //     creating a duplicate issue.)
+        //   - headings, quotes, tables and fences always break.
+        if (CHECKBOX_RE.test(l)) break
+        const indent = l.length - l.trimStart().length
+        if (!LIST_MARKER_RE.test(l) || indent !== hang) break
+      }
       parts.push(l.trim())
     }
     blocks.push({
@@ -177,6 +231,7 @@ function inferWidth(lines, fallback = DEFAULT_WIDTH) {
 }
 
 module.exports = {
+  fenceMask,
   findTaskBlocks,
   renderTaskBlock,
   wrapEmphasisAware,