@searls/turbocommit 0.10.0

package/lib/session.js

@@ -0,0 +1,298 @@
+const fs = require('fs')
+const path = require('path')
+const { ensureDir } = require('./io')
+
+const BREADCRUMB_THRESHOLD_MS = 2000
+const STALE_TTL_MS = 24 * 60 * 60 * 1000
+
+function turbocommitDir (root) {
+  return path.join(root, '.git', 'turbocommit')
+}
+
+function breadcrumbDir (root) {
+  return path.join(turbocommitDir(root), 'breadcrumbs')
+}
+
+function chainDir (root) {
+  return path.join(turbocommitDir(root), 'chains')
+}
+
+function pendingDir (root) {
+  return path.join(turbocommitDir(root), 'pending')
+}
+
+function watermarkDir (root) {
+  return path.join(turbocommitDir(root), 'watermarks')
+}
+
+/**
+ * SessionEnd handler. Writes a breadcrumb for the ending session.
+ */
+function handleSessionEnd (input, root) {
+  if (!root) return
+
+  let hookInput
+  try {
+    hookInput = JSON.parse(input)
+  } catch {
+    return
+  }
+
+  const sessionId = hookInput.session_id
+  if (!sessionId) return
+
+  const dir = breadcrumbDir(root)
+  ensureDir(dir)
+  const data = { session_id: sessionId, timestamp: Date.now() }
+  fs.writeFileSync(path.join(dir, sessionId + '.json'), JSON.stringify(data) + '\n')
+}
+
+/**
+ * SessionStart handler. Matches breadcrumbs for /clear and resume continuations.
+ */
+function handleSessionStart (input, root) {
+  if (!root) return
+
+  let hookInput
+  try {
+    hookInput = JSON.parse(input)
+  } catch {
+    return
+  }
+
+  const sessionId = hookInput.session_id
+  if (!sessionId) return
+
+  const source = hookInput.source
+  if (source !== 'clear' && source !== 'resume') return
+
+  const dir = breadcrumbDir(root)
+  if (!fs.existsSync(dir)) return
+
+  // Scan breadcrumbs for closest match
+  const now = Date.now()
+  let best = null
+  let bestGap = Infinity
+
+  let files
+  try {
+    files = fs.readdirSync(dir)
+  } catch {
+    return
+  }
+
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(dir, file), 'utf8'))
+      const gap = Math.abs(now - data.timestamp)
+      if (gap < bestGap) {
+        bestGap = gap
+        best = data
+      }
+    } catch {
+      continue
+    }
+  }
+
+  if (!best || bestGap > BREADCRUMB_THRESHOLD_MS) return
+
+  // Claim the breadcrumb (delete it so no other session grabs it)
+  try {
+    fs.unlinkSync(path.join(dir, best.session_id + '.json'))
+  } catch {}
+
+  // Read predecessor's chain to get full ancestry
+  const predecessorChain = readChain(root, best.session_id)
+  const ancestors = [best.session_id, ...(predecessorChain ? predecessorChain.ancestors : [])]
+
+  // Write chain for this session
+  const cDir = chainDir(root)
+  ensureDir(cDir)
+  const chain = { parent: best.session_id, ancestors }
+  fs.writeFileSync(path.join(cDir, sessionId + '.json'), JSON.stringify(chain) + '\n')
+}
+
+function readChain (root, sessionId) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(chainDir(root), sessionId + '.json'), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Get ordered ancestor list for a session (nearest first).
+ */
+function getAncestors (root, sessionId) {
+  const chain = readChain(root, sessionId)
+  return chain ? chain.ancestors : []
+}
+
+/**
+ * Save formatted transcript to pending directory for later pickup.
+ */
+let pendingSeq = 0
+function savePending (root, sessionId, transcript) {
+  const dir = path.join(pendingDir(root), sessionId)
+  ensureDir(dir)
+  const timestamp = String(Date.now()) + '-' + String(pendingSeq++).padStart(4, '0')
+  fs.writeFileSync(path.join(dir, timestamp + '.txt'), transcript)
+}
+
+/**
+ * Collect pending transcripts for a list of session IDs, in order
+ * (oldest ancestor first). Returns array of strings.
+ */
+function collectPending (root, sessionIds) {
+  const results = []
+  for (const sid of sessionIds) {
+    const dir = path.join(pendingDir(root), sid)
+    let files
+    try {
+      files = fs.readdirSync(dir).sort()
+    } catch {
+      continue
+    }
+    for (const file of files) {
+      if (!file.endsWith('.txt')) continue
+      try {
+        const content = fs.readFileSync(path.join(dir, file), 'utf8')
+        if (content.trim()) results.push(content)
+      } catch {
+        continue
+      }
+    }
+  }
+  return results
+}
+
+/**
+ * Read watermark for a session. Returns { pairs, commit } or null.
+ */
+function readWatermark (root, sessionId) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(watermarkDir(root), sessionId + '.json'), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Save watermark after a commit: pair count and commit SHA.
+ */
+function saveWatermark (root, sessionId, pairs, commit) {
+  const dir = watermarkDir(root)
+  ensureDir(dir)
+  fs.writeFileSync(path.join(dir, sessionId + '.json'), JSON.stringify({ pairs, commit }) + '\n')
+}
+
+/**
+ * Resolve parent commit SHA for continuation references.
+ * Checks own watermark first, then walks chain ancestors nearest-first.
+ */
+function resolveParentCommit (root, sessionId) {
+  // Own watermark takes priority (same-session previous commit)
+  const own = readWatermark(root, sessionId)
+  if (own) return own.commit
+
+  // Walk chain ancestors nearest-first
+  const ancestors = getAncestors(root, sessionId)
+  for (const aid of ancestors) {
+    const wm = readWatermark(root, aid)
+    if (wm) return wm.commit
+  }
+  return null
+}
+
+/**
+ * Delete consumed pending + chain files after commit.
+ */
+function cleanupConsumed (root, sessionIds) {
+  for (const sid of sessionIds) {
+    // Remove pending dir
+    const dir = path.join(pendingDir(root), sid)
+    try {
+      const files = fs.readdirSync(dir)
+      for (const file of files) {
+        fs.unlinkSync(path.join(dir, file))
+      }
+      fs.rmdirSync(dir)
+    } catch {}
+
+    // Chain files are preserved — resolveParentCommit needs them
+    // to walk cross-session lineage. Stale cleanup handles them after 24h.
+  }
+}
+
+/**
+ * Remove stale orphaned files older than maxAgeMs (default 24h).
+ */
+function cleanupStale (root, maxAgeMs) {
+  const ttl = maxAgeMs != null ? maxAgeMs : STALE_TTL_MS
+  const now = Date.now()
+  const base = turbocommitDir(root)
+
+  for (const sub of ['breadcrumbs', 'chains', 'tracking', 'watermarks']) {
+    const dir = path.join(base, sub)
+    let files
+    try {
+      files = fs.readdirSync(dir)
+    } catch {
+      continue
+    }
+    for (const file of files) {
+      const fp = path.join(dir, file)
+      try {
+        const stat = fs.statSync(fp)
+        if (now - stat.mtimeMs > ttl) {
+          fs.unlinkSync(fp)
+        }
+      } catch {}
+    }
+  }
+
+  // Clean stale pending directories
+  const pDir = path.join(base, 'pending')
+  let pdirs
+  try {
+    pdirs = fs.readdirSync(pDir)
+  } catch {
+    return
+  }
+  for (const sid of pdirs) {
+    const dir = path.join(pDir, sid)
+    try {
+      const stat = fs.statSync(dir)
+      if (!stat.isDirectory()) continue
+      if (now - stat.mtimeMs > ttl) {
+        const files = fs.readdirSync(dir)
+        for (const file of files) {
+          fs.unlinkSync(path.join(dir, file))
+        }
+        fs.rmdirSync(dir)
+      }
+    } catch {}
+  }
+}
+
+module.exports = {
+  handleSessionEnd,
+  handleSessionStart,
+  getAncestors,
+  savePending,
+  collectPending,
+  cleanupConsumed,
+  cleanupStale,
+  readChain,
+  readWatermark,
+  saveWatermark,
+  resolveParentCommit,
+  breadcrumbDir,
+  chainDir,
+  pendingDir,
+  watermarkDir,
+  turbocommitDir,
+  BREADCRUMB_THRESHOLD_MS,
+  STALE_TTL_MS
+}

