@searls/turbocommit 0.10.0

package/lib/install.js

@@ -0,0 +1,115 @@
+const os = require('os')
+const path = require('path')
+const { loadJson, writeJson } = require('./io')
+
+/**
+ * Hook definitions for each Claude Code event turbocommit uses.
+ */
+const HOOK_DEFS = {
+  PreToolUse: {
+    matcher: 'Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
+    hooks: [{ type: 'command', command: 'turbocommit hook pre-tool-use' }]
+  },
+  SessionStart: {
+    hooks: [{ type: 'command', command: 'turbocommit hook session-start' }]
+  },
+  SessionEnd: {
+    hooks: [{ type: 'command', command: 'turbocommit hook session-end' }]
+  },
+  Stop: {
+    hooks: [{ type: 'command', command: 'turbocommit hook stop' }]
+  }
+}
+
+function getSettingsPath () {
+  return path.join(os.homedir(), '.claude', 'settings.json')
+}
+
+function hasTurbocommit (groups) {
+  if (!Array.isArray(groups)) return false
+  return groups.some(g => {
+    const hooks = g && g.hooks ? g.hooks : []
+    return hooks.some(h => h.command && h.command.includes('turbocommit'))
+  })
+}
+
+/**
+ * Check if turbocommit hooks are installed across all expected events.
+ */
+function isFullyInstalled (settings) {
+  if (!settings || !settings.hooks) return false
+  return Object.keys(HOOK_DEFS).every(event =>
+    hasTurbocommit(settings.hooks[event])
+  )
+}
+
+function removeTurbocommitHooks (groups) {
+  if (!Array.isArray(groups)) return groups
+  return groups.map(g => {
+    if (!g || !Array.isArray(g.hooks)) return g
+    const filtered = g.hooks.filter(h => !h.command || !h.command.includes('turbocommit'))
+    return { ...g, hooks: filtered }
+  }).filter(g => g.hooks && g.hooks.length > 0)
+}
+
+/**
+ * Install turbocommit hooks for all 4 events (PreToolUse, SessionStart,
+ * SessionEnd, Stop). Each event gets its own group at the end.
+ * Cleans up stale entries (including old `turbocommit run`) on install.
+ */
+function install (settingsPath) {
+  settingsPath = settingsPath || getSettingsPath()
+  const settings = loadJson(settingsPath) || {}
+
+  if (!settings.hooks) settings.hooks = {}
+
+  // Check if already fully installed
+  if (isFullyInstalled(settings)) {
+    return { alreadyInstalled: true, settingsPath }
+  }
+
+  // Clean all stale turbocommit entries first (including old `turbocommit run`)
+  for (const k of Object.keys(settings.hooks)) {
+    settings.hooks[k] = removeTurbocommitHooks(settings.hooks[k])
+    if (Array.isArray(settings.hooks[k]) && settings.hooks[k].length === 0) {
+      delete settings.hooks[k]
+    }
+  }
+
+  // Install each hook event in its own group at the end
+  for (const [event, def] of Object.entries(HOOK_DEFS)) {
+    if (!settings.hooks[event]) settings.hooks[event] = []
+    const group = { hooks: def.hooks }
+    if (def.matcher) group.matcher = def.matcher
+    settings.hooks[event].push(group)
+  }
+
+  writeJson(settingsPath, settings)
+  return { alreadyInstalled: false, settingsPath }
+}
+
+function uninstall (settingsPath) {
+  settingsPath = settingsPath || getSettingsPath()
+  const settings = loadJson(settingsPath)
+
+  if (!settings || !settings.hooks) {
+    return { wasInstalled: false, settingsPath }
+  }
+
+  // Check if any turbocommit hook exists in any event
+  const wasInstalled = Object.keys(settings.hooks).some(event =>
+    hasTurbocommit(settings.hooks[event])
+  )
+
+  for (const k of Object.keys(settings.hooks)) {
+    settings.hooks[k] = removeTurbocommitHooks(settings.hooks[k])
+    if (Array.isArray(settings.hooks[k]) && settings.hooks[k].length === 0) {
+      delete settings.hooks[k]
+    }
+  }
+
+  writeJson(settingsPath, settings)
+  return { wasInstalled, settingsPath }
+}
+
+module.exports = { install, uninstall, hasTurbocommit, isFullyInstalled, getSettingsPath, HOOK_DEFS }

package/lib/io.js

