@claudemini/shit-cli 1.0.3 → 1.1.0

package/.claude/settings.local.json

@@ -13,7 +13,8 @@
       "Bash(git add:*)",
       "Bash(git commit -m \"$\\(cat <<''EOF''\n更新包名和版本号\n\n- 包名改为 @cluademini/shit-cli\n- 版本号升至 1.0.3\nEOF\n\\)\")",
       "Bash(git commit:*)",
-      "Bash(npm config set:*)"
+      "Bash(npm config set:*)",
+      "WebFetch(domain:github.com)"
     ]
   }
 }

package/bin/shit.js

@@ -4,14 +4,20 @@ const args = process.argv.slice(2);
 const command = args[0];
 
 const commands = {
-  init:   'Initialize hooks in .claude/settings.json',
-  log:    'Log a hook event (called by hooks)',
-  list:   'List all sessions',
-  view:   'View session details',
-  query:  'Query session memory (cross-session)',
-  shadow: 'List shadow branches',
-  clean:  'Clean old sessions',
-  help:   'Show help',
+  enable:  'Enable shit-cli in repository',
+  disable: 'Remove shit-cli hooks',
+  status:  'Show current session status',
+  init:    'Initialize hooks in .claude/settings.json',
+  log:     'Log a hook event (called by hooks)',
+  list:    'List all sessions',
+  view:    'View session details',
+  query:   'Query session memory (cross-session)',
+  rewind:  'Rollback to previous checkpoint',
+  resume:  'Resume session from checkpoint',
+  doctor:  'Fix or clean stuck sessions',
+  shadow:  'List shadow branches',
+  clean:   'Clean old sessions',
+  help:    'Show help',
 };
 
 function showHelp() {
@@ -22,16 +28,17 @@ function showHelp() {
     console.log(`  ${cmd.padEnd(10)} ${desc}`);
   });
   console.log('\nExamples:');
-  console.log('  shit init                        # Register hooks');
+  console.log('  shit enable                      # Enable shit-cli in repo');
+  console.log('  shit status                      # Show current session');
   console.log('  shit list                        # List sessions');
   console.log('  shit view <session-id>           # View session');
-  console.log('  shit view <session-id> --json    # View with JSON data');
+  console.log('  shit rewind <checkpoint>         # Rollback to checkpoint');
+  console.log('  shit resume <checkpoint>         # Resume from checkpoint');
+  console.log('  shit doctor --fix                # Fix stuck sessions');
   console.log('  shit query --recent=5            # Recent 5 sessions');
   console.log('  shit query --file=src/app.ts     # Sessions that touched file');
-  console.log('  shit query --type=bugfix         # Filter by session type');
-  console.log('  shit query --risk=high --json    # High-risk sessions as JSON');
   console.log('  shit shadow                      # List shadow branches');
