@claudemini/shit-cli 1.4.0 → 1.6.0

package/lib/disable.js

@@ -7,17 +7,17 @@
 
 import { existsSync, readFileSync, writeFileSync, rmSync } from 'fs';
 import { join } from 'path';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { getProjectRoot } from './config.js';
+
+const CLAUDE_HOOK_TYPES = [
+  'SessionStart',
+  'SessionEnd',
+  'UserPromptSubmit',
+  'PreToolUse',
+  'PostToolUse',
+  'Stop',
+  'Notification',
+];
 
 function removeClaudeHooks(projectRoot) {
   const settingsFile = join(projectRoot, '.claude', 'settings.json');
@@ -28,13 +28,49 @@ function removeClaudeHooks(projectRoot) {
 
   try {
     const settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+    let removed = false;
 
     if (settings.hooks) {
-      // Remove shit-cli hooks
-      delete settings.hooks.session_start;
-      delete settings.hooks.session_end;
-      delete settings.hooks.tool_use;
-      delete settings.hooks.edit_applied;
+      for (const hookType of CLAUDE_HOOK_TYPES) {
+        const rawEntries = settings.hooks[hookType];
+        if (Array.isArray(rawEntries)) {
+          const nextEntries = rawEntries
+            .map(entry => {
+              if (!Array.isArray(entry?.hooks)) {
+                return entry;
+              }
+              const nextHooks = entry.hooks.filter(hook =>
+                !(typeof hook?.command === 'string' && hook.command.includes('shit log'))
+              );
+              if (nextHooks.length !== entry.hooks.length) {
+                removed = true;
+              }
+              if (nextHooks.length === 0) {
+                return null;
+              }
+              return { ...entry, hooks: nextHooks };
+            })
+            .filter(Boolean);
+
+          if (nextEntries.length > 0) {
+            settings.hooks[hookType] = nextEntries;
+          } else {
+            delete settings.hooks[hookType];
+          }
+        } else if (typeof rawEntries === 'string' && rawEntries.includes('shit log')) {
+          delete settings.hooks[hookType];
+          removed = true;
+        }
+      }
+
+      // Cleanup legacy wrong names written by old versions.
+      const legacyKeys = ['session_start', 'session_end', 'tool_use', 'edit_applied'];
+      for (const key of legacyKeys) {
+        if (Object.prototype.hasOwnProperty.call(settings.hooks, key)) {
+          delete settings.hooks[key];
+          removed = true;
+        }
+      }
 
       // If hooks object is empty, remove it
       if (Object.keys(settings.hooks).length === 0) {
@@ -43,7 +79,7 @@ function removeClaudeHooks(projectRoot) {
     }
 
     writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
-    return true;
+    return removed;
   } catch {
     return false;
   }
@@ -74,7 +110,7 @@ function removeFromGitignore(projectRoot) {
 
 export default async function disable(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const cleanData = args.includes('--clean') || args.includes('--purge');
 
     console.log('🔧 Disabling shit-cli in repository...');

package/lib/doctor.js

@@ -5,20 +5,10 @@
  * Similar to 'entire doctor' - repairs corrupted state and cleans up
  */
 
-import { existsSync, readFileSync, writeFileSync, rmSync, readdirSync, statSync } from 'fs';
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
 
 function git(cmd, cwd) {
   return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
@@ -33,7 +23,6 @@ function checkShitLogsStructure(projectRoot) {
       type: 'missing_directory',
       message: '.shit-logs directory not found',
       fix: () => {
-        const { mkdirSync } = require('fs');
         mkdirSync(shitLogsDir, { recursive: true });
         return 'Created .shit-logs directory';
       }
@@ -67,7 +56,6 @@ function checkShitLogsStructure(projectRoot) {
         message: 'index.json is corrupted',
         fix: () => {
           const backup = `${indexFile}.backup.${Date.now()}`;
-          const { copyFileSync } = require('fs');
           copyFileSync(indexFile, backup);
 
           const initialIndex = {
@@ -98,7 +86,7 @@ function checkSessionDirectories(projectRoot) {
   const entries = readdirSync(shitLogsDir);
   const sessionDirs = entries.filter(name => {
     const fullPath = join(shitLogsDir, name);
-    return statSync(fullPath).isDirectory() && name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/);
+    return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
   });
 
   for (const sessionDir of sessionDirs) {
@@ -132,7 +120,6 @@ function checkSessionDirectories(projectRoot) {
           sessionDir,
           fix: () => {
             const backup = `${stateFile}.backup.${Date.now()}`;
-            const { copyFileSync } = require('fs');
             copyFileSync(stateFile, backup);
 
             const defaultState = {
@@ -166,7 +153,7 @@ function checkOrphanedShadowBranches(projectRoot) {
     const sessionDirs = existsSync(shitLogsDir) ?
       readdirSync(shitLogsDir).filter(name => {
         const fullPath = join(shitLogsDir, name);
-        return statSync(fullPath).isDirectory() && name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/);
+        return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
       }) : [];
 
     for (const branch of branches) {
@@ -208,11 +195,12 @@ function checkStuckSessions(projectRoot) {
   const entries = readdirSync(shitLogsDir);
   const sessionDirs = entries.filter(name => {
     const fullPath = join(shitLogsDir, name);
-    return statSync(fullPath).isDirectory() && name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/);
+    return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
   });
 
   const now = new Date();
   const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+  const endedHookTypes = new Set(['session-end', 'SessionEnd', 'stop', 'session_end', 'end']);
 
   for (const sessionDir of sessionDirs) {
     const sessionPath = join(shitLogsDir, sessionDir);
@@ -221,13 +209,18 @@ function checkStuckSessions(projectRoot) {
     if (existsSync(stateFile)) {
       try {
         const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
-        const startTime = new Date(state.start_time);
-
-        // Check for sessions older than 24 hours without end_time
-        if (!state.end_time && startTime < oneDayAgo) {
+        const lastActivity = new Date(state.last_time || state.start_time);
+        const hasValidLastActivity = !Number.isNaN(lastActivity.getTime());
+        const endedByHook = endedHookTypes.has(state.last_hook_type);
+        const hasShadowBranch = typeof state.shadow_branch === 'string' && state.shadow_branch.length > 0;
+        const hasCheckpoint = Array.isArray(state.checkpoints) && state.checkpoints.length > 0;
+        const consideredEnded = Boolean(state.end_time) || endedByHook || hasShadowBranch || hasCheckpoint;
+
+        // Stuck means inactive for >24h and not explicitly/implicitly ended.
+        if (!consideredEnded && hasValidLastActivity && lastActivity < oneDayAgo) {
           issues.push({
             type: 'stuck_session',
-            message: `Stuck session: ${sessionDir} (started ${startTime.toLocaleString()})`,
+            message: `Stuck session: ${sessionDir} (last activity ${lastActivity.toLocaleString()})`,
             sessionDir,
             fix: () => {
               state.end_time = new Date().toISOString();
@@ -248,7 +241,7 @@ function checkStuckSessions(projectRoot) {
 
 export default async function doctor(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const autoFix = args.includes('--fix') || args.includes('--auto-fix');
     const verbose = args.includes('--verbose') || args.includes('-v');
 

package/lib/enable.js

@@ -9,17 +9,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { getProjectRoot } from './config.js';
 
 // Agent-specific hook configurations
 const AGENT_HOOKS = {
@@ -95,9 +85,30 @@ function setupAgentHooks(projectRoot, agentType) {
   }
 
   // Add shit-cli hooks
-  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
 
   for (const [hookName, command] of Object.entries(config.hooks)) {
+    if (agentType === 'claude-code') {
+      const current = settings.hooks[hookName];
+      const existing = Array.isArray(current)
+        ? current
+        : (typeof current === 'string'
+          ? [{ matcher: '', hooks: [{ type: 'command', command: current }] }]
+          : []);
+      const alreadyExists = existing.some(entry =>
+        Array.isArray(entry?.hooks) &&
+        entry.hooks.some(hook => typeof hook?.command === 'string' && hook.command.includes('shit log'))
+      );
+
+      if (!alreadyExists) {
+        existing.push({ matcher: '', hooks: [{ type: 'command', command }] });
+      }
+      settings.hooks[hookName] = existing;
+      continue;
+    }
+
     settings.hooks[hookName] = command;
   }
 
@@ -164,7 +175,7 @@ function initializeShitLogs(projectRoot) {
 
 export default async function enable(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
 
     // Parse arguments
     const agents = [];

package/lib/explain.js

@@ -5,19 +5,25 @@
  * Provides human-readable explanation of what happened in a session
  */
 
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
 
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
+function git(args, cwd, ignoreError = false) {
+  try {
+    return execFileSync('git', args, {
+      cwd,
+      encoding: 'utf-8',
+      timeout: 10000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch (error) {
+    if (ignoreError) {
+      return null;
     }
-    dir = join(dir, '..');
+    throw error;
   }
-  throw new Error('Not in a git repository');
 }
 
 function getSessionData(sessionId, projectRoot) {
@@ -41,7 +47,6 @@ function getSessionData(sessionId, projectRoot) {
 }
 
 function explainFromSummary(summaryText) {
-  const lines = summaryText.split('\n');
   const explanation = [];
 
   // Extract key information
@@ -113,23 +118,20 @@ function explainFromSummary(summaryText) {
 function explainFromCommit(commitSha, projectRoot) {
   try {
     // Try to find associated checkpoint
-    const checkpoints = execSync('git branch --list "shit/checkpoints/v1/*"', {
-      cwd: projectRoot,
-      encoding: 'utf-8'
-    }).split('\n').filter(Boolean);
+    const checkpoints = (git(['branch', '--list', 'shit/checkpoints/v1/*'], projectRoot, true) || '')
+      .split('\n')
+      .map(line => line.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
 
     for (const branch of checkpoints) {
       try {
-        const log = execSync(`git log ${branch} --oneline -1`, {
-          cwd: projectRoot,
-          encoding: 'utf-8'
-        }).trim();
+        const log = git(['log', branch, '--oneline', '-1'], projectRoot, true);
+        if (!log) {
+          continue;
+        }
 
         if (log.includes(commitSha.slice(0, 12))) {
-          const message = execSync(`git log ${branch} --format=%B -1`, {
-            cwd: projectRoot,
-            encoding: 'utf-8'
-          }).trim();
+          const message = git(['log', branch, '--format=%B', '-1'], projectRoot, true) || '';
 
           return `📸 This commit has an associated checkpoint:\n\nBranch: ${branch}\n\n${message}`;
         }
@@ -146,13 +148,13 @@ function explainFromCommit(commitSha, projectRoot) {
 
 export default async function explain(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const target = args[0];
 
     if (!target) {
       console.log('Usage: shit explain <session-id | commit-sha>');
       console.log('\nExamples:');
-      console.log('  shit explain 2026-02-28-abc12345  # Explain a session');
+      console.log('  shit explain b5613b31-c732-4546-9be5-f8ae36f2327f  # Explain a session');
       console.log('  shit explain abc1234              # Explain a commit');
       process.exit(1);
     }
@@ -170,23 +172,26 @@ export default async function explain(args) {
     }
 
     // Try as commit
-    try {
-      execSync('git rev-parse --verify ' + target + '^{commit}', {
-        cwd: projectRoot,
-        stdio: 'ignore'
-      });
-
-      console.log('📸 Commit Explanation\n');
-      console.log(explainFromCommit(target, projectRoot));
-      return;
-    } catch {
-      // Not a commit
+    const isCommitLike = /^[a-f0-9]{4,40}$/i.test(target);
+    if (isCommitLike) {
+      const resolvedCommit = git(['rev-parse', '--verify', `${target}^{commit}`], projectRoot, true);
+      if (resolvedCommit) {
+        console.log('📸 Commit Explanation\n');
+        console.log(explainFromCommit(resolvedCommit, projectRoot));
+        return;
+      }
     }
 
+    // Not a commit
+
     // Try partial match
-    const sessions = execSync('ls .shit-logs', { cwd: projectRoot, encoding: 'utf-8' })
-      .split('\n')
-      .filter(s => s.includes(target));
+    const logDir = join(projectRoot, '.shit-logs');
+    const sessions = existsSync(logDir)
+      ? readdirSync(logDir, { withFileTypes: true })
+        .filter(entry => entry.isDirectory() && SESSION_ID_REGEX.test(entry.name))
+        .map(entry => entry.name)
+        .filter(name => name.includes(target))
+      : [];
 
     if (sessions.length > 0) {
       const matchedSession = sessions[0];

package/lib/reset.js

@@ -5,20 +5,10 @@
  * Similar to 'entire reset' - removes shadow branch and session state
  */
 
-import { existsSync, readFileSync, rmSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
 
 function git(cmd, cwd) {
   return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
@@ -53,9 +43,11 @@ function findActiveSession(projectRoot) {
     return null;
   }
 
-  const { readdirSync, statSync } = require('fs');
   const sessions = readdirSync(shitLogsDir)
-    .filter(name => name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/))
+    .filter(name => {
+      const fullPath = join(shitLogsDir, name);
+      return SESSION_ID_REGEX.test(name) && statSync(fullPath).isDirectory();
+    })
     .map(name => ({
       name,
       path: join(shitLogsDir, name),
@@ -68,7 +60,7 @@ function findActiveSession(projectRoot) {
 
 export default async function reset(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const force = args.includes('--force') || args.includes('-f');
 
     // Get current commit
@@ -112,7 +104,7 @@ export default async function reset(args) {
           if (state.checkpoints && state.checkpoints.some(cp => cp.linked_commit === commitSha)) {
             // Remove checkpoint references
             state.checkpoints = state.checkpoints.filter(cp => cp.linked_commit !== commitSha);
-            require('fs').writeFileSync(stateFile, JSON.stringify(state, null, 2));
+            writeFileSync(stateFile, JSON.stringify(state, null, 2));
             console.log('✅ Updated session state');
           }
         } catch {

package/lib/resume.js

@@ -8,17 +8,8 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { execSync } from 'child_process';
-
-function findProjectRoot() {
-  let dir = process.cwd();
-  while (dir !== '/') {
-    if (existsSync(join(dir, '.git'))) {
-      return dir;
-    }
-    dir = join(dir, '..');
-  }
-  throw new Error('Not in a git repository');
-}
+import { randomUUID } from 'crypto';
+import { getProjectRoot } from './config.js';
 
 function git(cmd, cwd) {
   return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
@@ -26,19 +17,37 @@ function git(cmd, cwd) {
 
 function findCheckpoint(projectRoot, checkpointId) {
   try {
-    const branches = git('branch --list "shit/*"', projectRoot)
+    const branches = git('branch --list "shit/checkpoints/v1/*" "shit/*"', projectRoot)
       .split('\n')
       .map(b => b.trim().replace(/^\*?\s*/, ''))
       .filter(Boolean);
 
     for (const branch of branches) {
-      const match = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
-      if (match) {
-        const [, baseCommit, sessionShort] = match;
-        if (sessionShort.startsWith(checkpointId) || baseCommit.startsWith(checkpointId)) {
-          const log = git(`log ${branch} --oneline -1`, projectRoot);
-          const timestamp = git(`log ${branch} --format=%ci -1`, projectRoot);
+      const timestamp = git(`log ${branch} --format=%ci -1`, projectRoot);
+      const log = git(`log ${branch} --oneline -1`, projectRoot);
+
+      const checkpointMatch = branch.match(/^shit\/checkpoints\/v1\/(\d{4}-\d{2}-\d{2})-([a-f0-9]+)$/);
+      if (checkpointMatch) {
+        const branchKey = `${checkpointMatch[1]}-${checkpointMatch[2]}`;
+        const message = git(`log ${branch} --format=%B -1`, projectRoot);
+        const linkedMatch = message.match(/@ ([a-f0-9]+)/);
+        const baseCommit = linkedMatch ? linkedMatch[1] : null;
+
+        if (branchKey.startsWith(checkpointId) || checkpointMatch[2].startsWith(checkpointId) || (baseCommit && baseCommit.startsWith(checkpointId))) {
+          return {
+            branch,
+            baseCommit,
+            sessionShort: checkpointMatch[2],
+            timestamp,
+            message: log.split(' ').slice(1).join(' ')
+          };
+        }
+      }
 
+      const shadowMatch = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
+      if (shadowMatch) {
+        const [, baseCommit, sessionShort] = shadowMatch;
+        if (sessionShort.startsWith(checkpointId) || baseCommit.startsWith(checkpointId)) {
           return {
             branch,
             baseCommit,
@@ -116,11 +125,7 @@ function restoreSessionData(projectRoot, sessionData, newSessionId) {
 }
 
 function generateSessionId() {
-  const now = new Date();
-  const date = now.toISOString().split('T')[0]; // YYYY-MM-DD
-  const uuid = Math.random().toString(36).substring(2, 15) +
-               Math.random().toString(36).substring(2, 15);
-  return `${date}-${uuid}`;
+  return randomUUID();
 }
 
 function updateSessionState(sessionDir, checkpoint) {
@@ -149,7 +154,7 @@ function updateSessionState(sessionDir, checkpoint) {
 
 export default async function resume(args) {
   try {
-    const projectRoot = findProjectRoot();
+    const projectRoot = getProjectRoot();
     const checkpointId = args.find(arg => !arg.startsWith('-'));
 
     if (!checkpointId) {
@@ -164,19 +169,19 @@ export default async function resume(args) {
     const checkpoint = findCheckpoint(projectRoot, checkpointId);
     if (!checkpoint) {
       console.error(`❌ Checkpoint not found: ${checkpointId}`);
-      console.error('   Use "shit shadow" to list available checkpoints');
+      console.error('   Use "shit checkpoints" to list available checkpoints');
       process.exit(1);
     }
 
     console.log(`✅ Found checkpoint: ${checkpoint.sessionShort}`);
     console.log(`   Branch: ${checkpoint.branch}`);
-    console.log(`   Base commit: ${checkpoint.baseCommit}`);
+    console.log(`   Base commit: ${checkpoint.baseCommit || 'unknown'}`);
     console.log(`   Created: ${new Date(checkpoint.timestamp).toLocaleString()}`);
     console.log();
 
     // Check if we're already at the right commit
     const currentCommit = git('rev-parse HEAD', projectRoot);
-    if (!currentCommit.startsWith(checkpoint.baseCommit)) {
+    if (checkpoint.baseCommit && !currentCommit.startsWith(checkpoint.baseCommit)) {
       console.log(`🔄 Checking out base commit: ${checkpoint.baseCommit}`);
       git(`checkout ${checkpoint.baseCommit}`, projectRoot);
     }