@@ -0,0 +1,58 @@
+const fs = require('fs')
+const path = require('path')
+const { spawnSync } = require('child_process')
+
+function readStdin () {
+  return fs.readFileSync(0, 'utf8')
+}
+
+function loadJson (p) {
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function writeJson (p, obj) {
+  ensureDir(path.dirname(p))
+  fs.writeFileSync(p, JSON.stringify(obj, null, 2) + '\n', 'utf8')
+}
+
+function ensureDir (p) {
+  fs.mkdirSync(p, { recursive: true })
+}
+
+function tryRun (cmd, opts) {
+  const { input, ...rest } = opts || {}
+  let r
+  try {
+    r = spawnSync(cmd, {
+      ...rest,
+      ...(input != null ? { input } : {}),
+      shell: true,
+      encoding: 'utf8',
+      maxBuffer: 50 * 1024 * 1024
+    })
+  } catch {
+    return { code: 1, signal: null, stdout: '', stderr: '' }
+  }
+  return { code: r.status ?? (r.signal || r.error ? 1 : 0), signal: r.signal || null, stdout: r.stdout ?? '', stderr: r.stderr ?? '' }
+}
+
+function mergeConfig (global, project) {
+  const result = { ...global }
+  for (const key of Object.keys(project)) {
+    if (
+      typeof result[key] === 'object' && result[key] !== null && !Array.isArray(result[key]) &&
+      typeof project[key] === 'object' && project[key] !== null && !Array.isArray(project[key])
+    ) {
+      result[key] = { ...result[key], ...project[key] }
+    } else {
+      result[key] = project[key]
+    }
+  }
+  return result
+}
+
+module.exports = { readStdin, loadJson, writeJson, ensureDir, tryRun, mergeConfig }

package/lib/log.js

@@ -0,0 +1,18 @@
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+
+function logPath () {
+  return path.join(os.homedir(), '.claude', 'turbocommit', 'monitor.jsonl')
+}
+
+function logEvent (event, meta = {}) {
+  try {
+    const entry = { event, ...meta, title: meta.title || null, at: Date.now() }
+    const p = logPath()
+    fs.mkdirSync(path.dirname(p), { recursive: true })
+    fs.appendFileSync(p, JSON.stringify(entry) + '\n')
+  } catch {}
+}
+
+module.exports = { logEvent, logPath }

package/lib/monitor.js

@@ -0,0 +1,92 @@
+const fs = require('fs')
+const { logPath } = require('./log')
+
+const COLORS = {
+  start: '\x1b[36m',
+  success: '\x1b[32m',
+  fail: '\x1b[31m',
+  skip: '\x1b[33m',
+  reset: '\x1b[0m',
+  dim: '\x1b[2m'
+}
+
+function formatSize (bytes) {
+  if (bytes < 1024) return bytes + 'B'
+  return Math.round(bytes / 1024) + 'KB'
+}
+
+function formatTime (ts) {
+  const d = new Date(ts)
+  return d.toLocaleTimeString('en-GB', { hour12: false })
+}
+
+function formatEntry (entry, cols) {
+  const time = formatTime(entry.at)
+  const event = entry.event.padEnd(7)
+  const project = (entry.project || '').padEnd(12)
+  const branch = (entry.branch || '').padEnd(10)
+  const size = formatSize(entry.context || 0).padEnd(6)
+  const color = COLORS[entry.event] || ''
+
+  // Fixed columns: time(8) + 2 + event(7) + 2 + project(12) + 2 + branch(10) + 2 + size(6) = 51
+  const fixedWidth = 51
+  const maxTitle = Math.max(0, (cols || 80) - fixedWidth)
+  let title = entry.title || ''
+  if (title.length > maxTitle) title = title.slice(0, maxTitle - 1) + '\u2026'
+
+  return `${COLORS.dim}${time}${COLORS.reset}  ${color}${event}${COLORS.reset}  ${project}  ${branch}  ${size}${title}`
+}
+
+function readEntries (filePath) {
+  try {
+    const data = fs.readFileSync(filePath, 'utf8')
+    return data.split('\n').filter(Boolean).map(line => {
+      try { return JSON.parse(line) } catch { return null }
+    }).filter(Boolean)
+  } catch {
+    return []
+  }
+}
+
+function monitor () {
+  const cols = process.stdout.columns || 80
+  const lp = logPath()
+  const entries = readEntries(lp)
+  for (const entry of entries) {
+    process.stdout.write(formatEntry(entry, cols) + '\n')
+  }
+
+  let offset = 0
+  try { offset = fs.statSync(lp).size } catch {}
+
+  fs.watchFile(lp, { interval: 500 }, () => {
+    let data
+    try {
+      const stat = fs.statSync(lp)
+      if (stat.size < offset) offset = 0 // File was truncated/recreated
+      if (stat.size === offset) return
+      const fd = fs.openSync(lp, 'r')
+      const buf = Buffer.alloc(stat.size - offset)
+      fs.readSync(fd, buf, 0, buf.length, offset)
+      fs.closeSync(fd)
+      offset = stat.size
+      data = buf.toString('utf8')
+    } catch {
+      return
+    }
+    const lines = data.split('\n').filter(Boolean)
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line)
+        process.stdout.write(formatEntry(entry, process.stdout.columns || cols) + '\n')
+      } catch {}
+    }
+  })
+
+  process.on('SIGINT', () => {
+    fs.unwatchFile(lp)
+    process.exit(0)
+  })
+}
+
+module.exports = { monitor, formatEntry, readEntries, formatSize, formatTime }

