@searls/turbocommit 0.16.0 → 0.16.2

package/README.md

@@ -29,10 +29,13 @@ turbocommit registers hooks with the harnesses you use:
 - **PostToolUse** attributes paths that became dirty during a shell command or
   MCP tool call, so files a tool rewrites without naming them (an Xcode project
   file, for example) belong to the session that changed them. A shell command
-  that names a path inside another enabled checkout (absolute, `~`-relative, or
-  relative to a directory the command mentions) is snapshotted in that checkout
-  too, so a pin bump made with `sed` in a sibling repository is attributed and
-  committed there.
+  that names a path inside another enabled checkout (absolute, `~`-relative,
+  or relative to the working directory or to a directory the command mentions)
+  is snapshotted in that checkout too, so a pin bump made with `sed` in a
+  sibling repository is attributed and committed there. Only changes under the
+  named paths are attributed, bare words never count as paths, and a checkout
+  with a merge, rebase, or similar operation in progress is left untouched. A
+  tool the pre hook denies leaves no claim behind.
   Concurrent commands in one session share ownership. Commands from different
   sessions retain hashed overlap evidence instead of claiming each other's
   paths. Once every involved turn stops and no shell remains active in that
@@ -77,8 +80,14 @@ Each touched checkout:
 - 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.
+repository has `push: true`. Staging and committing are retried a few times
+when Git is momentarily unavailable, for example while Xcode holds the index
+lock. Failures are retained and retried on a later Stop in that checkout by
+any session, along with every transcript accumulated before the commit
+succeeds, and the failed session's claims are released so they do not block
+other sessions meanwhile. Each `fail` monitor event records Git's error. A
+deletion the session already staged with `git rm` is committed with the rest
+of its paths.
 
 Separate worktrees are committed independently. Enabled submodules are
 committed and pushed before enabled parent repositories. When one turn creates

package/lib/git.js