-  console.log('  shit clean --days=7              # Clean old sessions');
+  console.log('  shit disable --clean             # Remove shit-cli and data');
 }
 
 if (!command || command === 'help' || command === '--help') {

package/lib/disable.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * Disable shit-cli in repository
+ * Similar to 'entire disable' - removes hooks and optionally cleans data
+ */
+
+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');
+}
+
+function removeClaudeHooks(projectRoot) {
+  const settingsFile = join(projectRoot, '.claude', 'settings.json');
+
+  if (!existsSync(settingsFile)) {
+    return false;
+  }
+
+  try {
+    const settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+
+    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;
+
+      // If hooks object is empty, remove it
+      if (Object.keys(settings.hooks).length === 0) {
+        delete settings.hooks;
+      }
+    }
+
+    writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removeFromGitignore(projectRoot) {
+  const gitignoreFile = join(projectRoot, '.gitignore');
+
+  if (!existsSync(gitignoreFile)) {
+    return false;
+  }
+
+  try {
+    let gitignore = readFileSync(gitignoreFile, 'utf-8');
+    const lines = gitignore.split('\n');
+    const filtered = lines.filter(line => !line.trim().startsWith('.shit-logs'));
+
+    if (filtered.length !== lines.length) {
+      writeFileSync(gitignoreFile, filtered.join('\n'));
+      return true;
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  return false;
+}
+
+export default async function disable(args) {
+  try {
+    const projectRoot = findProjectRoot();
+    const cleanData = args.includes('--clean') || args.includes('--purge');
+
+    console.log('🔧 Disabling shit-cli in repository...');
+
+    // Remove Claude Code hooks
+    const hooksRemoved = removeClaudeHooks(projectRoot);
+    if (hooksRemoved) {
+      console.log('✅ Removed Claude hooks from .claude/settings.json');
+    } else {
+      console.log('ℹ️  No Claude hooks found to remove');
+    }
+
+    // Remove from .gitignore
+    const gitignoreUpdated = removeFromGitignore(projectRoot);
+    if (gitignoreUpdated) {
+      console.log('✅ Removed .shit-logs from .gitignore');
+    }
+
+    // Optionally clean data
+    if (cleanData) {
+      const shitLogsDir = join(projectRoot, '.shit-logs');
+      if (existsSync(shitLogsDir)) {
+        rmSync(shitLogsDir, { recursive: true, force: true });
+        console.log('✅ Removed .shit-logs directory');
+      }
+    }
+
+    console.log('\n🎉 shit-cli disabled successfully!');
+
+    if (!cleanData) {
+      console.log('\nNote: .shit-logs directory preserved.');
+      console.log('Use "shit disable --clean" to remove all data.');
+    }
+
+  } catch (error) {
+    console.error('❌ Failed to disable shit-cli:', error.message);
+    process.exit(1);
+  }
+}

package/lib/doctor.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+/**
+ * Doctor command - fix or clean stuck sessions
+ * Similar to 'entire doctor' - repairs corrupted state and cleans up
+ */
+
+import { existsSync, readFileSync, writeFileSync, rmSync, 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');
+}
+
+function git(cmd, cwd) {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
+}
+
+function checkShitLogsStructure(projectRoot) {
+  const issues = [];
+  const shitLogsDir = join(projectRoot, '.shit-logs');
+
+  if (!existsSync(shitLogsDir)) {
+    issues.push({
+      type: 'missing_directory',
+      message: '.shit-logs directory not found',
+      fix: () => {
+        const { mkdirSync } = require('fs');
+        mkdirSync(shitLogsDir, { recursive: true });
+        return 'Created .shit-logs directory';
+      }
+    });
+    return issues;
+  }
+
+  // Check index.json
+  const indexFile = join(shitLogsDir, 'index.json');
+  if (!existsSync(indexFile)) {
+    issues.push({
+      type: 'missing_index',
+      message: 'index.json not found',
+      fix: () => {
+        const initialIndex = {
+          version: 2,
+          sessions: [],
+          files: {},
+          created: new Date().toISOString()
+        };
+        writeFileSync(indexFile, JSON.stringify(initialIndex, null, 2));
+        return 'Created index.json';
+      }
+    });
+  } else {
+    try {
+      JSON.parse(readFileSync(indexFile, 'utf-8'));
+    } catch {
+      issues.push({
+        type: 'corrupted_index',
+        message: 'index.json is corrupted',
+        fix: () => {
+          const backup = `${indexFile}.backup.${Date.now()}`;
+          const { copyFileSync } = require('fs');
+          copyFileSync(indexFile, backup);
+
+          const initialIndex = {
+            version: 2,
+            sessions: [],
+            files: {},
+            created: new Date().toISOString(),
+            recovered: true
+          };
+          writeFileSync(indexFile, JSON.stringify(initialIndex, null, 2));
+          return `Recreated index.json (backup saved as ${backup})`;
+        }
+      });
+    }
+  }
+
+  return issues;
+}
+
+function checkSessionDirectories(projectRoot) {
+  const issues = [];
+  const shitLogsDir = join(projectRoot, '.shit-logs');
+
+  if (!existsSync(shitLogsDir)) {
+    return issues;
+  }
+
+  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-]+$/);
+  });
+
+  for (const sessionDir of sessionDirs) {
+    const sessionPath = join(shitLogsDir, sessionDir);
+    const stateFile = join(sessionPath, 'state.json');
+
+    if (!existsSync(stateFile)) {
+      issues.push({
+        type: 'missing_state',
+        message: `Session ${sessionDir} missing state.json`,
+        sessionDir,
+        fix: () => {
+          const defaultState = {
+            session_id: sessionDir,
+            start_time: new Date().toISOString(),
+            event_count: 0,
+            files: {},
+            recovered: true
+          };
+          writeFileSync(stateFile, JSON.stringify(defaultState, null, 2));
+          return `Created state.json for ${sessionDir}`;
+        }
+      });
+    } else {
+      try {
+        JSON.parse(readFileSync(stateFile, 'utf-8'));
+      } catch {
+        issues.push({
+          type: 'corrupted_state',
+          message: `Session ${sessionDir} has corrupted state.json`,
+          sessionDir,
+          fix: () => {
+            const backup = `${stateFile}.backup.${Date.now()}`;
+            const { copyFileSync } = require('fs');
+            copyFileSync(stateFile, backup);
+
+            const defaultState = {
+              session_id: sessionDir,
+              start_time: new Date().toISOString(),
+              event_count: 0,
+              files: {},
+              recovered: true
+            };
+            writeFileSync(stateFile, JSON.stringify(defaultState, null, 2));
+            return `Recreated state.json for ${sessionDir} (backup: ${backup})`;
+          }
+        });
+      }
+    }
+  }
+
+  return issues;
+}
+
+function checkOrphanedShadowBranches(projectRoot) {
+  const issues = [];
+  const shitLogsDir = join(projectRoot, '.shit-logs');
+
+  try {
+    const branches = git('branch --list "shit/*"', projectRoot)
+      .split('\n')
+      .map(b => b.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
+
+    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-]+$/);
+      }) : [];
+
+    for (const branch of branches) {
+      const match = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
+      if (match) {
+        const [, baseCommit, sessionShort] = match;
+
+        // Check if corresponding session exists
+        const hasSession = sessionDirs.some(dir => dir.includes(sessionShort));
+
+        if (!hasSession) {
+          issues.push({
+            type: 'orphaned_shadow',
+            message: `Orphaned shadow branch: ${branch}`,
+            branch,
+            fix: () => {
+              git(`branch -D ${branch}`, projectRoot);
+              return `Deleted orphaned shadow branch: ${branch}`;
+            }
+          });
+        }
+      }
+    }
+  } catch {
+    // Git operations failed, skip shadow branch check
+  }
+
+  return issues;
+}
+
+function checkStuckSessions(projectRoot) {
+  const issues = [];
+  const shitLogsDir = join(projectRoot, '.shit-logs');
+
+  if (!existsSync(shitLogsDir)) {
+    return issues;
+  }
+
+  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-]+$/);
+  });
+
+  const now = new Date();
+  const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+
+  for (const sessionDir of sessionDirs) {
+    const sessionPath = join(shitLogsDir, sessionDir);
+    const stateFile = join(sessionPath, 'state.json');
+
+    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) {
+          issues.push({
+            type: 'stuck_session',
+            message: `Stuck session: ${sessionDir} (started ${startTime.toLocaleString()})`,
+            sessionDir,
+            fix: () => {
+              state.end_time = new Date().toISOString();
+              state.stuck_session_recovered = true;
+              writeFileSync(stateFile, JSON.stringify(state, null, 2));
+              return `Marked stuck session as ended: ${sessionDir}`;
+            }
+          });
+        }
+      } catch {
+        // Already handled by checkSessionDirectories
+      }
+    }
+  }
+
+  return issues;
+}
+
+export default async function doctor(args) {
+  try {
+    const projectRoot = findProjectRoot();
+    const autoFix = args.includes('--fix') || args.includes('--auto-fix');
+    const verbose = args.includes('--verbose') || args.includes('-v');
+
+    console.log('🩺 Running shit-cli diagnostics...\n');
+
+    // Collect all issues
+    const allIssues = [
+      ...checkShitLogsStructure(projectRoot),
+      ...checkSessionDirectories(projectRoot),
+      ...checkOrphanedShadowBranches(projectRoot),
+      ...checkStuckSessions(projectRoot)
+    ];
+
+    if (allIssues.length === 0) {
+      console.log('✅ No issues found! shit-cli is healthy.');
+      return;
+    }
+
+    console.log(`🔍 Found ${allIssues.length} issue(s):\n`);
+
+    let fixedCount = 0;
+    for (const [index, issue] of allIssues.entries()) {
+      const prefix = `${index + 1}.`;
+      console.log(`${prefix} ${issue.message}`);
+
+      if (verbose) {
+        console.log(`   Type: ${issue.type}`);
+        if (issue.sessionDir) {
+          console.log(`   Session: ${issue.sessionDir}`);
+        }
+        if (issue.branch) {
+          console.log(`   Branch: ${issue.branch}`);
+        }
+      }
+
+      if (autoFix && issue.fix) {
+        try {
+          const result = issue.fix();
+          console.log(`   ✅ Fixed: ${result}`);
+          fixedCount++;
+        } catch (error) {
+          console.log(`   ❌ Fix failed: ${error.message}`);
+        }
+      }
+
+      console.log();
+    }
+
+    if (autoFix) {
+      console.log(`🎉 Fixed ${fixedCount}/${allIssues.length} issues.`);
+      if (fixedCount < allIssues.length) {
+        console.log('   Some issues could not be automatically fixed.');
+      }
+    } else {
+      console.log('💡 To automatically fix these issues, run:');
+      console.log('   shit doctor --fix');
+    }
+
+  } catch (error) {
+    console.error('❌ Doctor failed:', error.message);
+    process.exit(1);
+  }
+}