package/lib/track.js

@@ -0,0 +1,120 @@
+const fs = require('fs')
+const path = require('path')
+const { ensureDir } = require('./io')
+
+/**
+ * Directory under .git where turbocommit stores tracking state.
+ */
+function trackingDir (root) {
+  return path.join(root, '.git', 'turbocommit', 'tracking')
+}
+
+function trackingPath (root, sessionId) {
+  return path.join(trackingDir(root), sessionId + '.jsonl')
+}
+
+/**
+ * Keys to probe in tool_input for a file path (MCP tools, Write, Edit, etc.)
+ */
+const FILE_PATH_KEYS = ['file_path', 'filePath', 'path', 'file', 'notebook_path']
+
+/**
+ * Extract a file path from tool_input, heuristically checking known keys.
+ */
+function extractFilePath (toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return null
+  for (const key of FILE_PATH_KEYS) {
+    if (typeof toolInput[key] === 'string' && toolInput[key].length > 0) {
+      return toolInput[key]
+    }
+  }
+  return null
+}
+
+/**
+ * PreToolUse handler. Appends a tracking entry for potentially-modifying tools.
+ * Always exits 0 (never blocks tool execution).
+ */
+function handleTrack (input, root) {
+  if (!root) return
+
+  let hookInput
+  try {
+    hookInput = JSON.parse(input)
+  } catch {
+    return
+  }
+
+  const sessionId = hookInput.session_id
+  if (!sessionId) return
+
+  const toolName = hookInput.tool_name
+  if (!toolName) return
+
+  const toolInput = hookInput.tool_input || {}
+
+  const entry = { tool: toolName, t: Date.now() }
+
+  // Extract file path for file-modifying tools
+  const filePath = extractFilePath(toolInput)
+  if (filePath) {
+    entry.file = filePath
+  }
+
+  // For Bash, record the command
+  if (toolName === 'Bash' && typeof toolInput.command === 'string') {
+    entry.command = toolInput.command
+  }
+
+  // Skip Bash with no command (malformed input). All other non-Bash tools
+  // passed the PreToolUse matcher, so they're known modifying tools even if
+  // we can't extract a specific file path (e.g. MultiEdit nests paths in edits[]).
+  if (toolName === 'Bash' && typeof toolInput.command !== 'string') return
+
+  const file = trackingPath(root, sessionId)
+  ensureDir(path.dirname(file))
+  fs.appendFileSync(file, JSON.stringify(entry) + '\n')
+}
+
+/**
+ * Check whether a session has tracked any file-modifying tool calls.
+ * Bash entries alone don't count — Bash is too noisy (ls, git status, etc.)
+ * and we can't reliably distinguish read-only from write commands.
+ * The definitive signal comes from Write/Edit/NotebookEdit/MCP tools.
+ */
+function hasTrackedModifications (root, sessionId) {
+  const file = trackingPath(root, sessionId)
+  try {
+    const data = fs.readFileSync(file, 'utf8')
+    if (!data) return false
+    const lines = data.trim().split('\n')
+    return lines.some(line => {
+      try {
+        const entry = JSON.parse(line)
+        return entry.tool !== 'Bash'
+      } catch {
+        return false
+      }
+    })
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Delete tracking file after commit or cleanup.
+ */
+function cleanupTracking (root, sessionId) {
+  try {
+    fs.unlinkSync(trackingPath(root, sessionId))
+  } catch {}
+}
+
+module.exports = {
+  handleTrack,
+  hasTrackedModifications,
+  cleanupTracking,
+  extractFilePath,
+  trackingDir,
+  trackingPath
+}

package/lib/transcript.js

@@ -0,0 +1,133 @@
+const fs = require('fs')
+
+/**
+ * Parse a JSONL transcript file into prompt/response pairs.
+ * Returns array of { prompt, response } objects.
+ */
+function parseTranscript (filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return []
+
+  const lines = fs.readFileSync(filePath, 'utf8').split('\n')
+  const state = { pairs: [], prompt: null, response: '' }
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+    let entry
+    try {
+      entry = JSON.parse(line)
+    } catch {
+      continue
+    }
+
+    if (entry.type === 'user' && typeof entry.message?.content === 'string') {
+      if (state.prompt !== null) {
+        state.pairs.push({ prompt: state.prompt, response: state.response })
+      }
+      state.prompt = entry.message.content
+      state.response = ''
+    } else if (entry.type === 'assistant' && Array.isArray(entry.message?.content)) {
+      const hasToolUse = entry.message.content.some(b => b.type === 'tool_use')
+      if (hasToolUse) continue
+      const texts = entry.message.content
+        .filter(b => b.type === 'text')
+        .map(b => b.text)
+      state.response += texts.join('')
+    }
+  }
+
+  if (state.prompt !== null) {
+    state.pairs.push({ prompt: state.prompt, response: state.response })
+  }
+
+  return state.pairs
+}
+
+/**
+ * Format a single prompt/response pair.
+ */
+function formatPair (p) {
+  return `Prompt:\n${p.prompt}\n\nResponse:\n${p.response}`
+}
+
+/**
+ * Format prompt/response pairs into a commit body.
+ */
+function formatBody (pairs) {
+  if (pairs.length === 0) return '(no transcript)'
+  return pairs.map(formatPair).join('\n\n---\n\n')
+}
+
+/**
+ * Format a condensed transcript for title generation.
+ * Returns the full transcript when it fits within budget, otherwise
+ * samples the first, middle, and last pairs with gap markers.
+ * Individual prompts and responses are capped to keep the sample compact.
+ */
+function formatTitleTranscript (pairs, budget) {
+  budget = budget || 20000
+  if (pairs.length === 0) return '(no transcript)'
+
+  const full = formatBody(pairs)
+  if (full.length <= budget) return full
+
+  const sep = '\n\n---\n\n'
+  const cap = (text, max) => text.length > max ? text.slice(0, max) + '...' : text
+  const fmt = p => `Prompt:\n${cap(p.prompt, 500)}\n\nResponse:\n${cap(p.response, 2000)}`
+
+  // Pick first, middle, and last — deduplicated and in order
+  const indices = [...new Set([0, Math.floor(pairs.length / 2), pairs.length - 1])]
+
+  const parts = []
+  let prev = -1
+  for (const i of indices) {
+    const skipped = i - prev - 1
+    if (skipped > 0) parts.push(`[... ${skipped} turns omitted ...]`)
+    parts.push(fmt(pairs[i]))
+    prev = i
+  }
+
+  return parts.join(sep)
+}
+
+/**
+ * Extract a headline from the last user prompt.
+ * Falls back to a timestamped default.
+ */
+function extractHeadline (pairs) {
+  if (pairs.length === 0) return fallbackHeadline()
+  const lastPrompt = pairs[pairs.length - 1].prompt
+  if (!lastPrompt) return fallbackHeadline()
+  const firstLine = lastPrompt.split('\n')[0]
+  return firstLine.slice(0, 72) || fallbackHeadline()
+}
+
+function fallbackHeadline () {
+  const now = new Date()
+  const pad = n => String(n).padStart(2, '0')
+  return `auto-commit ${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}`
+}
+
+/**
+ * Extract the model ID from the first assistant entry in a JSONL transcript.
+ * Returns null if not found.
+ */
+function extractModel (filePath) {
+  if (!filePath || !fs.existsSync(filePath)) return null
+
+  const lines = fs.readFileSync(filePath, 'utf8').split('\n')
+  for (const line of lines) {
+    if (!line.trim()) continue
+    let entry
+    try {
+      entry = JSON.parse(line)
+    } catch {
+      continue
+    }
+    if (entry.type === 'assistant' && entry.message?.model) {
+      return entry.message.model
+    }
+  }
+  return null
+}
+
+module.exports = { parseTranscript, formatPair, formatBody, formatTitleTranscript, extractHeadline, fallbackHeadline, extractModel }

package/lib/wrap.js

@@ -0,0 +1,129 @@
+/**
+ * Wrap prose lines at a specified width while preserving structured
+ * Markdown content (code blocks, tables, headers, etc.) verbatim.
+ */
+
+function wrapLine (text, maxLen, indent) {
+  indent = indent || ''
+  const leadMatch = text.match(/^(\s+)/)
+  const lead = leadMatch ? leadMatch[1] : ''
+  const words = text.trimStart().split(' ')
+  if (words.length > 0) words[0] = lead + words[0]
+  const lines = []
+  let current = ''
+
+  for (const word of words) {
+    if (current === '') {
+      current = word
+    } else if (current.length + 1 + word.length <= maxLen) {
+      current += ' ' + word
+    } else {
+      lines.push(current)
+      current = indent + word
+    }
+  }
+  if (current) lines.push(current)
+  return lines.join('\n')
+}
+
+function wrapText (text, maxLineLength) {
+  if (!maxLineLength || typeof maxLineLength !== 'number' || maxLineLength < 1) return text
+  if (text === '') return text
+
+  const lines = text.split('\n')
+  const result = []
+  let inFence = false
+  let fencePattern = null
+
+  for (const line of lines) {
+    // Fenced code block toggle (backtick or tilde)
+    const fenceMatch = line.match(/^(`{3,}|~{3,})/)
+    if (fenceMatch) {
+      if (!inFence) {
+        inFence = true
+        fencePattern = fenceMatch[1]
+        result.push(line)
+        continue
+      } else if (line.startsWith(fencePattern) && line.trim() === fencePattern) {
+        inFence = false
+        fencePattern = null
+        result.push(line)
+        continue
+      }
+    }
+
+    // Inside fenced block — preserve verbatim
+    if (inFence) {
+      result.push(line)
+      continue
+    }
+
+    // Blank line
+    if (line === '') {
+      result.push(line)
+      continue
+    }
+
+    // Indented code (4+ spaces or tab)
+    if (/^( {4,}|\t)/.test(line)) {
+      result.push(line)
+      continue
+    }
+
+    // Header
+    if (/^#{1,6}\s/.test(line)) {
+      result.push(line)
+      continue
+    }
+
+    // Table row (starts with |)
+    if (/^\|/.test(line.trimStart())) {
+      result.push(line)
+      continue
+    }
+
+    // Horizontal rule
+    if (/^[-*_]{3,}\s*$/.test(line)) {
+      result.push(line)
+      continue
+    }
+
+    // Blockquote
+    const bqMatch = line.match(/^((?:>\s?)+)/)
+    if (bqMatch) {
+      const prefix = bqMatch[0]
+      const indent = bqMatch[1].replace(/\s?$/, ' ')
+      if (line.length <= maxLineLength) {
+        result.push(line)
+      } else {
+        const content = line.slice(prefix.length)
+        result.push(wrapLine(prefix + content, maxLineLength, indent))
+      }
+      continue
+    }
+
+    // List item
+    const listMatch = line.match(/^(\s*)([-*]|\d+\.)\s/)
+    if (listMatch) {
+      const prefix = listMatch[0]
+      const indent = ' '.repeat(prefix.length)
+      if (line.length <= maxLineLength) {
+        result.push(line)
+      } else {
+        result.push(wrapLine(line, maxLineLength, indent))
+      }
+      continue
+    }
+
+    // Prose — wrap at word boundaries
+    if (line.length <= maxLineLength) {
+      result.push(line)
+    } else {
+      result.push(wrapLine(line, maxLineLength, ''))
+    }
+  }
+
+  return result.join('\n')
+}
+
+module.exports = { wrapText }

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@searls/turbocommit",
+  "version": "0.10.0",
+  "description": "Auto-commit after every Claude Code turn",
+  "bin": {
+    "turbocommit": "./cli.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "cli.js",
+    "lib/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/searlsco/turbocommit.git"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "git",
+    "auto-commit"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "lint": "npx standard --fix"
+  },
+  "devDependencies": {
+    "standard": "^17.1.0"
+  },
+  "license": "MIT"
+}