@skitterbyte/skitterspec-linear 7.0.0 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skitterbyte/skitterspec-linear",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "Spec-driven development for Claude Code, with Linear hybrid-sync — a superset of @skitterbyte/skitterspec: the base filesystem workflow plus git-like /spec-status · /spec-pull · /spec-push and the spec-sync CLI. Install this OR the base, not both.",
   "keywords": [
     "claude",

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

@@ -16,6 +16,7 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
+const { findTaskBlocks, collapse } = require('./task-block.js')
 
 // --- markdown / frontmatter parsing -----------------------------------------
 
@@ -165,10 +166,15 @@ function readPhaseFiles(snapshotDir) {
     .map((file) => {
       const raw = fs.readFileSync(path.join(snapshotDir, file), 'utf-8')
       const { data, body } = parseFrontmatter(raw)
-      const goal = (/^\*\*Goal:\*\*\s*([\s\S]*?)(?:\n\n|$)/m.exec(body) || [])[1] || ''
-      const tasks = (body.match(/^-\s*\[[ x]\]\s*.*$/gm) || []).map((t) =>
-        t.replace(/^-\s*/, '').trim(),
-      )
+      // No /m on either: under /m, `$` matches end-of-LINE, so a non-greedy
+      // scan stops at the first newline and a hand-wrapped bullet or goal loses
+      // every continuation line. Tasks come from findTaskBlocks, which reads a
+      // wrapped bullet as one logical task.
+      // Collapsed, not just captured: the goal becomes a milestone description,
+      // and Linear may canonicalize a soft line break away on save. Collapsing
+      // both sides keeps a wrapped goal from diffing forever.
+      const goal = collapse((/\*\*Goal:\*\*\s*([\s\S]*?)(?:\n\n|$)/.exec(body) || [])[1] || '')
+      const tasks = findTaskBlocks(body.split('\n')).map((b) => `[${b.mark}] ${b.text}`)
       return {
         phase: file.replace(/\.md$/, ''),
         file,

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

@@ -0,0 +1,95 @@
+'use strict'
+
+// Task bullets in a phase file are hand-wrapped prose, not single lines:
+//
+//   - [x] Add `DbProcessEventOutbox` to `prisma/schema.prisma`, modelled on
+//         `DbNotificationOutbox`: status, attempts, `nextAttemptAt`, …
+//
+// A Linear issue title is single-line, so the two representations differ by
+// wrapping alone. This module is the one place that converts between them:
+// `findTaskBlocks` reads wrapped bullets into logical tasks, `renderTaskBlock`
+// writes a logical task back out re-wrapped in the file's own style.
+//
+// Everything here is line-index based so callers can splice whole blocks.
+
+const DEFAULT_WIDTH = 80
+
+// Start of a task bullet. The continuation lines that follow are any indented,
+// non-empty lines that are not themselves a bullet or heading.
+const TASK_START_RE = /^([ \t]*)-\s*\[([ xX])\]\s*(.*)$/
+const CONTINUATION_RE = /^[ \t]+\S/
+const BLOCK_BREAK_RE = /^[ \t]*(?:[-*+]\s|\d+\.\s|#{1,6}\s|>|\||```)/
+
+// Collapse a wrapped bullet's lines into the single logical line the rest of the
+// sync engine (and Linear) works in.
+function collapse(text) {
+  return String(text).replace(/\s+/g, ' ').trim()
+}
+
+/**
+ * Find every task bullet in `lines` as a logical block.
+ * @returns {Array<{start:number, end:number, indent:string, mark:string, text:string}>}
+ *   `end` is exclusive. `text` is the collapsed single-line form, id included.
+ */
+function findTaskBlocks(lines) {
+  const blocks = []
+  for (let i = 0; i < lines.length; i++) {
+    const m = TASK_START_RE.exec(lines[i])
+    if (!m) continue
+    const parts = [m[3]]
+    let j = i + 1
+    for (; j < lines.length; j++) {
+      const l = lines[j]
+      if (!l.trim()) break
+      if (!CONTINUATION_RE.test(l)) break
+      if (BLOCK_BREAK_RE.test(l)) break
+      parts.push(l.trim())
+    }
+    blocks.push({
+      start: i,
+      end: j,
+      indent: m[1],
+      mark: m[2].toLowerCase() === 'x' ? 'x' : ' ',
+      text: collapse(parts.join(' ')),
+    })
+    i = j - 1
+  }
+  return blocks
+}
+
+/**
+ * Render a logical task back into wrapped file lines, matching the surrounding
+ * style: `- [x] ` opener, continuations aligned under the text.
+ * @returns {string[]}
+ */
+function renderTaskBlock({ indent = '', done, text, id }, width = DEFAULT_WIDTH) {
+  const opener = `${indent}- [${done ? 'x' : ' '}] `
+  const hang = ' '.repeat(opener.length)
+  const body = collapse(text) + (id ? ` (${id})` : '')
+
+  const out = []
+  let line = opener
+  let first = true
+  for (const word of body.split(' ')) {
+    if (!first && line.length + 1 + word.length > width) {
+      out.push(line)
+      line = hang + word
+    } else {
+      line += (first ? '' : ' ') + word
+      first = false
+    }
+  }
+  out.push(line)
+  return out
+}
+
+// Infer the wrap width a file already uses, so a rewrite doesn't reflow it to a
+// different column. Falls back to the default when there's nothing to learn from.
+function inferWidth(lines, fallback = DEFAULT_WIDTH) {
+  const widths = lines.filter((l) => l.trim()).map((l) => l.length)
+  if (!widths.length) return fallback
+  const max = Math.max(...widths)
+  return max > 40 && max <= 120 ? Math.max(max, 60) : fallback
+}
+
+module.exports = { findTaskBlocks, renderTaskBlock, collapse, inferWidth, DEFAULT_WIDTH }

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

@@ -18,6 +18,12 @@
 
 const fs = require('node:fs')
 const path = require('node:path')
+const {
+  findTaskBlocks,
+  renderTaskBlock,
+  collapse,
+  inferWidth,
+} = require('./task-block.js')
 
 // Serialize a JS value as a YAML-ish frontmatter scalar. null/undefined → the
 // key is dropped (caller shouldn't pass those).
@@ -222,33 +228,31 @@ function applyMilestonesPull(snapshotDir, items) {
 
 // --- task-line denormalizer (keyed issue pull) -----------------------------
 //
-// Tasks live as checkbox lines inside phase files. A pulled issue edit rewrites
-// the matching line (by its inline id) in place; a Linear-only issue appends a
-// new task line; a created issue's id is stamped inline. Removals report-only.
+// Tasks live as (hand-wrapped) checkbox bullets inside phase files. A pulled
+// issue edit rewrites the matching bullet — whole block, re-wrapped — by its
+// inline id; a Linear-only issue appends a new bullet; a created issue's id is
+// stamped inline. Removals report-only. See task-block.js for the wrapping.
 
-const TASK_RE = /^(\s*)-\s*\[([ xX])\]\s*(.*)$/
 const INLINE_ID_RE = /\s*\(([A-Za-z][A-Za-z0-9]*-\d+)\)\s*$/
 
-// Render a task line from an item.
-function taskLine(indent, { id, text, done }) {
-  return `${indent}- [${done ? 'x' : ' '}] ${text}${id ? ` (${id})` : ''}`
-}
-
-// Update the task line carrying inline id `id` (text + checkbox), in place.
+// Update the task carrying inline id `id` (text + checkbox), in place.
+//
+// Block-aware: a task bullet is hand-wrapped across several lines, so the whole
+// block is replaced and the new text re-wrapped in the file's own style. Editing
+// only the first line would strand its continuation lines as orphaned prose.
 function updateTaskLine(snapshotDir, id, { text, done }) {
   const want = String(id)
   for (const file of listPhaseFiles(snapshotDir)) {
     const p = path.join(snapshotDir, file)
     const lines = fs.readFileSync(p, 'utf-8').split('\n')
-    for (let i = 0; i < lines.length; i++) {
-      const m = TASK_RE.exec(lines[i])
-      if (!m) continue
-      const idm = INLINE_ID_RE.exec(m[3])
-      if (idm && idm[1] === want) {
-        lines[i] = taskLine(m[1], { id: want, text, done })
-        fs.writeFileSync(p, lines.join('\n'), 'utf-8')
-        return true
-      }
+    const width = inferWidth(lines)
+    for (const b of findTaskBlocks(lines)) {
+      const idm = INLINE_ID_RE.exec(b.text)
+      if (!idm || idm[1] !== want) continue
+      const rendered = renderTaskBlock({ indent: b.indent, done, text, id: want }, width)
+      lines.splice(b.start, b.end - b.start, ...rendered)
+      fs.writeFileSync(p, lines.join('\n'), 'utf-8')
+      return true
     }
   }
   return false
@@ -262,11 +266,10 @@ function addTaskLine(snapshotDir, item) {
   if (!file) return null
   const p = path.join(snapshotDir, file)
   const lines = fs.readFileSync(p, 'utf-8').split('\n')
-  let lastTask = -1
-  for (let i = 0; i < lines.length; i++) if (TASK_RE.test(lines[i])) lastTask = i
-  const line = taskLine('', item)
-  if (lastTask >= 0) lines.splice(lastTask + 1, 0, line)
-  else lines.push(line)
+  const blocks = findTaskBlocks(lines)
+  const rendered = renderTaskBlock({ indent: '', ...item }, inferWidth(lines))
+  if (blocks.length) lines.splice(blocks[blocks.length - 1].end, 0, ...rendered)
+  else lines.push(...rendered)
   fs.writeFileSync(p, lines.join('\n'), 'utf-8')
   return file
 }
@@ -274,18 +277,21 @@ function addTaskLine(snapshotDir, item) {
 // Stamp an inline id onto the (idless) task line whose text matches — used after
 // the skill creates an issue for a new local task.
 function stampIssueId(snapshotDir, text, id) {
-  const want = String(text).trim()
+  const want = collapse(text)
   for (const file of listPhaseFiles(snapshotDir)) {
     const p = path.join(snapshotDir, file)
     const lines = fs.readFileSync(p, 'utf-8').split('\n')
-    for (let i = 0; i < lines.length; i++) {
-      const m = TASK_RE.exec(lines[i])
-      if (!m || INLINE_ID_RE.test(m[3])) continue
-      if (m[3].trim() === want) {
-        lines[i] = `${m[1]}- [${m[2].toLowerCase() === 'x' ? 'x' : ' '}] ${want} (${id})`
-        fs.writeFileSync(p, lines.join('\n'), 'utf-8')
-        return file
-      }
+    const width = inferWidth(lines)
+    for (const b of findTaskBlocks(lines)) {
+      if (INLINE_ID_RE.test(b.text)) continue
+      if (b.text !== want) continue
+      const rendered = renderTaskBlock(
+        { indent: b.indent, done: b.mark === 'x', text: want, id },
+        width,
+      )
+      lines.splice(b.start, b.end - b.start, ...rendered)
+      fs.writeFileSync(p, lines.join('\n'), 'utf-8')
+      return file
     }
   }
   return null