package/lib/enable.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+/**
+ * Enable shit-cli in repository
+ * Similar to 'entire enable' - sets up hooks and configuration
+ */
+
+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');
+}
+
+function setupClaudeHooks(projectRoot) {
+  const claudeDir = join(projectRoot, '.claude');
+  const settingsFile = join(claudeDir, 'settings.json');
+
+  // Create .claude directory if it doesn't exist
+  if (!existsSync(claudeDir)) {
+    mkdirSync(claudeDir, { recursive: true });
+  }
+
+  let settings = {};
+  if (existsSync(settingsFile)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+    } catch {
+      // Invalid JSON, start fresh
+    }
+  }
+
+  // Add shit-cli hooks
+  if (!settings.hooks) settings.hooks = {};
+
+  settings.hooks.session_start = 'shit log session_start';
+  settings.hooks.session_end = 'shit log session_end';
+  settings.hooks.tool_use = 'shit log tool_use';
+  settings.hooks.edit_applied = 'shit log edit_applied';
+
+  writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+  return settingsFile;
+}
+
+function initializeShitLogs(projectRoot) {
+  const shitDir = join(projectRoot, '.shit-logs');
+  if (!existsSync(shitDir)) {
+    mkdirSync(shitDir, { recursive: true });
+  }
+
+  // Create index.json if it doesn't exist
+  const indexFile = join(shitDir, 'index.json');
+  if (!existsSync(indexFile)) {
+    const initialIndex = {
+      version: 2,
+      sessions: [],
+      files: {},
+      created: new Date().toISOString()
+    };
+    writeFileSync(indexFile, JSON.stringify(initialIndex, null, 2));
+  }
+}
+
+export default async function enable(args) {
+  try {
+    const projectRoot = findProjectRoot();
+
+    console.log('🔧 Enabling shit-cli in repository...');
+
+    // Setup Claude Code hooks
+    const settingsFile = setupClaudeHooks(projectRoot);
+    console.log(`✅ Updated Claude hooks in ${settingsFile}`);
+
+    // Initialize .shit-logs directory
+    initializeShitLogs(projectRoot);
+    console.log('✅ Initialized .shit-logs directory');
+
+    // Add .shit-logs to .gitignore if not already there
+    const gitignoreFile = join(projectRoot, '.gitignore');
+    let gitignore = '';
+    if (existsSync(gitignoreFile)) {
+      gitignore = readFileSync(gitignoreFile, 'utf-8');
+    }
+
+    if (!gitignore.includes('.shit-logs')) {
+      const newLine = gitignore.endsWith('\n') || gitignore === '' ? '' : '\n';
+      writeFileSync(gitignoreFile, gitignore + newLine + '.shit-logs/\n');
+      console.log('✅ Added .shit-logs to .gitignore');
+    }
+
+    console.log('\n🎉 shit-cli enabled successfully!');
+    console.log('\nNext steps:');
+    console.log('  1. Start a Claude Code session');
+    console.log('  2. Use "shit status" to check session tracking');
+    console.log('  3. Use "shit list" to view logged sessions');
+
+  } catch (error) {
+    console.error('❌ Failed to enable shit-cli:', error.message);
+    process.exit(1);
+  }
+}

