@searls/turbocommit 0.14.1 → 0.15.1

package/lib/harness.js

@@ -75,6 +75,7 @@ function normalizeHookInput (input, event, forcedHarness) {
     transcriptPath: hookInput.transcript_path,
     toolName: hookInput.tool_name,
     toolInput: hookInput.tool_input || {},
+    toolUseId: hookInput.tool_use_id,
     cwd: hookInput.cwd,
     model: hookInput.model,
     source: hookInput.source,
@@ -85,6 +86,7 @@ function normalizeHookInput (input, event, forcedHarness) {
 function eventName (event) {
   const names = {
     'pre-tool-use': 'PreToolUse',
+    'post-tool-use': 'PostToolUse',
     'session-start': 'SessionStart',
     'session-end': 'SessionEnd',
     'pre-compact': 'PreCompact',

package/lib/install.js

@@ -10,11 +10,19 @@ const HOOK_DEFS = {
     matcher: 'Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
     hooks: [{ type: 'command', command: 'turbocommit hook pre-tool-use --harness claude' }]
   },
+  PostToolUse: {
+    matcher: 'Bash',
+    hooks: [{ type: 'command', command: 'turbocommit hook post-tool-use --harness claude' }]
+  },
+  PostToolUseFailure: {
+    matcher: 'Bash',
+    hooks: [{ type: 'command', command: 'turbocommit hook post-tool-use --harness claude' }]
+  },
   SessionStart: {
     hooks: [{ type: 'command', command: 'turbocommit hook session-start --harness claude' }]
   },
   SessionEnd: {
-    hooks: [{ type: 'command', command: 'turbocommit hook session-end --harness claude' }]
+    hooks: [{ type: 'command', command: 'turbocommit hook session-end --harness claude', timeout: 60 }]
   },
   Stop: {
     hooks: [{ type: 'command', command: 'turbocommit hook stop --harness claude' }]
@@ -26,10 +34,17 @@ const CODEX_HOOK_DEFS = {
     matcher: 'apply_patch|Write|Edit|MultiEdit|NotebookEdit|Bash|mcp__.*',
     hooks: [{ type: 'command', command: 'turbocommit hook pre-tool-use --harness codex' }]
   },
+  PostToolUse: {
+    matcher: 'Bash',
+    hooks: [{ type: 'command', command: 'turbocommit hook post-tool-use --harness codex' }]
+  },
   SessionStart: {
     matcher: 'resume|clear',
     hooks: [{ type: 'command', command: 'turbocommit hook session-start --harness codex' }]
   },
+  SessionEnd: {
+    hooks: [{ type: 'command', command: 'turbocommit hook session-end --harness codex', timeout: 3 }]
+  },
   PreCompact: {
     matcher: 'manual|auto',
     hooks: [{ type: 'command', command: 'turbocommit hook pre-compact --harness codex' }]
@@ -63,11 +78,12 @@ function hasTurbocommit (groups) {
  */
 function hasExactHooks (groups, def) {
   if (!Array.isArray(groups)) return false
-  const expected = def.hooks.map(h => h.command)
-  return expected.every(cmd =>
+  return def.hooks.every(expected =>
     groups.some(g => {
       const hooks = g && g.hooks ? g.hooks : []
-      return hooks.some(h => h.command === cmd)
+      const matcherMatches = def.matcher === undefined || g.matcher === def.matcher
+      return matcherMatches && hooks.some(actual =>
+        Object.entries(expected).every(([key, value]) => actual[key] === value))
     })
   )
 }
@@ -99,8 +115,7 @@ function removeTurbocommitHooks (groups) {
 }
 
 /**
- * Install turbocommit hooks for all 4 events (PreToolUse, SessionStart,
- * SessionEnd, Stop). Each event gets its own group at the end.
+ * Install every turbocommit hook event. Each event gets its own group at the end.
  * Cleans up stale entries (including old `turbocommit run`) on install.
  */
 function installClaude (settingsPath) {

package/lib/multi.js

@@ -3,7 +3,7 @@ const fs = require('fs')
 const path = require('path')
 const { ensureDir, loadJson } = require('./io')
 const { turbocommitDir } = require('./session')
-const { gitRoot, gitRootForPath, isGitlink } = require('./git')
+const { canonicalRoot, canonicalTrackedPath, gitRoot, gitRootForPath, gitWorktrees, hasPathChanges, isGitlink } = require('./git')
 const { activeConfig } = require('./config')
 
 function checkoutKey (root) {
@@ -15,13 +15,16 @@ function manifestPath (anchor) {
 }
 
 function loadManifest (anchor) {
-  return loadJson(manifestPath(anchor)) || { nextOrder: 0, repos: [] }
+  return normalizeManifest(loadJson(manifestPath(anchor)))
 }
 
 function saveManifest (anchor, manifest) {
   const file = manifestPath(anchor)
   ensureDir(path.dirname(file))
-  fs.writeFileSync(file, JSON.stringify(manifest, null, 2) + '\n')
+  fs.writeFileSync(file, JSON.stringify({
+    nextOrder: manifest.nextOrder,
+    repos: manifest.repos
+  }, null, 2) + '\n')
 }
 
 function deleteManifestIfEmpty (anchor, manifest) {
@@ -34,41 +37,91 @@ function deleteManifestIfEmpty (anchor, manifest) {
   } 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)
+function trackedChangesFromEntries (anchor, entries) {
+  const pathsByRoot = new Map()
+  const ambiguous = []
+  const add = (root, file) => {
+    root = canonicalRoot(root)
+    file = canonicalTrackedPath(file)
+    if (!root || activeConfig(root).config.enabled !== true) return
+    const relative = path.relative(root, file)
+    if (!relative || relative.startsWith('..')) return
+    if (!pathsByRoot.has(root)) pathsByRoot.set(root, new Set())
+    pathsByRoot.get(root).add(path.join(root, relative))
   }
 
   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)
+    const rawFiles = Array.isArray(entry.rawFiles) && entry.rawFiles.length > 0
+      ? entry.rawFiles
+      : Array.isArray(entry.files) ? entry.files : []
+    if (entry.tool === 'Bash' && rawFiles.length === 0) continue
+    if (rawFiles.length === 0) continue
+
+    for (const rawFile of rawFiles) {
+      const candidates = changedCandidates(anchor, entry.cwd || anchor, rawFile, entry.tool)
+      if (candidates.length > 1) {
+        ambiguous.push({ tool: entry.tool, path: rawFile, reason: 'multiple-worktrees' })
+      } else if (candidates.length === 1) {
+        add(candidates[0].root, candidates[0].file)
+      }
     }
   }
-  return addEnabledSuperprojects(roots, add)
+
+  addEnabledSuperprojects(pathsByRoot, add)
+  const repos = [...pathsByRoot].map(([root, paths]) => ({ root, paths: [...paths] }))
+  return { repos, ambiguous }
+}
+
+function changedCandidates (anchor, cwd, rawFile, tool) {
+  if (path.isAbsolute(rawFile)) return changedCandidate(rawFile)
+
+  anchor = canonicalRoot(anchor)
+  const direct = canonicalTrackedPath(path.resolve(cwd, rawFile))
+  const directRoot = gitRootForPath(direct)
+  if (!isOpaquePathTool(tool) || (directRoot && directRoot !== anchor)) {
+    return changedCandidate(direct)
+  }
+
+  const relative = path.relative(anchor, direct)
+  if (!relative || relative.startsWith('..')) return changedCandidate(direct)
+  const candidates = []
+  const seen = new Set()
+  for (const worktree of gitWorktrees(anchor)) {
+    const file = canonicalTrackedPath(path.join(worktree, relative))
+    if (isDirectoryPath(file)) continue
+    const root = gitRootForPath(file)
+    if (!root || seen.has(root) || activeConfig(root).config.enabled !== true) continue
+    seen.add(root)
+    if (hasPathChanges(root, file)) candidates.push({ root, file })
+  }
+  return candidates
+}
+
+function isOpaquePathTool (tool) {
+  return typeof tool === 'string' && tool.startsWith('mcp__')
 }
 
-function addEnabledSuperprojects (roots, add) {
-  for (let i = 0; i < roots.length; i++) {
-    const child = roots[i]
+function changedCandidate (file) {
+  if (isDirectoryPath(file)) return []
+  file = canonicalTrackedPath(file)
+  const root = gitRootForPath(file)
+  if (!root || activeConfig(root).config.enabled !== true) return []
+  return hasPathChanges(root, file) ? [{ root, file }] : []
+}
+
+function isDirectoryPath (file) {
+  try {
+    return fs.statSync(file).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function addEnabledSuperprojects (pathsByRoot, add) {
+  for (const child of [...pathsByRoot.keys()]) {
     const parent = gitRoot(path.dirname(child))
-    if (parent && parent !== child && isGitlink(parent, child)) add(parent)
+    if (parent && parent !== child && isGitlink(parent, child)) add(parent, child)
   }
-  return roots
 }
 
 function dependencyOrder (repos) {
@@ -89,6 +142,29 @@ function appendWork (manifest, root, work) {
   return repo
 }
 
+function normalizeManifest (stored) {
+  const manifest = stored && typeof stored === 'object' ? stored : {}
+  const repos = Array.isArray(manifest.repos) ? manifest.repos : []
+  let discardedLegacyWork = 0
+  const normalizedRepos = []
+
+  for (const repo of repos) {
+    if (!repo || typeof repo.root !== 'string' || !Array.isArray(repo.work)) continue
+    const work = repo.work.filter(item => {
+      const safe = item && Array.isArray(item.paths) && item.paths.length > 0
+      if (!safe) discardedLegacyWork++
+      return safe
+    })
+    if (work.length > 0) normalizedRepos.push({ ...repo, work })
+  }
+
+  return {
+    nextOrder: Number.isInteger(manifest.nextOrder) ? manifest.nextOrder : 0,
+    repos: normalizedRepos,
+    discardedLegacyWork
+  }
+}
+
 function multiWatermarkPath (root, sessionId) {
   return path.join(turbocommitDir(root), 'multi-watermarks', checkoutKey(root), sessionId + '.json')
 }
@@ -115,7 +191,7 @@ module.exports = {
   loadManifest,
   manifestPath,
   readMultiWatermark,
-  rootsFromEntries,
+  trackedChangesFromEntries,
   saveManifest,
   saveMultiWatermark
 }

package/lib/rescue.js

@@ -0,0 +1,308 @@
+const crypto = require('crypto')
+const { execFileSync } = require('child_process')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { gitCommonDir } = require('./git')
+const { ensureDir } = require('./io')
+
+function createSessionEndRescue (root, hookInput) {
+  const gitDir = gitCommonDir(root)
+  if (!gitDir || !hookInput?.sessionId) return null
+  const id = crypto.randomUUID()
+  const ref = `refs/turbocommit/session-end-rescues/${id}`
+  const stateDir = path.join(gitDir, 'turbocommit', 'session-end-rescues')
+  const index = path.join(stateDir, `${id}.index`)
+  const recordPath = path.join(stateDir, `${id}.json`)
+  const env = { ...process.env, GIT_INDEX_FILE: index }
+  let checkoutIdentity
+  try {
+    ensureDir(stateDir)
+    const rawIndex = gitOutput(root, ['rev-parse', '--git-path', 'index'])
+    const realIndex = path.isAbsolute(rawIndex) ? rawIndex : path.resolve(root, rawIndex)
+    if (realIndex && fs.existsSync(realIndex)) {
+      fs.copyFileSync(realIndex, index)
+    } else {
+      gitOutput(root, ['read-tree', 'HEAD'], { env })
+    }
+    gitOutput(root, ['add', '-A'], { env })
+    const tree = gitOutput(root, ['write-tree'], { env })
+    const head = gitOutput(root, ['rev-parse', 'HEAD'])
+    const branch = gitOutput(root, ['branch', '--show-current'])
+    const commit = gitOutput(root, ['commit-tree', tree, '-p', head, '-m', 'turbocommit SessionEnd rescue'])
+    gitOutput(root, ['update-ref', ref, commit, '0'.repeat(commit.length)])
+    checkoutIdentity = createCheckoutIdentity(root, id)
+    if (!checkoutIdentity) throw new Error('Could not identify rescued checkout')
+    const rescue = {
+      id,
+      ref,
+      commit,
+      head,
+      branch: branch || null,
+      root,
+      gitDir,
+      checkoutIdentity,
+      recordPath,
+      hookInput
+    }
+    writeRecord(recordPath, rescue)
+    return rescue
+  } catch {
+    try { gitOutput(root, ['update-ref', '-d', ref]) } catch {}
+    cleanupCheckoutIdentity(checkoutIdentity)
+    try { fs.unlinkSync(recordPath) } catch {}
+    return null
+  } finally {
+    try { fs.unlinkSync(index) } catch {}
+  }
+}
+
+function restoreSessionEndRescue (rescue) {
+  if (!rescue?.gitDir || !rescue.root || !rescue.commit) return false
+  if (fs.existsSync(rescue.root)) return false
+  let created = false
+  try {
+    ensureDir(path.dirname(rescue.root))
+    const args = ['--git-dir', rescue.gitDir, 'worktree', 'add', '--force', '--detach', rescue.root, rescue.head]
+    execFileSync('git', args, { cwd: stableGitCwd(rescue.gitDir), stdio: 'ignore' })
+    created = true
+    gitOutput(rescue.root, ['restore', '--source', rescue.commit, '--worktree', '--', '.'])
+    return true
+  } catch {
+    if (created) removeSessionEndRescueWorktree(rescue)
+    return false
+  }
+}
+
+function matchesSessionEndRescueRoot (rescue, root) {
+  if (!rescue?.checkoutIdentity || !root) return false
+  try {
+    if (canonicalExistingPath(gitCommonDir(root)) !== canonicalExistingPath(rescue.gitDir)) return false
+    if (gitOutput(root, ['rev-parse', 'HEAD']) !== rescue.head) return false
+    if ((gitOutput(root, ['branch', '--show-current']) || null) !== rescue.branch) return false
+    return sameCheckoutIdentity(readCheckoutIdentity(root), rescue.checkoutIdentity) &&
+      hasCheckoutIdentityMarker(rescue.checkoutIdentity)
+  } catch {
+    return false
+  }
+}
+
+function finalizeRestoredSessionEndRescue (rescue, { clean = false } = {}) {
+  const recovered = preserveSessionEndRecoveredCommit(rescue, rescue.root)
+  if (!recovered) return { resolved: false, preserved: false }
+  const { recoveredCommit, recoveredRef } = recovered
+
+  if (!clean) {
+    recordPreservedSessionEndRescue(rescue, recovered, 'dirty-recovery-worktree')
+    return { resolved: false, preserved: true, recoveredCommit, recoveredRef, removeWorktree: false }
+  }
+
+  if (!rescue.branch) {
+    recordPreservedSessionEndRescue(rescue, recovered, 'detached-recovered')
+    return { resolved: false, preserved: true, recoveredCommit, recoveredRef, removeWorktree: true }
+  }
+
+  if (!removeSessionEndRescueWorktree(rescue)) {
+    recordPreservedSessionEndRescue(rescue, recovered, 'restore-worktree-removal-failed')
+    return { resolved: false, preserved: true, recoveredCommit, recoveredRef, removeWorktree: false }
+  }
+
+  let attached = false
+  try {
+    execFileSync('git', ['--git-dir', rescue.gitDir, 'worktree', 'add', rescue.root, rescue.branch], {
+      cwd: stableGitCwd(rescue.gitDir),
+      stdio: 'ignore'
+    })
+    attached = true
+    if (gitOutput(rescue.root, ['rev-parse', 'HEAD']) !== rescue.head) throw new Error('Branch advanced')
+    if (gitOutput(rescue.root, ['branch', '--show-current']) !== rescue.branch) throw new Error('Wrong branch')
+    if (!isClean(rescue.root)) throw new Error('Attached worktree is dirty')
+    gitOutput(rescue.root, ['merge', '--ff-only', recoveredRef])
+    if (gitOutput(rescue.root, ['rev-parse', 'HEAD']) !== recoveredCommit) throw new Error('Branch did not advance')
+    return { resolved: true, preserved: true, recoveredCommit, recoveredRef, attached: true }
+  } catch {
+    if (attached) removeSessionEndRescueWorktree(rescue)
+    const status = branchAtCapturedHead(rescue) ? 'branch-unavailable' : 'branch-advanced'
+    recordPreservedSessionEndRescue(rescue, recovered, status)
+    return { resolved: false, preserved: true, recoveredCommit, recoveredRef, removeWorktree: false }
+  }
+}
+
+function recordPreservedSessionEndRescue (rescue, recovered, status) {
+  try {
+    writeRecord(rescue.recordPath, {
+      ...rescue,
+      ...recovered,
+      status
+    })
+  } catch {}
+}
+
+function branchAtCapturedHead (rescue) {
+  if (!rescue?.branch || !rescue.gitDir || !rescue.head) return false
+  try {
+    return gitOutput(stableGitCwd(rescue.gitDir), [
+      '--git-dir', rescue.gitDir, 'rev-parse', '--verify', `refs/heads/${rescue.branch}`
+    ]) === rescue.head
+  } catch {
+    return false
+  }
+}
+
+function preserveSessionEndRecoveredCommit (rescue, root) {
+  if (!rescue?.gitDir || !rescue.id || !root) return null
+  try {
+    const recoveredCommit = gitOutput(root, ['rev-parse', 'HEAD'])
+    const recoveredRef = `refs/turbocommit/session-end-recovered/${rescue.id}`
+    let current = null
+    try {
+      current = gitOutput(stableGitCwd(rescue.gitDir), [
+        '--git-dir', rescue.gitDir, 'rev-parse', '--verify', recoveredRef
+      ])
+    } catch {}
+    if (current && current !== recoveredCommit) return null
+    if (!current) {
+      execFileSync('git', [
+        '--git-dir', rescue.gitDir,
+        'update-ref', recoveredRef, recoveredCommit, '0'.repeat(recoveredCommit.length)
+      ], {
+        cwd: stableGitCwd(rescue.gitDir),
+        stdio: 'ignore'
+      })
+    }
+    return { recoveredCommit, recoveredRef }
+  } catch {
+    return null
+  }
+}
+
+function removeSessionEndRescueWorktree (rescue, { force = false } = {}) {
+  if (!rescue?.gitDir || !rescue.root) return false
+  try {
+    const args = ['--git-dir', rescue.gitDir, 'worktree', 'remove']
+    if (force) args.push('--force')
+    args.push(rescue.root)
+    execFileSync('git', args, {
+      cwd: stableGitCwd(rescue.gitDir),
+      stdio: 'ignore'
+    })
+  } catch {}
+  return !fs.existsSync(rescue.root)
+}
+
+function cleanupSessionEndRescue (rescue, { removeWorktree = false } = {}) {
+  if (!rescue) return false
+  if (removeWorktree && !removeSessionEndRescueWorktree(rescue)) return false
+  if (rescue.gitDir && rescue.ref && rescue.commit) {
+    try {
+      execFileSync('git', ['--git-dir', rescue.gitDir, 'update-ref', '-d', rescue.ref, rescue.commit], {
+        cwd: stableGitCwd(rescue.gitDir),
+        stdio: 'ignore'
+      })
+    } catch {}
+  }
+  cleanupCheckoutIdentity(rescue.checkoutIdentity)
+  try { fs.unlinkSync(rescue.recordPath) } catch {}
+  return true
+}
+
+function isClean (root) {
+  try {
+    return gitOutput(root, ['status', '--porcelain']) === ''
+  } catch {
+    return false
+  }
+}
+
+function writeRecord (file, rescue) {
+  const temporary = file + `.${process.pid}.${crypto.randomUUID()}.tmp`
+  try {
+    fs.writeFileSync(temporary, JSON.stringify(rescue) + '\n')
+    fs.renameSync(temporary, file)
+  } finally {
+    try { fs.unlinkSync(temporary) } catch {}
+  }
+}
+
+function readCheckoutIdentity (root) {
+  try {
+    const rootStat = fs.statSync(root, { bigint: true })
+    const rawGitDir = gitOutput(root, ['rev-parse', '--git-dir'])
+    const worktreeGitDir = canonicalExistingPath(path.isAbsolute(rawGitDir) ? rawGitDir : path.resolve(root, rawGitDir))
+    const gitDirStat = fs.statSync(worktreeGitDir, { bigint: true })
+    return {
+      rootDevice: rootStat.dev.toString(),
+      rootInode: rootStat.ino.toString(),
+      worktreeGitDir,
+      gitDirDevice: gitDirStat.dev.toString(),
+      gitDirInode: gitDirStat.ino.toString()
+    }
+  } catch {
+    return null
+  }
+}
+
+function createCheckoutIdentity (root, id) {
+  const identity = readCheckoutIdentity(root)
+  if (!identity) return null
+  const markerDir = path.join(identity.worktreeGitDir, 'turbocommit-rescue-identities')
+  const markerPath = path.join(markerDir, `${id}.marker`)
+  const markerToken = crypto.randomUUID()
+  ensureDir(markerDir)
+  fs.writeFileSync(markerPath, markerToken + '\n', { flag: 'wx' })
+  return { ...identity, markerPath, markerToken }
+}
+
+function hasCheckoutIdentityMarker (identity) {
+  if (!identity?.markerPath || !identity.markerToken) return false
+  try {
+    return fs.readFileSync(identity.markerPath, 'utf8').trim() === identity.markerToken
+  } catch {
+    return false
+  }
+}
+
+function cleanupCheckoutIdentity (identity) {
+  if (!identity?.markerPath) return
+  try { fs.unlinkSync(identity.markerPath) } catch {}
+  try { fs.rmdirSync(path.dirname(identity.markerPath)) } catch {}
+}
+
+function sameCheckoutIdentity (actual, expected) {
+  if (!actual || !expected) return false
+  return actual.rootDevice === expected.rootDevice &&
+    actual.rootInode === expected.rootInode &&
+    actual.worktreeGitDir === expected.worktreeGitDir &&
+    actual.gitDirDevice === expected.gitDirDevice &&
+    actual.gitDirInode === expected.gitDirInode
+}
+
+function canonicalExistingPath (filePath) {
+  return fs.realpathSync(path.resolve(filePath))
+}
+
+function gitOutput (cwd, args, opts = {}) {
+  return execFileSync('git', args, {
+    cwd,
+    env: opts.env || process.env,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore']
+  }).trim()
+}
+
+function stableGitCwd (gitDir) {
+  const parent = path.dirname(gitDir)
+  return fs.existsSync(parent) ? parent : os.tmpdir()
+}
+
+module.exports = {
+  createSessionEndRescue,
+  restoreSessionEndRescue,
+  matchesSessionEndRescueRoot,
+  finalizeRestoredSessionEndRescue,
+  preserveSessionEndRecoveredCommit,
+  recordPreservedSessionEndRescue,
+  removeSessionEndRescueWorktree,
+  cleanupSessionEndRescue,
+  isClean
+}