@@ -115,12 +115,46 @@ function stageAll (cwd) {
 
 function stagePaths (cwd, filePaths) {
   const changed = changedPaths(cwd, filePaths)
-  const paths = pathspecs(cwd, changed)
-  if (paths.length === 0) return []
-  git(`add -A -- ${paths.map(quote).join(' ')}`, { cwd })
+  if (changed.length === 0) return []
+  // A deletion the session already staged (git rm) matches nothing on disk or
+  // in the index, and `git add` aborts on such a pathspec. It is already
+  // staged, so only the remaining paths are added.
+  const paths = pathspecs(cwd, changed.filter(file => existsOnDisk(file) || isIndexed(cwd, file)))
+  if (paths.length > 0) git(`add -A -- ${paths.map(quote).join(' ')}`, { cwd })
   return changed
 }
 
+function existsOnDisk (file) {
+  try {
+    fs.lstatSync(file)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function isIndexed (cwd, file) {
+  const spec = pathspecs(cwd, [file])
+  if (spec.length === 0) return false
+  return git(`ls-files --cached -z -- ${quote(spec[0])}`, { cwd }) !== ''
+}
+
+/**
+ * Git refuses to work while another process holds the index (Xcode and other
+ * tools take `.git/index.lock` briefly), so a staging or commit step is tried
+ * again before its failure is allowed to strand a turn's work.
+ */
+function withGitRetry (operation, attempts = 3, delayMs = 250) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return operation()
+    } catch (err) {
+      if (attempt >= attempts) throw err
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delayMs)
+    }
+  }
+}
+
 function commitPaths (cwd, filePaths, headline, body, opts = {}) {
   if (opts.pathScoped && hasRepositoryOperation(cwd)) return null
   const changed = stagePaths(cwd, filePaths)
@@ -271,6 +305,7 @@ function hasRepositoryOperation (cwd) {
 }
 
 module.exports = {
+  withGitRetry,
   git,
   canonicalRoot,
   canonicalTrackedPath,

package/lib/run.js

@@ -4,7 +4,7 @@ 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, changedPaths, addAndCommit, stagePaths, commitPaths, commitStagedPaths, stagedChangeContext, currentBranch, pushClean, hasRepositoryOperation } = require('./git')
+const { withGitRetry, gitRoot, hasChanges, changedPaths, addAndCommit, stagePaths, commitPaths, commitStagedPaths, stagedChangeContext, currentBranch, pushClean, hasRepositoryOperation } = require('./git')
 const { logEvent } = require('./log')
 const { wrapText } = require('./wrap')
 const {
@@ -281,6 +281,8 @@ function runSingle (input, opts = {}) {
   const project = path.basename(root)
   const branch = currentBranch(root)
   let context = 0
+  // Work a failed commit could not land is retained for a later Stop.
+  let retained = null
   try { context = fs.statSync(transcriptPath).size } catch {}
 
   const sessionId = hookInput.sessionId
@@ -344,6 +346,7 @@ function runSingle (input, opts = {}) {
     logEvent('start', { harness: hookInput.harness, project, branch, context })
 
     const formattedTranscript = formatBody(effectivePairs)
+    if (sessionId) retained = { body: formattedTranscript, paths: ownedPaths }
 
     // Title: agent by default, transcript if opted out
     let headline
@@ -397,9 +400,9 @@ function runSingle (input, opts = {}) {
     const redactions = buildRedactions()
     const safeHeadline = redact(headline, redactions)
     const safeBody = redact(wrappedBody + tag, redactions)
-    const sha = sessionId
+    const sha = withGitRetry(() => sessionId
       ? commitPaths(root, ownedPaths, safeHeadline, safeBody)
-      : addAndCommit(root, safeHeadline, safeBody)
+      : addAndCommit(root, safeHeadline, safeBody))
     if (!sha) {
       if (sessionId) cleanupTracking(root, sessionId)
       logEvent('skip', {
@@ -432,7 +435,8 @@ function runSingle (input, opts = {}) {
     }
     cleanupStale(root)
   } catch (err) {
-    logEvent('fail', { harness: hookInput.harness, project, branch, context })
+    logEvent('fail', { harness: hookInput.harness, project, branch, context, error: failureMessage(err) })
+    if (retained) retainFailedWork(root, sessionId, retained, pairs.length)
     throw err
   }
 }
@@ -534,7 +538,7 @@ function runMulti (hookInput, anchor, currentRepos, manifest, opts = {}) {
 
     try {
       logEvent('start', { harness: hookInput.harness, project, branch, context })
-      const stagedPaths = stagePaths(root, currentPaths)
+      const stagedPaths = withGitRetry(() => stagePaths(root, currentPaths))
       if (stagedPaths.length === 0) {
         manifest.repos = manifest.repos.filter(candidate => candidate !== repo)
         logEvent('skip', { harness: hookInput.harness, project, branch, context, reason: 'no-path-changes' })
@@ -582,7 +586,7 @@ function runMulti (hookInput, anchor, currentRepos, manifest, opts = {}) {
 
       const safeHeadline = redact(headline, redactions)
       const safeBody = redact(body, redactions)
-      const sha = commitStagedPaths(root, stagedPaths, safeHeadline, safeBody)
+      const sha = withGitRetry(() => commitStagedPaths(root, stagedPaths, safeHeadline, safeBody))
       if (!sha) throw new Error('Tracked paths changed before commit')
       if (sessionId) saveMultiWatermark(root, sessionId, sha)
       if (root === anchor && sessionId) {
@@ -597,8 +601,8 @@ function runMulti (hookInput, anchor, currentRepos, manifest, opts = {}) {
         context,
         title: safeHeadline
       })
-    } catch {
-      logEvent('fail', { harness: hookInput.harness, project, branch, context })
+    } catch (err) {
+      logEvent('fail', { harness: hookInput.harness, project, branch, context, error: failureMessage(err) })
     }
   }
 
@@ -631,6 +635,30 @@ function runMulti (hookInput, anchor, currentRepos, manifest, opts = {}) {
   cleanupStale(anchor)
 }
 
+/**
+ * A single-repository commit that failed joins the retry manifest, which any
+ * later Stop in this checkout replays. The session's tracking file is
+ * released so its claims stop blocking other sessions in the meantime.
+ */
+function retainFailedWork (root, sessionId, retained, pairCount) {
+  try {
+    const manifest = loadManifest(root)
+    appendWork(manifest, root, {
+      key: cryptoKey(`${sessionId}\n${pairCount}\n${retained.body}`),
+      body: retained.body,
+      sessionIds: [],
+      paths: retained.paths
+    })
+    saveManifest(root, manifest)
+    cleanupTracking(root, sessionId)
+  } catch {}
+}
+
+function failureMessage (err) {
+  const text = err?.stderr?.toString?.().trim() || err?.message || String(err)
+  return text.split('\n')[0].slice(0, 200)
+}
+
 function transcriptSize (transcriptPath) {
   try {
     return fs.statSync(transcriptPath).size

package/lib/shell.js

@@ -1,17 +1,23 @@
 const fs = require('fs')
 const os = require('os')
 const path = require('path')
-const { canonicalRoot, gitRootForPath } = require('./git')
+const { canonicalRoot, gitRootForPath, hasRepositoryOperation } = require('./git')
 const { activeConfig } = require('./config')
 
 /**
- * Enabled checkouts other than the anchor that a shell command names.
+ * Enabled checkouts other than the anchor that a shell command names, each
+ * with the paths inside it the command named. Only changes under those paths
+ * are attributed, since a command that merely mentions a repository is not
+ * evidence that it wrote anywhere else in it.
  *
- * A command can `cd` anywhere before it edits, so every word that resolves to
- * an existing path is probed for the repository containing it. Relative words
- * are resolved against the command's working directory and against every
- * absolute directory the command mentions, which is how a loop such as
- * `cd ~/code && for r in app/Core lib/Core; do ...` reaches each checkout.
+ * A command can `cd` anywhere before it edits, so every path-shaped word that
+ * resolves to an existing path is probed for the repository containing it.
+ * Relative words are resolved against the command's working directory and
+ * against every absolute directory the command mentions, which is how a loop
+ * such as `cd ~/code && for r in app/Core lib/Core; do ...` reaches each
+ * checkout. A checkout with a merge, rebase, or similar operation in progress
+ * is left alone: its commits cannot be path-scoped, so nothing there may be
+ * attributed on the strength of a mention.
  */
 function shellCheckouts (command, cwd, anchor) {
   if (typeof command !== 'string' || !command) return []
@@ -19,7 +25,7 @@ function shellCheckouts (command, cwd, anchor) {
   const words = shellWords(command)
   const bases = [cwd, ...words.filter(word => path.isAbsolute(word) && isDirectory(word))]
 
-  const candidates = new Set()
+  const named = new Set()
   for (const word of words) {
     const resolved = path.isAbsolute(word)
       ? [word]
@@ -28,18 +34,24 @@ function shellCheckouts (command, cwd, anchor) {
       if (!fs.existsSync(candidate)) continue
       const canonical = canonicalRoot(candidate)
       if (isInside(canonical, anchorRoot) || canonical.startsWith('/dev/')) continue
-      candidates.add(isDirectory(canonical) ? canonical : path.dirname(canonical))
+      named.add(canonical)
     }
   }
 
   const rootsByDir = new Map()
   const checkouts = []
-  for (const dir of candidates) {
+  for (const file of named) {
+    const dir = isDirectory(file) ? file : path.dirname(file)
     if (!rootsByDir.has(dir)) rootsByDir.set(dir, gitRootForPath(dir))
     const root = rootsByDir.get(dir)
-    if (!root || root === anchorRoot || checkouts.includes(root)) continue
-    if (activeConfig(root).config.enabled !== true) continue
-    checkouts.push(root)
+    if (!root || root === anchorRoot) continue
+    let checkout = checkouts.find(candidate => candidate.root === root)
+    if (!checkout) {
+      if (activeConfig(root).config.enabled !== true || hasRepositoryOperation(root)) continue
+      checkout = { root, paths: [] }
+      checkouts.push(checkout)
+    }
+    if (!checkout.paths.includes(file)) checkout.paths.push(file)
   }
   return checkouts
 }
@@ -51,6 +63,9 @@ function shellWords (command) {
     if (word === '~' || word.startsWith('~/')) word = home + word.slice(1)
     if (!word || word.startsWith('-') || word.length > 1024) return []
     if (/[$*?{}[\]\\]/.test(word)) return []
+    // A bare word is an argument or prose, not a path, unless it exists
+    // relative to the working directory itself.
+    if (!path.isAbsolute(word) && !word.includes('/')) return []
     return [word]
   })
 }

package/lib/track.js

@@ -170,7 +170,7 @@ function handleTrack (input, root, opts = {}) {
   // A shell command can edit any checkout it names, so each of those is
   // snapshotted alongside the anchor and attributed back to this session.
   const checkouts = toolName === 'Bash' ? shellCheckouts(toolInput.command, cwd, root) : []
-  const snapshotRoots = [root, ...checkouts]
+  const snapshotRoots = [root, ...checkouts.map(checkout => checkout.root)]
   const removeSnapshots = () => {
     for (const checkout of snapshotRoots) removeBashSnapshot(checkout, sessionId, toolUseId)
   }
@@ -179,12 +179,12 @@ function handleTrack (input, root, opts = {}) {
   try {
     if (snapshotsRepository(toolName)) {
       if (toolName === 'Bash') entry.command = toolInput.command
-      if (checkouts.length > 0) entry.checkouts = checkouts
+      if (checkouts.length > 0) entry.checkouts = snapshotRoots.slice(1)
       pendingSnapshot = true
-      for (const checkout of snapshotRoots) {
-        savePendingBashSnapshot(checkout, sessionId, toolUseId, cwd, toolName, checkout === root ? checkouts : [])
+      savePendingBashSnapshot(root, sessionId, toolUseId, cwd, toolName, { checkouts: snapshotRoots.slice(1) })
+      for (const checkout of checkouts) {
+        savePendingBashSnapshot(checkout.root, sessionId, toolUseId, cwd, toolName, { scope: checkout.paths })
       }
-      appendTracking(root, sessionId, entry)
     } else {
       preclaim = savePreclaim(root, sessionId, entry)
     }
@@ -196,6 +196,9 @@ function handleTrack (input, root, opts = {}) {
 
   const recoveryWaitMs = opts.recoveryWaitMs ?? 5000
   if (pendingSnapshot) {
+    // The pending snapshots already keep recovery out of every checkout, so
+    // the claim is recorded only once the tool is certain to run. A denied
+    // tool must leave nothing behind for another session to honor.
     try {
       for (const checkout of snapshotRoots) {
         if (!startBashSnapshot(checkout, sessionId, toolUseId, cwd, recoveryWaitMs)) {
@@ -203,6 +206,7 @@ function handleTrack (input, root, opts = {}) {
           return false
         }
       }
+      appendTracking(root, sessionId, entry)
     } catch (error) {
       removeSnapshots()
       throw error
@@ -283,7 +287,7 @@ function finishBashSnapshot (root, snapshot, { cwd, endedAt, trackingRoot = root
   const claimed = overlapping
     ? claimedPathsBySessions(root)
     : claimedPathsBySessions(root, snapshot.sessionId)
-  const candidates = changed.filter(file => !before.has(file) && !claimed.has(file))
+  const candidates = changed.filter(file => !before.has(file) && !claimed.has(file) && withinScope(snapshot, file))
   const files = overlapping ? [] : candidates
 
   const entry = { tool: snapshot.toolName || 'Bash', phase: 'post', t: endedAt, cwd }
@@ -301,6 +305,15 @@ function finishBashSnapshot (root, snapshot, { cwd, endedAt, trackingRoot = root
   return true
 }
 
+/**
+ * A snapshot taken in a checkout the command merely named only attributes
+ * paths under what it named; the anchor snapshot has no scope.
+ */
+function withinScope (snapshot, file) {
+  if (!Array.isArray(snapshot.scope)) return true
+  return snapshot.scope.some(named => file === named || file.startsWith(named + path.sep))
+}
+
 function bashSnapshotDir (root) {
   const base = turbocommitDir(root)
   return base && path.join(base, 'bash-snapshots')
@@ -315,7 +328,7 @@ function bashSnapshotPath (root, sessionId, toolUseId) {
   return path.join(dir, key + '.json')
 }
 
-function savePendingBashSnapshot (root, sessionId, toolUseId, cwd, toolName = 'Bash', checkouts = []) {
+function savePendingBashSnapshot (root, sessionId, toolUseId, cwd, toolName = 'Bash', { checkouts = [], scope } = {}) {
   const checkout = canonicalRoot(root)
   writeBashSnapshot(root, sessionId, toolUseId, {
     root: checkout,
@@ -325,7 +338,8 @@ function savePendingBashSnapshot (root, sessionId, toolUseId, cwd, toolName = 'B
     toolUseId: toolUseId || null,
     createdAt: Date.now(),
     pending: true,
-    ...(checkouts.length > 0 ? { checkouts } : {})
+    ...(checkouts.length > 0 ? { checkouts } : {}),
+    ...(Array.isArray(scope) ? { scope } : {})
   })
 }
 

package/package.json

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