@searls/turbocommit 0.13.2 → 0.14.1

package/README.md

@@ -32,6 +32,30 @@ turbocommit registers hooks with the harnesses you use:
   commits with `git add -A`. If not, it buffers the transcript for pickup
   by a later session that does commit.
 
+### Changes across multiple repositories
+
+A session that starts in an enabled repository can commit changes in other
+enabled local checkouts during the same turn. Turbocommit discovers each
+checkout from explicit file paths supplied to Claude Code tools, Codex
+`apply_patch`, and path-bearing MCP tools. Shell commands alone do not discover
+additional repositories.
+
+Each touched checkout:
+
+- Reads its own merged global and project configuration.
+- Keeps the normal `git add -A` behavior.
+- Gets an independent commit with the full turn transcript.
+- Gives the configured title agent repository-specific bounded diff context.
+
+Turbocommit attempts every commit before pushing every successful commit whose
+repository has `push: true`. Failures are retained and retried on a later Stop,
+along with every transcript accumulated before the commit succeeds.
+
+Separate worktrees are committed independently. Enabled submodules are
+committed and pushed before enabled parent repositories. When one turn creates
+commits in multiple repositories, each commit includes a shared
+`Turbocommit-Session` trailer.
+
 The commit message headline is generated by a title agent (configurable).
 The body contains the full prompt/response transcript. When planning
 context was buffered from ancestor sessions, it appears under a

package/lib/git.js

@@ -1,4 +1,5 @@
 const { execSync } = require('child_process')
+const fs = require('fs')
 const path = require('path')
 
 function git (args, opts = {}) {
@@ -18,6 +19,21 @@ function gitRoot (cwd) {
   }
 }
 