package/lib/resume.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+/**
+ * Resume session from checkpoint
+ * Similar to 'entire resume' - restore branch and session metadata
+ */
+
+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');
+}
+
+function git(cmd, cwd) {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
+}
+
+function findCheckpoint(projectRoot, checkpointId) {
+  try {
+    const branches = git('branch --list "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);
+
+          return {
+            branch,
+            baseCommit,
+            sessionShort,
+            timestamp,
+            message: log.split(' ').slice(1).join(' ')
+          };
+        }
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function extractSessionFromShadow(projectRoot, checkpoint) {
+  try {
+    // Get files from shadow branch
+    const files = git(`ls-tree -r --name-only ${checkpoint.branch}`, projectRoot)
+      .split('\n')
+      .filter(Boolean);
+
+    const sessionData = {};
+
+    for (const file of files) {
+      if (file.startsWith('.shit-logs/')) {
+        try {
+          const content = git(`show ${checkpoint.branch}:${file}`, projectRoot);
+          sessionData[file] = content;
+        } catch {
+          // Skip files that can't be read
+        }
+      }
+    }
+
+    return sessionData;
+  } catch {
+    return {};
+  }
+}
+
+function restoreSessionData(projectRoot, sessionData, newSessionId) {
+  const shitLogsDir = join(projectRoot, '.shit-logs');
+  if (!existsSync(shitLogsDir)) {
+    mkdirSync(shitLogsDir, { recursive: true });
+  }
+
+  const sessionDir = join(shitLogsDir, newSessionId);
+  if (!existsSync(sessionDir)) {
+    mkdirSync(sessionDir, { recursive: true });
+  }
+
+  let restoredFiles = 0;
+
+  for (const [filePath, content] of Object.entries(sessionData)) {
+    // Extract relative path within session
+    const match = filePath.match(/^\.shit-logs\/[^/]+\/(.+)$/);
+    if (match) {
+      const relativePath = match[1];
+      const targetPath = join(sessionDir, relativePath);
+
+      // Create directory if needed
+      const targetDir = join(targetPath, '..');
+      if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+      }
+
+      writeFileSync(targetPath, content);
+      restoredFiles++;
+    }
+  }
+
+  return { sessionDir, restoredFiles };
+}
+
+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}`;
+}
+
+function updateSessionState(sessionDir, checkpoint) {
+  const stateFile = join(sessionDir, 'state.json');
+
+  let state = {};
+  if (existsSync(stateFile)) {
+    try {
+      state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+    } catch {
+      // Invalid JSON, start fresh
+    }
+  }
+
+  // Update state for resumed session
+  state.resumed_from = checkpoint.sessionShort;
+  state.resumed_at = new Date().toISOString();
+  state.original_checkpoint = checkpoint.branch;
+
+  // Reset some fields for new session
+  delete state.end_time;
+  delete state.shadow_branch;
+
+  writeFileSync(stateFile, JSON.stringify(state, null, 2));
+}
+
+export default async function resume(args) {
+  try {
+    const projectRoot = findProjectRoot();
+    const checkpointId = args.find(arg => !arg.startsWith('-'));
+
+    if (!checkpointId) {
+      console.error('❌ Please specify a checkpoint ID');
+      console.error('   Usage: shit resume <checkpoint-id>');
+      console.error('   Use "shit list" to see available checkpoints');
+      process.exit(1);
+    }
+
+    console.log(`🔍 Looking for checkpoint: ${checkpointId}`);
+
+    const checkpoint = findCheckpoint(projectRoot, checkpointId);
+    if (!checkpoint) {
+      console.error(`❌ Checkpoint not found: ${checkpointId}`);
+      console.error('   Use "shit shadow" 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(`   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)) {
+      console.log(`🔄 Checking out base commit: ${checkpoint.baseCommit}`);
+      git(`checkout ${checkpoint.baseCommit}`, projectRoot);
+    }
+
+    // Extract session data from shadow branch
+    console.log('📦 Extracting session data from shadow branch...');
+    const sessionData = extractSessionFromShadow(projectRoot, checkpoint);
+
+    if (Object.keys(sessionData).length === 0) {
+      console.error('❌ No session data found in shadow branch');
+      process.exit(1);
+    }
+
+    // Create new session ID for resumed session
+    const newSessionId = generateSessionId();
+    console.log(`🆕 Creating new session: ${newSessionId}`);
+
+    // Restore session data
+    const { sessionDir, restoredFiles } = restoreSessionData(projectRoot, sessionData, newSessionId);
+    console.log(`✅ Restored ${restoredFiles} files to ${sessionDir}`);
+
+    // Update session state
+    updateSessionState(sessionDir, checkpoint);
+    console.log('✅ Updated session state');
+
+    console.log();
+    console.log('🎉 Session resumed successfully!');
+    console.log(`   New session ID: ${newSessionId}`);
+    console.log(`   Resumed from: ${checkpoint.sessionShort}`);
+    console.log();
+    console.log('💡 Next steps:');
+    console.log('   1. Start Claude Code to continue the session');
+    console.log('   2. Use "shit status" to verify session tracking');
+    console.log('   3. Use "shit view" to see session history');
+
+  } catch (error) {
+    console.error('❌ Failed to resume session:', error.message);
+    process.exit(1);
+  }
+}