package/lib/run.js

@@ -0,0 +1,208 @@
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { loadJson, mergeConfig } = require('./io')
+const { parseTranscript, formatBody, formatTitleTranscript, extractHeadline, extractModel } = require('./transcript')
+const { runTitleAgent, runBodyAgent } = require('./agent')
+const { gitRoot, hasChanges, addAndCommit, hasCommits, currentBranch } = require('./git')
+const { logEvent } = require('./log')
+const { wrapText } = require('./wrap')
+const { hasTrackedModifications, cleanupTracking } = require('./track')
+const { getAncestors, savePending, collectPending, cleanupConsumed, cleanupStale, readWatermark, saveWatermark, resolveParentCommit } = require('./session')
+
+/**
+ * Map a model ID like "claude-opus-4-6" to a friendly name like "Claude Opus 4.6".
+ * Handles both new (claude-opus-4-6) and old (claude-3-5-sonnet-20241022) formats
+ * by separating parts into alphabetic (tier) and numeric (version) groups.
+ */
+function formatModelName (modelId) {
+  if (!modelId) return null
+  const stripped = modelId.replace(/^claude-/, '')
+  if (stripped === modelId) return modelId // not a claude model, use as-is
+  const withoutDate = stripped.replace(/-\d{8}$/, '')
+  const parts = withoutDate.split('-')
+  const alpha = parts.filter(p => /^[a-z]+$/i.test(p))
+  const numeric = parts.filter(p => /^\d+$/.test(p))
+  if (alpha.length === 0 || numeric.length === 0) return modelId
+  const tier = alpha.map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')
+  const version = numeric.join('.')
+  return `Claude ${tier} ${version}`
+}
+
+/**
+ * Read Claude Code's attribution.commit setting.
+ * Returns the string value (including empty string for explicit opt-out),
+ * or undefined when the setting is absent / not running under Claude Code.
+ */
+function readClaudeAttribution (root) {
+  if (!process.env.CLAUDECODE) return undefined
+  const globalSettings = loadJson(path.join(os.homedir(), '.claude', 'settings.json'))
+  const projectSettings = root ? loadJson(path.join(root, '.claude', 'settings.json')) : null
+  const projectVal = projectSettings?.attribution?.commit
+  const globalVal = globalSettings?.attribution?.commit
+  if (projectVal !== undefined) return projectVal
+  if (globalVal !== undefined) return globalVal
+  return undefined
+}
+
+/**
+ * Resolve the Co-Authored-By trailer value.
+ * Returns the full trailer line or null.
+ *
+ * Tier 1: turbocommit config (coauthor: false → null, string → use it)
+ * Tier 2: Claude Code attribution.commit setting (when running under Claude)
+ * Tier 3: auto-detect model from transcript
+ */
+function resolveCoauthor (config, transcriptPath, root) {
+  // Tier 1: explicit turbocommit config
+  if (config.coauthor === false) return null
+
+  if (typeof config.coauthor === 'string') {
+    return `Co-Authored-By: ${config.coauthor}`
+  }
+
+  // Tier 2: Claude Code attribution setting
+  const claudeAttr = readClaudeAttribution(root)
+  if (claudeAttr !== undefined) {
+    return claudeAttr === '' ? null : claudeAttr
+  }
+
+  // Tier 3: auto-detect from transcript
+  const model = extractModel(transcriptPath)
+  if (!model) return null
+  const name = formatModelName(model)
+  return `Co-Authored-By: ${name} <noreply@anthropic.com>`
+}
+
+/**
+ * Core auto-commit logic. Called by `turbocommit hook stop`.
+ * Reads hook input, checks bail conditions, and commits.
+ * Always exits 0 — never blocks Claude, never outputs to stdout.
+ *
+ * Skip/commit decision is based on PreToolUse tracking:
+ * - If tracking file exists with entries → this agent modified files → commit
+ * - If tracking file missing/empty → skip, buffer transcript for later pickup
+ */
+function run (input) {
+  if (process.env.TURBOCOMMIT_DISABLED) return
+
+  let hookInput
+  try {
+    hookInput = JSON.parse(input)
+  } catch {
+    return
+  }
+
+  // Find git root
+  const root = gitRoot()
+  if (!root) return
+
+  // Merge global + project config (project wins)
+  const globalCfg = loadJson(path.join(os.homedir(), '.claude', 'turbocommit.json'))
+  const projectCfg = loadJson(`${root}/.claude/turbocommit.json`)
+  const config = mergeConfig(globalCfg || {}, projectCfg || {})
+  if (config.enabled !== true) return
+
+  // Parse transcript
+  const pairs = parseTranscript(hookInput.transcript_path)
+
+  // Gather monitor metadata
+  const project = path.basename(root)
+  const branch = currentBranch(root)
+  let context = 0
+  try { context = fs.statSync(hookInput.transcript_path).size } catch {}
+
+  const sessionId = hookInput.session_id
+
+  // Watermark slicing: only include new pairs since last commit in this session
+  const watermark = sessionId ? readWatermark(root, sessionId) : null
+  const newPairs = watermark ? pairs.slice(watermark.pairs) : pairs
+  const effectivePairs = newPairs.length > 0 ? newPairs : pairs
+
+  // Skip decision: if PreToolUse never fired for this session, skip commit
+  if (sessionId && !hasTrackedModifications(root, sessionId)) {
+    savePending(root, sessionId, formatBody(effectivePairs))
+    logEvent('skip', { project, branch, context })
+    cleanupStale(root)
+    return
+  }
+
+  try {
+    // Early exit: tracking fired but all changes were reverted
+    if (hasCommits(root) && !hasChanges(root)) {
+      if (sessionId) {
+        savePending(root, sessionId, formatBody(effectivePairs))
+        cleanupTracking(root, sessionId)
+      }
+      logEvent('skip', { project, branch, context })
+      cleanupStale(root)
+      return
+    }
+
+    logEvent('start', { project, branch, context })
+
+    const formattedTranscript = formatBody(effectivePairs)
+
+    // Title: agent by default, transcript if opted out
+    let headline
+    if (config.title?.type !== 'transcript') {
+      const titleTranscript = formatTitleTranscript(effectivePairs)
+      headline = runTitleAgent(root, config.title || {}, titleTranscript)
+    }
+    headline = headline || extractHeadline(effectivePairs)
+
+    // Body: transcript by default, agent if opted in
+    let body
+    if (config.body?.type === 'agent') {
+      body = runBodyAgent(root, config.body, formattedTranscript)
+    }
+    body = body || formattedTranscript
+
+    // Continuation reference + pending transcripts from ancestor sessions
+    let combinedBody = body
+    if (sessionId) {
+      const parentCommit = resolveParentCommit(root, sessionId)
+      const continuation = parentCommit
+        ? `Continuation of ${parentCommit.slice(0, 7)}\n\n`
+        : ''
+
+      const ancestors = getAncestors(root, sessionId)
+      // Collect pending from ancestors only — self-pending is already
+      // covered by effectivePairs (same watermark baseline) so including
+      // it would duplicate content between Planning and Implementation.
+      const pending = collectPending(root, [...ancestors].reverse())
+
+      if (pending.length > 0) {
+        combinedBody = continuation + '## Planning\n\n' + pending.join('\n\n---\n\n') +
+          '\n\n## Implementation\n\n' + body
+      } else {
+        combinedBody = continuation + body
+      }
+    }
+
+    // Wrap body lines if configured
+    const wrappedBody = wrapText(combinedBody, config.body?.maxLineLength)
+
+    // Resolve coauthor trailer
+    const coauthor = resolveCoauthor(config, hookInput.transcript_path, root)
+    const tag = coauthor ? '\n\n' + coauthor : ''
+
+    const sha = addAndCommit(root, headline, wrappedBody + tag)
+
+    logEvent('success', { project, branch, context, title: headline })
+
+    // Post-commit: save watermark and cleanup
+    if (sessionId) {
+      saveWatermark(root, sessionId, pairs.length, sha)
+      const ancestors = getAncestors(root, sessionId)
+      cleanupConsumed(root, [...ancestors, sessionId])
+      cleanupTracking(root, sessionId)
+    }
+    cleanupStale(root)
+  } catch (err) {
+    logEvent('fail', { project, branch, context })
+    throw err
+  }
+}
+
+module.exports = { run, formatModelName, resolveCoauthor, readClaudeAttribution }