+function gitRootForPath (filePath) {
+  let probe = filePath
+  try {
+    if (!fs.statSync(probe).isDirectory()) probe = path.dirname(probe)
+  } catch {
+    probe = path.dirname(probe)
+  }
+  while (probe && !fs.existsSync(probe)) {
+    const parent = path.dirname(probe)
+    if (parent === probe) return null
+    probe = parent
+  }
+  return gitRoot(probe)
+}
+
 function gitCommonDir (cwd) {
   try {
     const out = git('rev-parse --git-common-dir', { cwd })
@@ -45,11 +61,41 @@ function hasChanges (cwd) {
 }
 
 function addAndCommit (cwd, headline, body) {
+  stageAll(cwd)
+  commitStaged(cwd, headline, body)
+  return git('rev-parse HEAD', { cwd })
+}
+
+function stageAll (cwd) {
   git('add -A', { cwd })
+}
+
+function commitStaged (cwd, headline, body) {
   git(`commit -m "${esc(headline)}" -m "${esc(body)}" --no-verify`, { cwd })
   return git('rev-parse HEAD', { cwd })
 }
 
+function stagedChangeContext (cwd, budget = 20000) {
+  const status = git('status --short', { cwd })
+  const stat = git('diff --cached --stat', { cwd })
+  const diff = git('diff --cached --no-ext-diff --unified=3', { cwd })
+  const prefix = `Status:\n${status || '(clean)'}\n\nDiff stat:\n${stat || '(none)'}\n\nDiff:\n`
+  const remaining = Math.max(0, budget - prefix.length)
+  return prefix + (diff.length > remaining ? diff.slice(0, remaining) + '\n[... diff truncated ...]' : diff)
+}
+
+function isGitlink (parentRoot, childRoot) {
+  const relative = path.relative(parentRoot, childRoot)
+  if (!relative || relative.startsWith('..')) return false
+  try {
+    return git(`ls-files --stage -- "${esc(relative)}"`, { cwd: parentRoot })
+      .split('\n')
+      .some(line => line.startsWith('160000 '))
+  } catch {
+    return false
+  }
+}
+
 function hasCommits (cwd) {
   try {
     git('rev-parse HEAD', { cwd })
@@ -83,10 +129,15 @@ function esc (s) {
 module.exports = {
   git,
   gitRoot,
+  gitRootForPath,
   gitCommonDir,
   hasChanges,
   addAndCommit,
+  stageAll,
+  commitStaged,
+  stagedChangeContext,
   hasCommits,
   currentBranch,
-  pushClean
+  pushClean,
+  isGitlink
 }

package/lib/install.js

@@ -23,7 +23,7 @@ const HOOK_DEFS = {
 
 const CODEX_HOOK_DEFS = {
   PreToolUse: {
-    matcher: 'Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
+    matcher: 'apply_patch|Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
     hooks: [{ type: 'command', command: 'turbocommit hook pre-tool-use --harness codex' }]
   },
   SessionStart: {

package/lib/multi.js

@@ -0,0 +1,121 @@
+const crypto = require('crypto')
+const fs = require('fs')
+const path = require('path')
+const { ensureDir, loadJson } = require('./io')
+const { turbocommitDir } = require('./session')
+const { gitRoot, gitRootForPath, isGitlink } = require('./git')
+const { activeConfig } = require('./config')
+
+function checkoutKey (root) {
+  return crypto.createHash('sha256').update(fs.realpathSync(root)).digest('hex').slice(0, 16)
+}
+
+function manifestPath (anchor) {
+  return path.join(turbocommitDir(anchor), 'multi', checkoutKey(anchor), 'manifest.json')
+}
+
+function loadManifest (anchor) {
+  return loadJson(manifestPath(anchor)) || { nextOrder: 0, repos: [] }
+}
+
+function saveManifest (anchor, manifest) {
+  const file = manifestPath(anchor)
+  ensureDir(path.dirname(file))
+  fs.writeFileSync(file, JSON.stringify(manifest, null, 2) + '\n')
+}
+
+function deleteManifestIfEmpty (anchor, manifest) {
+  if (manifest.repos.length > 0) {
+    saveManifest(anchor, manifest)
+    return
+  }
+  try {
+    fs.unlinkSync(manifestPath(anchor))
+  } catch {}
+}
+
+function rootsFromEntries (anchor, entries) {
+  const roots = []
+  const seen = new Set()
+  const add = root => {
+    if (!root) return
+    let real
+    try {
+      real = fs.realpathSync(root)
+    } catch {
+      return
+    }
+    if (seen.has(real)) return
+    if (activeConfig(real).config.enabled !== true) return
+    seen.add(real)
+    roots.push(real)
+  }
+
+  for (const entry of entries) {
+    if (entry.tool === 'Bash') continue
+    if (Array.isArray(entry.files) && entry.files.length > 0) {
+      for (const file of entry.files) add(gitRootForPath(file) || anchor)
+    } else {
+      add(anchor)
+    }
+  }
+  return addEnabledSuperprojects(roots, add)
+}
+
+function addEnabledSuperprojects (roots, add) {
+  for (let i = 0; i < roots.length; i++) {
+    const child = roots[i]
+    const parent = gitRoot(path.dirname(child))
+    if (parent && parent !== child && isGitlink(parent, child)) add(parent)
+  }
+  return roots
+}
+
+function dependencyOrder (repos) {
+  return [...repos].sort((a, b) => {
+    if (isGitlink(a.root, b.root)) return 1
+    if (isGitlink(b.root, a.root)) return -1
+    return a.order - b.order
+  })
+}
+
+function appendWork (manifest, root, work) {
+  let repo = manifest.repos.find(candidate => candidate.root === root)
+  if (!repo) {
+    repo = { root, order: manifest.nextOrder++, work: [] }
+    manifest.repos.push(repo)
+  }
+  if (!repo.work.some(item => item.key === work.key)) repo.work.push(work)
+  return repo
+}
+
+function multiWatermarkPath (root, sessionId) {
+  return path.join(turbocommitDir(root), 'multi-watermarks', checkoutKey(root), sessionId + '.json')
+}
+
+function readMultiWatermark (root, sessionIds) {
+  for (const sessionId of sessionIds) {
+    const value = loadJson(multiWatermarkPath(root, sessionId))
+    if (value?.commit) return value
+  }
+  return null
+}
+
+function saveMultiWatermark (root, sessionId, commit) {
+  const file = multiWatermarkPath(root, sessionId)
+  ensureDir(path.dirname(file))
+  fs.writeFileSync(file, JSON.stringify({ commit }) + '\n')
+}
+
+module.exports = {
+  appendWork,
+  checkoutKey,
+  deleteManifestIfEmpty,
+  dependencyOrder,
+  loadManifest,
+  manifestPath,
+  readMultiWatermark,
+  rootsFromEntries,
+  saveManifest,
+  saveMultiWatermark
+}

package/lib/run.js

@@ -4,15 +4,25 @@ const path = require('path')
 const { loadJson } = require('./io')
 const { parseTranscript, parseCodexTranscript, formatBody, formatTitleTranscript, extractHeadline, extractModel, extractCodexModel } = require('./transcript')
 const { runTitleAgent, runBodyAgent } = require('./agent')
-const { gitRoot, hasChanges, addAndCommit, hasCommits, currentBranch, pushClean } = require('./git')
+const { gitRoot, hasChanges, addAndCommit, stageAll, commitStaged, stagedChangeContext, hasCommits, currentBranch, pushClean } = require('./git')
 const { logEvent } = require('./log')
 const { wrapText } = require('./wrap')
-const { hasTrackedModifications, cleanupTracking } = require('./track')
+const { hasTrackedModifications, cleanupTracking, readTracking } = require('./track')
 const { redact, buildRedactions } = require('./redact')
 const { handleSessionEnd, getAncestors, savePending, collectPending, cleanupConsumed, cleanupStale, readWatermark, saveWatermark, resolveParentCommit } = require('./session')
 const { activeConfig } = require('./config')
 const { normalizeHookInput } = require('./harness')
 const { resolveCodexTranscriptPath } = require('./codex')
+const {
+  appendWork,
+  deleteManifestIfEmpty,
+  dependencyOrder,
+  loadManifest,
+  readMultiWatermark,
+  rootsFromEntries,
+  saveManifest,
+  saveMultiWatermark
+} = require('./multi')
 
 /**
  * Map a model ID like "claude-opus-4-6" to a friendly name like "Claude Opus 4.6".
@@ -92,6 +102,29 @@ function resolveCoauthor (config, transcriptPath, root, opts = {}) {
  */
 function run (input, opts = {}) {
   if (process.env.TURBOCOMMIT_DISABLED) return
+  const hookInput = typeof input === 'string'
+    ? normalizeHookInput(input, 'stop', opts.harness)
+    : input
+  if (!hookInput) return
+
+  const root = gitRoot(hookInput.cwd || process.cwd())
+  if (!root || activeConfig(root).config.enabled !== true) return
+
+  const entries = hookInput.sessionId ? readTracking(root, hookInput.sessionId) : []
+  const roots = rootsFromEntries(root, entries)
+  const manifest = loadManifest(root)
+  const hasCrossRootPath = entries.some(entry =>
+    Array.isArray(entry.files) && entry.files.length > 0
+  ) && (roots.length !== 1 || roots[0] !== root)
+
+  if (manifest.repos.length > 0 || roots.length > 1 || hasCrossRootPath) {
+    return runMulti(hookInput, root, roots, manifest)
+  }
+  return runSingle(hookInput)
+}
+
+function runSingle (input, opts = {}) {
+  if (process.env.TURBOCOMMIT_DISABLED) return
 
   const hookInput = typeof input === 'string'
     ? normalizeHookInput(input, 'stop', opts.harness)
@@ -240,6 +273,191 @@ function run (input, opts = {}) {
   }
 }
 
+function runMulti (hookInput, anchor, currentRoots, manifest) {
+  recordCodexStop(hookInput, anchor)
+
+  const transcriptPath = resolveTranscriptPath(hookInput)
+  const pairs = hookInput.harness === 'codex'
+    ? parseCodexTranscript(transcriptPath)
+    : parseTranscript(transcriptPath)
+  const sessionId = hookInput.sessionId
+  const watermark = sessionId ? readWatermark(anchor, sessionId) : null
+  const watermarkPairCount = watermark && Number.isInteger(watermark.pairs) ? watermark.pairs : 0
+  const newPairs = watermark ? pairs.slice(watermarkPairCount) : pairs
+  const precompactWatermark = watermark && watermark.source === 'precompact'
+  const selfPrecompactPending = sessionId
+    ? collectPending(anchor, [sessionId], { source: 'precompact' })
+    : []
+  let effectivePairs = newPairs.length > 0 ? newPairs : pairs
+  if (precompactWatermark && newPairs.length === 0 && selfPrecompactPending.length > 0) {
+    const basePairs = Number.isInteger(watermark.basePairs) ? watermark.basePairs : 0
+    const bufferedPairs = pairs.slice(basePairs, watermarkPairCount)
+    effectivePairs = bufferedPairs.length > 0 ? bufferedPairs : pairs
+  }
+  const formattedTranscript = formatBody(effectivePairs)
+  const ancestors = sessionId ? getAncestors(anchor, sessionId) : []
+  const pending = sessionId ? collectPending(anchor, [...ancestors].reverse()) : []
+  if (precompactWatermark && newPairs.length > 0 && selfPrecompactPending.length > 0) {
+    pending.push(...selfPrecompactPending)
+  }
+  const turnBody = pending.length > 0
+    ? '## Planning\n\n' + pending.join('\n\n---\n\n') +
+      '\n\n## Implementation\n\n' + formattedTranscript
+    : formattedTranscript
+
+  const dirtyRoots = currentRoots.filter(root => !hasCommits(root) || hasChanges(root))
+  const isMultiTurn = currentRoots.length > 1
+  const turnKey = hookInput.raw?.turn_id ||
+    cryptoKey(`${sessionId || 'no-session'}\n${pairs.length}\n${turnBody}`)
+
+  if (dirtyRoots.length === 0 && manifest.repos.length === 0) {
+    if (sessionId) {
+      savePending(anchor, sessionId, formattedTranscript)
+      cleanupTracking(anchor, sessionId)
+    }
+    logEvent('skip', {
+      harness: hookInput.harness,
+      project: path.basename(anchor),
+      branch: currentBranch(anchor),
+      context: transcriptSize(transcriptPath)
+    })
+    return
+  }
+
+  for (const root of currentRoots) {
+    appendWork(manifest, root, {
+      key: turnKey,
+      body: turnBody,
+      sessionIds: isMultiTurn && sessionId ? [sessionId] : []
+    })
+  }
+
+  saveManifest(anchor, manifest)
+  const successes = []
+  const ordered = dependencyOrder(manifest.repos)
+
+  for (const repo of ordered) {
+    const root = repo.root
+    const { config } = activeConfig(root)
+    const project = path.basename(root)
+    const branch = currentBranch(root)
+    const context = transcriptSize(transcriptPath)
+
+    if (config.enabled !== true) {
+      manifest.repos = manifest.repos.filter(candidate => candidate !== repo)
+      logEvent('skip', { harness: hookInput.harness, project, branch, context })
+      continue
+    }
+    if (hasCommits(root) && !hasChanges(root)) {
+      manifest.repos = manifest.repos.filter(candidate => candidate !== repo)
+      logEvent('skip', { harness: hookInput.harness, project, branch, context })
+      continue
+    }
+
+    try {
+      logEvent('start', { harness: hookInput.harness, project, branch, context })
+      stageAll(root)
+
+      const rawBody = repo.work.map(item => item.body).join('\n\n---\n\n')
+      const redactions = buildRedactions()
+      const changeContext = redact(stagedChangeContext(root, 10000), redactions)
+      const titleInput = `${changeContext}\n\nTranscript:\n${rawBody}`.slice(0, 20000)
+
+      let headline
+      if (config.title?.type !== 'transcript') {
+        headline = runTitleAgent(root, config.title || {}, titleInput, hookInput.harness)
+      }
+      headline = headline || extractHeadline(effectivePairs)
+
+      let body
+      if (config.body?.type === 'agent') {
+        body = runBodyAgent(root, config.body, rawBody, hookInput.harness)
+      }
+      body = body || rawBody
+
+      const parent = sessionId
+        ? readMultiWatermark(root, [sessionId, ...ancestors])
+        : null
+      if (parent?.commit) body = `Continuation of ${parent.commit.slice(0, 7)}\n\n${body}`
+      body = wrapText(body, config.body?.maxLineLength)
+
+      const trailers = []
+      for (const work of repo.work) {
+        for (const id of work.sessionIds || []) {
+          if (!trailers.includes(id)) trailers.push(id)
+        }
+      }
+      if (trailers.length > 0) {
+        body += '\n\n' + trailers.map(id => `Turbocommit-Session: ${id}`).join('\n')
+      }
+
+      const coauthor = resolveCoauthor(config, transcriptPath, root, {
+        harness: hookInput.harness,
+        model: hookInput.model
+      })
+      if (coauthor) body += '\n\n' + coauthor
+
+      const safeHeadline = redact(headline, redactions)
+      const safeBody = redact(body, redactions)
+      const sha = commitStaged(root, safeHeadline, safeBody)
+      if (sessionId) saveMultiWatermark(root, sessionId, sha)
+      if (root === anchor && sessionId) {
+        saveWatermark(anchor, sessionId, pairs.length, sha, { source: 'commit' })
+      }
+      manifest.repos = manifest.repos.filter(candidate => candidate !== repo)
+      successes.push({ root, config, project, branch })
+      logEvent('success', {
+        harness: hookInput.harness,
+        project,
+        branch,
+        context,
+        title: safeHeadline
+      })
+    } catch {
+      logEvent('fail', { harness: hookInput.harness, project, branch, context })
+    }
+  }
+
+  for (const success of successes) {
+    if (success.config.push !== true) continue
+    if (pushClean(success.root)) {
+      logEvent('push', {
+        harness: hookInput.harness,
+        project: success.project,
+        branch: success.branch
+      })
+    } else {
+      logEvent('push-fail', {
+        harness: hookInput.harness,
+        project: success.project,
+        branch: success.branch
+      })
+    }
+  }
+
+  if (sessionId) {
+    if (!readWatermark(anchor, sessionId)) {
+      saveWatermark(anchor, sessionId, pairs.length, undefined, { source: 'multi' })
+    }
+    cleanupConsumed(anchor, [...ancestors, sessionId])
+    cleanupTracking(anchor, sessionId)
+  }
+  deleteManifestIfEmpty(anchor, manifest)
+  cleanupStale(anchor)
+}
+
+function transcriptSize (transcriptPath) {
+  try {
+    return fs.statSync(transcriptPath).size
+  } catch {
+    return 0
+  }
+}
+
+function cryptoKey (value) {
+  return require('crypto').createHash('sha256').update(value).digest('hex').slice(0, 20)
+}
+
 function runPreCompact (input, opts = {}) {
   if (process.env.TURBOCOMMIT_DISABLED) return
   const hookInput = typeof input === 'string'

package/lib/track.js

@@ -36,6 +36,41 @@ function extractFilePath (toolInput) {
   return null
 }
 
+function extractFilePaths (toolName, toolInput, cwd) {
+  const paths = []
+  const seen = new Set()
+  const add = value => {
+    if (typeof value !== 'string' || value.length === 0) return
+    const resolved = path.isAbsolute(value) ? value : path.resolve(cwd || process.cwd(), value)
+    if (seen.has(resolved)) return
+    seen.add(resolved)
+    paths.push(resolved)
+  }
+
+  if (toolName === 'apply_patch' && typeof toolInput?.command === 'string') {
+    for (const line of toolInput.command.split('\n')) {
+      const match = line.match(/^\*\*\* (?:Add|Update|Delete) File: (.+)$/) ||
+        line.match(/^\*\*\* Move to: (.+)$/)
+      if (match) add(match[1])
+    }
+    return paths
+  }
+
+  const visit = value => {
+    if (!value || typeof value !== 'object') return
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item)
+      return
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (FILE_PATH_KEYS.includes(key)) add(nested)
+      if (nested && typeof nested === 'object') visit(nested)
+    }
+  }
+  visit(toolInput)
+  return paths
+}
+
 /**
  * PreToolUse handler. Appends a tracking entry for potentially-modifying tools.
  * Always exits 0 (never blocks tool execution).
@@ -55,11 +90,9 @@ function handleTrack (input, root) {
 
   const entry = { tool: toolName, t: Date.now() }
 
-  // Extract file path for file-modifying tools
-  const filePath = extractFilePath(toolInput)
-  if (filePath) {
-    entry.file = filePath
-  }
+  const cwd = hookInput.cwd || hookInput.raw?.cwd || root
+  const files = extractFilePaths(toolName, toolInput, cwd)
+  if (files.length > 0) entry.files = files
 
   // For Bash, record the command
   if (toolName === 'Bash' && typeof toolInput.command === 'string') {
@@ -92,21 +125,23 @@ function parseInput (input) {
  * The definitive signal comes from Write/Edit/NotebookEdit/MCP tools.
  */
 function hasTrackedModifications (root, sessionId) {
+  return readTracking(root, sessionId).some(entry => entry.tool !== 'Bash')
+}
+
+function readTracking (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 => {
+    if (!data) return []
+    return data.trim().split('\n').map(line => {
       try {
-        const entry = JSON.parse(line)
-        return entry.tool !== 'Bash'
+        return JSON.parse(line)
       } catch {
-        return false
+        return null
       }
-    })
+    }).filter(Boolean)
   } catch {
-    return false
+    return []
   }
 }
 
@@ -124,6 +159,8 @@ module.exports = {
   hasTrackedModifications,
   cleanupTracking,
   extractFilePath,
+  extractFilePaths,
+  readTracking,
   trackingDir,
   trackingPath
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@searls/turbocommit",
-  "version": "0.13.2",
+  "version": "0.14.1",
   "description": "Auto-commit after every AI coding agent turn",
   "bin": {
     "turbocommit": "./cli.js"