package/lib/rewind.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+/**
+ * Rewind to previous checkpoint
+ * Similar to 'entire rewind' - rollback to known good state
+ */
+
+import { existsSync, readFileSync, 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');
+}
+
+function git(cmd, cwd) {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
+}
+
+function listCheckpoints(projectRoot) {
+  try {
+    // Get shadow branches
+    const branches = git('branch --list "shit/*"', projectRoot)
+      .split('\n')
+      .map(b => b.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
+
+    const checkpoints = [];
+
+    for (const branch of branches) {
+      try {
+        const log = git(`log ${branch} --oneline -1`, projectRoot);
+        const [commit, ...messageParts] = log.split(' ');
+        const message = messageParts.join(' ');
+
+        // Extract session info from branch name: shit/<commit>-<session>
+        const match = branch.match(/^shit\/([a-f0-9]+)-([a-f0-9]+)$/);
+        if (match) {
+          const [, baseCommit, sessionShort] = match;
+          checkpoints.push({
+            branch,
+            commit,
+            baseCommit,
+            sessionShort,
+            message,
+            timestamp: git(`log ${branch} --format=%ci -1`, projectRoot)
+          });
+        }
+      } catch {
+        // Skip invalid branches
+      }
+    }
+
+    return checkpoints.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+  } catch {
+    return [];
+  }
+}
+
+function getCurrentCommit(projectRoot) {
+  try {
+    return git('rev-parse HEAD', projectRoot);
+  } catch {
+    return null;
+  }
+}
+
+function hasUncommittedChanges(projectRoot) {
+  try {
+    const status = git('status --porcelain', projectRoot);
+    return status.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function rewindToCheckpoint(projectRoot, checkpoint, force = false) {
+  const currentCommit = getCurrentCommit(projectRoot);
+
+  if (!force && hasUncommittedChanges(projectRoot)) {
+    throw new Error('Working directory has uncommitted changes. Use --force to override or commit changes first.');
+  }
+
+  // Reset to the base commit of the checkpoint
+  git(`reset --hard ${checkpoint.baseCommit}`, projectRoot);
+
+  console.log(`✅ Rewound to checkpoint ${checkpoint.sessionShort}`);
+  console.log(`   Base commit: ${checkpoint.baseCommit}`);
+  console.log(`   Previous HEAD: ${currentCommit}`);
+
+  return currentCommit;
+}
+
+export default async function rewind(args) {
+  try {
+    const projectRoot = findProjectRoot();
+    const force = args.includes('--force') || args.includes('-f');
+    const interactive = args.includes('--interactive') || args.includes('-i');
+
+    // Get target checkpoint
+    let targetCheckpoint = null;
+    const checkpointArg = args.find(arg => !arg.startsWith('-'));
+
+    const checkpoints = listCheckpoints(projectRoot);
+
+    if (checkpoints.length === 0) {
+      console.log('❌ No checkpoints found');
+      console.log('   Checkpoints are created automatically when sessions end.');
+      process.exit(1);
+    }
+
+    if (checkpointArg) {
+      // Find specific checkpoint
+      targetCheckpoint = checkpoints.find(cp =>
+        cp.sessionShort.startsWith(checkpointArg) ||
+        cp.baseCommit.startsWith(checkpointArg)
+      );
+
+      if (!targetCheckpoint) {
+        console.error(`❌ Checkpoint not found: ${checkpointArg}`);
+        process.exit(1);
+      }
+    } else if (interactive) {
+      // Interactive selection
+      console.log('📋 Available checkpoints:\n');
+      checkpoints.forEach((cp, i) => {
+        const date = new Date(cp.timestamp).toLocaleString();
+        console.log(`${i + 1}. ${cp.sessionShort} (${cp.baseCommit.slice(0, 7)}) - ${date}`);
+        console.log(`   ${cp.message}`);
+        console.log();
+      });
+
+      // For now, just use the most recent
+      targetCheckpoint = checkpoints[0];
+      console.log(`Using most recent checkpoint: ${targetCheckpoint.sessionShort}`);
+    } else {
+      // Use most recent checkpoint
+      targetCheckpoint = checkpoints[0];
+    }
+
+    console.log(`🔄 Rewinding to checkpoint: ${targetCheckpoint.sessionShort}`);
+    console.log(`   Branch: ${targetCheckpoint.branch}`);
+    console.log(`   Base commit: ${targetCheckpoint.baseCommit}`);
+    console.log(`   Created: ${new Date(targetCheckpoint.timestamp).toLocaleString()}`);
+    console.log();
+
+    if (!force && hasUncommittedChanges(projectRoot)) {
+      console.error('❌ Working directory has uncommitted changes.');
+      console.error('   Commit your changes or use --force to discard them.');
+      process.exit(1);
+    }
+
+    const previousCommit = rewindToCheckpoint(projectRoot, targetCheckpoint, force);
+
+    console.log();
+    console.log('💡 To undo this rewind:');
+    console.log(`   git reset --hard ${previousCommit}`);
+    console.log();
+    console.log('💡 To resume from this checkpoint:');
+    console.log(`   shit resume ${targetCheckpoint.sessionShort}`);
+
+  } catch (error) {
+    console.error('❌ Failed to rewind:', error.message);
+    process.exit(1);
+  }
+}

package/lib/status.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+
+/**
+ * Show current session status
+ * Similar to 'entire status' - displays active session info
+ */
+
+import { existsSync, readFileSync } 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');
+}
+
+function getCurrentSession(projectRoot) {
+  const shitLogsDir = join(projectRoot, '.shit-logs');
+  if (!existsSync(shitLogsDir)) {
+    return null;
+  }
+
+  // Find the most recent session directory
+  const { readdirSync, statSync } = await import('fs');
+  const sessions = readdirSync(shitLogsDir)
+    .filter(name => name.match(/^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/)) // session format
+    .map(name => ({
+      name,
+      path: join(shitLogsDir, name),
+      mtime: statSync(join(shitLogsDir, name)).mtime
+    }))
+    .sort((a, b) => b.mtime - a.mtime);
+
+  if (sessions.length === 0) {
+    return null;
+  }
+
+  const latestSession = sessions[0];
+  const stateFile = join(latestSession.path, 'state.json');
+
+  if (!existsSync(stateFile)) {
+    return { ...latestSession, state: null };
+  }
+
+  try {
+    const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+    return { ...latestSession, state };
+  } catch {
+    return { ...latestSession, state: null };
+  }
+}
+
+function getGitInfo(projectRoot) {
+  try {
+    const branch = execSync('git branch --show-current', { cwd: projectRoot, encoding: 'utf-8' }).trim();
+    const commit = execSync('git rev-parse --short HEAD', { cwd: projectRoot, encoding: 'utf-8' }).trim();
+    const status = execSync('git status --porcelain', { cwd: projectRoot, encoding: 'utf-8' }).trim();
+
+    return {
+      branch,
+      commit,
+      dirty: status.length > 0,
+      changes: status.split('\n').filter(Boolean).length
+    };
+  } catch {
+    return null;
+  }
+}
+
+function formatDuration(startTime) {
+  if (!startTime) return 'unknown';
+
+  const start = new Date(startTime);
+  const now = new Date();
+  const diff = now - start;
+
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  } else {
+    return `${minutes}m`;
+  }
+}
+
+export default async function status(args) {
+  try {
+    const projectRoot = findProjectRoot();
+    const gitInfo = getGitInfo(projectRoot);
+    const currentSession = await getCurrentSession(projectRoot);
+
+    console.log('📊 shit-cli Status\n');
+
+    // Git info
+    if (gitInfo) {
+      console.log(`📂 Repository: ${gitInfo.branch} @ ${gitInfo.commit}`);
+      if (gitInfo.dirty) {
+        console.log(`⚠️  Working tree: ${gitInfo.changes} uncommitted changes`);
+      } else {
+        console.log('✅ Working tree: clean');
+      }
+    } else {
+      console.log('❌ Git repository: not found');
+    }
+
+    console.log();
+
+    // Session info
+    if (currentSession) {
+      console.log(`🎯 Current Session: ${currentSession.name}`);
+
+      if (currentSession.state) {
+        const state = currentSession.state;
+        console.log(`   Started: ${new Date(state.start_time).toLocaleString()}`);
+        console.log(`   Duration: ${formatDuration(state.start_time)}`);
+        console.log(`   Events: ${state.event_count || 0}`);
+        console.log(`   Files: ${Object.keys(state.files || {}).length}`);
+
+        if (state.shadow_branch) {
+          console.log(`   Shadow: ${state.shadow_branch}`);
+        }
+
+        if (state.session_type) {
+          console.log(`   Type: ${state.session_type}`);
+        }
+
+        if (state.risk_level) {
+          const riskEmoji = state.risk_level === 'high' ? '🔴' :
+                           state.risk_level === 'medium' ? '🟡' : '🟢';
+          console.log(`   Risk: ${riskEmoji} ${state.risk_level}`);
+        }
+      } else {
+        console.log('   State: no state file found');
+      }
+    } else {
+      console.log('💤 No active session found');
+      console.log('   Run "shit enable" to start tracking sessions');
+    }
+
+    // Check if shit-cli is enabled
+    const claudeSettings = join(projectRoot, '.claude', 'settings.json');
+    if (existsSync(claudeSettings)) {
+      try {
+        const settings = JSON.parse(readFileSync(claudeSettings, 'utf-8'));
+        const hasHooks = settings.hooks &&
+          (settings.hooks.session_start || settings.hooks.session_end);
+
+        console.log();
+        if (hasHooks) {
+          console.log('✅ shit-cli: enabled and configured');
+        } else {
+          console.log('⚠️  shit-cli: not configured (run "shit enable")');
+        }
+      } catch {
+        console.log('⚠️  shit-cli: configuration error');
+      }
+    } else {
+      console.log();
+      console.log('❌ shit-cli: not enabled (run "shit enable")');
+    }
+
+  } catch (error) {
+    console.error('❌ Failed to get status:', error.message);
+    process.exit(1);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claudemini/shit-cli",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "Session-based Hook Intelligence Tracker - CLI tool for logging Claude Code hooks",
   "type": "module",
   "bin": {