@claudemini/ses-cli 1.4.3

package/lib/rewind.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+/**
+ * Rewind to previous checkpoint
+ * Similar to 'entire rewind' - rollback to known good state
+ */
+
+import { execSync } from 'child_process';
+import { getProjectRoot } from './config.js';
+
+function git(cmd, cwd) {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
+}
+
+function parseCheckpointRef(projectRoot, branch) {
+  const shadowMatch = branch.match(/^ses\/([a-f0-9]+)-([a-f0-9]+)$/);
+  if (shadowMatch) {
+    return {
+      type: 'shadow',
+      baseCommit: shadowMatch[1],
+      sessionShort: shadowMatch[2],
+      lookupKey: shadowMatch[2],
+    };
+  }
+
+  const checkpointMatch = branch.match(/^ses\/checkpoints\/v1\/(\d{4}-\d{2}-\d{2})-([a-f0-9]+)$/);
+  if (checkpointMatch) {
+    const message = git(`log ${branch} --format=%B -1`, projectRoot);
+    const linkedMatch = message.match(/@ ([a-f0-9]+)/);
+    const date = checkpointMatch[1];
+    const sessionShort = checkpointMatch[2];
+    return {
+      type: 'checkpoint',
+      baseCommit: linkedMatch ? linkedMatch[1] : null,
+      sessionShort,
+      lookupKey: `${date}-${sessionShort}`,
+    };
+  }
+
+  return null;
+}
+
+function listCheckpoints(projectRoot) {
+  try {
+    const branches = git('branch --list "ses/checkpoints/v1/*" "ses/*"', projectRoot)
+      .split('\n')
+      .map(b => b.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
+    const uniqueBranches = [...new Set(branches)];
+
+    const checkpoints = [];
+
+    for (const branch of uniqueBranches) {
+      try {
+        const parsed = parseCheckpointRef(projectRoot, branch);
+        if (!parsed) {
+          continue;
+        }
+
+        const log = git(`log ${branch} --oneline -1`, projectRoot);
+        const [commit, ...messageParts] = log.split(' ');
+        const message = messageParts.join(' ');
+        checkpoints.push({
+          branch,
+          commit,
+          baseCommit: parsed.baseCommit,
+          sessionShort: parsed.sessionShort,
+          lookupKey: parsed.lookupKey,
+          type: parsed.type,
+          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 (!checkpoint.baseCommit) {
+    throw new Error(`Checkpoint ${checkpoint.lookupKey || checkpoint.sessionShort} is missing a linked base commit`);
+  }
+
+  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 = getProjectRoot();
+    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 when you run "ses commit".');
+      process.exit(1);
+    }
+
+    if (checkpointArg) {
+      // Find specific checkpoint
+      targetCheckpoint = checkpoints.find(cp =>
+        cp.sessionShort.startsWith(checkpointArg) ||
+        cp.lookupKey.startsWith(checkpointArg) ||
+        (cp.baseCommit && 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();
+        const base = cp.baseCommit ? cp.baseCommit.slice(0, 7) : 'unknown';
+        const key = cp.lookupKey || cp.sessionShort;
+        console.log(`${i + 1}. ${key} (${base}) - ${date}`);
+        console.log(`   ${cp.message}`);
+        console.log();
+      });
+
+      // For now, just use the most recent
+      targetCheckpoint = checkpoints[0];
+      console.log(`Using most recent checkpoint: ${targetCheckpoint.lookupKey || targetCheckpoint.sessionShort}`);
+    } else {
+      // Use most recent checkpoint
+      targetCheckpoint = checkpoints[0];
+    }
+
+    const selectedKey = targetCheckpoint.lookupKey || targetCheckpoint.sessionShort;
+    console.log(`🔄 Rewinding to checkpoint: ${selectedKey}`);
+    console.log(`   Branch: ${targetCheckpoint.branch}`);
+    console.log(`   Base commit: ${targetCheckpoint.baseCommit || 'unknown'}`);
+    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(`   ses resume ${selectedKey}`);
+
+  } catch (error) {
+    console.error('❌ Failed to rewind:', error.message);
+    process.exit(1);
+  }
+}

package/lib/session.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+
+/**
+ * Session state management and cross-session index.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { toRelative } from './config.js';
+
+// --- State management ---
+
+const EMPTY_STATE = {
+  start_time: null,
+  last_time: null,
+  event_count: 0,
+  tool_counts: {},
+  file_ops: { read: [], write: [], edit: [], glob: [], grep: [] },
+  commands: [],
+  edits: [],
+  errors: [],
+  prompts: [],
+  last_hook_type: null,
+  shadow_branch: null,
+  // Enhanced fields for Entire-style tracking
+  transcript_path: null,
+  cwd: null,
+  model: null,
+};
+
+export function loadState(sessionDir) {
+  const stateFile = join(sessionDir, 'state.json');
+  if (!existsSync(stateFile)) {
+    return {
+      ...EMPTY_STATE,
+      file_ops: { read: [], write: [], edit: [], glob: [], grep: [] },
+      commands: [],
+      edits: [],
+      errors: [],
+      prompts: [],
+    };
+  }
+  try {
+    return JSON.parse(readFileSync(stateFile, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function saveState(sessionDir, state) {
+  writeFileSync(join(sessionDir, 'state.json'), JSON.stringify(state, null, 2));
+}
+
+// --- Event processing ---
+
+function addUnique(arr, val) {
+  if (val && !arr.includes(val)) arr.push(val);
+}
+
+export function processEvent(state, event, hookType, projectRoot) {
+  const now = new Date().toISOString();
+  state.event_count++;
+  state.last_hook_type = hookType;
+  state.last_time = now;
+  if (!state.start_time) state.start_time = now;
+
+  const toolName = event.tool_name;
+  const input = event.tool_input || {};
+
+  // User prompts - support both camelCase and kebab-case
+  if (hookType === 'user-prompt-submit' || hookType === 'UserPromptSubmit') {
+    // Extract prompt from various possible fields
+    let prompt = '';
+    if (event.prompt) {
+      prompt = typeof event.prompt === 'string' ? event.prompt :
+        event.prompt.text || event.prompt.message || JSON.stringify(event.prompt).slice(0, 500);
+    } else if (event.message) {
+      prompt = typeof event.message === 'string' ? event.message :
+        event.message.text || JSON.stringify(event.message).slice(0, 500);
+    } else if (event.text) {
+      prompt = event.text;
+    }
+
+    if (prompt) {
+      state.prompts.push({
+        time: now,
+        text: prompt.slice(0, 2000), // Limit prompt length
+        type: event.prompt_type || 'user'
+      });
+    }
+    return;
+  }
+
+  // Record transcript path from SessionStart
+  if (hookType === 'session-start' || hookType === 'SessionStart') {
+    if (event.transcript_path) {
+      state.transcript_path = event.transcript_path;
+    }
+    if (event.cwd) {
+      state.cwd = event.cwd;
+    }
+    if (event.model) {
+      state.model = event.model;
+    }
+    return;
+  }
+
+  // Mark session as ended for end/stop hooks.
+  if (hookType === 'session-end' || hookType === 'SessionEnd' || hookType === 'stop' || hookType === 'session_end' || hookType === 'end') {
+    state.end_time = now;
+    return;
+  }
+
+  // Tool events
+  if (hookType === 'post-tool-use' && toolName) {
+    state.tool_counts[toolName] = (state.tool_counts[toolName] || 0) + 1;
+
+    const rel = (p) => toRelative(projectRoot, p);
+
+    switch (toolName) {
+      case 'Read':
+        addUnique(state.file_ops.read, rel(input.file_path));
+        break;
+      case 'Write':
+        addUnique(state.file_ops.write, rel(input.file_path));
+        break;
+      case 'Edit':
+        addUnique(state.file_ops.edit, rel(input.file_path));
+        if (input.old_string || input.new_string) {
+          state.edits.push({
+            file: rel(input.file_path),
+            old: (input.old_string || '').slice(0, 200),
+            new: (input.new_string || '').slice(0, 200),
+          });
+        }
+        break;
+      case 'Glob':
+        addUnique(state.file_ops.glob, input.pattern);
+        break;
+      case 'Grep':
+        addUnique(state.file_ops.grep, input.pattern);
+        break;
+      case 'Bash':
+        if (input.command) state.commands.push(input.command.slice(0, 500));
+        break;
+    }
+
+    // Track errors
+    const result = event.tool_result;
+    if (result && typeof result === 'object' && result.isError) {
+      state.errors.push({
+        tool: toolName,
+        time: now,
+        message: (typeof result.content === 'string'
+          ? result.content : JSON.stringify(result.content)).slice(0, 300),
+      });
+    }
+  }
+}
+
+// --- Cross-session index ---
+
+export function updateIndex(logDir, sessionId, intent, classification, changes, state) {
+  const indexFile = join(logDir, 'index.json');
+  let index = { project: '', sessions: [], file_history: {} };
+
+  if (existsSync(indexFile)) {
+    try {
+      index = JSON.parse(readFileSync(indexFile, 'utf-8'));
+    } catch { /* start fresh */ }
+  }
+
+  // Detect project name from git or directory
+  if (!index.project) {
+    const parts = logDir.split('/');
+    // logDir is typically <project>/.ses-logs
+    index.project = parts[parts.length - 2] || 'unknown';
+  }
+
+  const durationMs = state.start_time && state.last_time
+    ? new Date(state.last_time) - new Date(state.start_time) : 0;
+  const durationMin = Math.round(durationMs / 60000);
+
+  // Upsert session entry
+  const modifiedFiles = changes.files
+    .filter(f => f.operations.some(op => op !== 'read'))
+    .map(f => f.path);
+
+  const existingIdx = index.sessions.findIndex(s => s.id === sessionId);
+  const sessionEntry = {
+    id: sessionId,
+    date: (state.start_time || new Date().toISOString()).slice(0, 10),
+    type: classification.type,
+    intent: intent.goal.slice(0, 200),
+    files: modifiedFiles,
+    duration: durationMin,
+    risk: classification.risk,
+  };
+
+  if (existingIdx >= 0) {
+    index.sessions[existingIdx] = sessionEntry;
+  } else {
+    index.sessions.push(sessionEntry);
+  }
+
+  // Keep last 100 sessions
+  if (index.sessions.length > 100) {
+    index.sessions = index.sessions.slice(-100);
+  }
+
+  // Update file history
+  if (!index.file_history) index.file_history = {};
+  for (const file of modifiedFiles) {
+    if (!index.file_history[file]) index.file_history[file] = [];
+    if (!index.file_history[file].includes(sessionId)) {
+      index.file_history[file].push(sessionId);
+    }
+    // Keep last 20 sessions per file
+    if (index.file_history[file].length > 20) {
+      index.file_history[file] = index.file_history[file].slice(-20);
+    }
+  }
+
+  writeFileSync(indexFile, JSON.stringify(index, null, 2));
+}

package/lib/shadow.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+import { getProjectRoot } from './config.js';
+
+export { commitShadow, listShadowBranches, shadowInfo } from './git-shadow.js';
+
+export default async function shadowCmd(args) {
+  const projectRoot = getProjectRoot();
+  const sub = args[0];
+
+  if (sub === 'info' && args[1]) {
+    const { shadowInfo } = await import('./git-shadow.js');
+    const info = shadowInfo(projectRoot, args[1]);
+    if (!info) {
+      console.error(`Branch not found: ${args[1]}`);
+      process.exit(1);
+    }
+    console.log('Recent commits:');
+    console.log(info.log);
+    console.log('\nFiles:');
+    info.files.forEach(f => console.log(`  ${f}`));
+    return;
+  }
+
+  // Default: list shadow branches
+  const { listShadowBranches } = await import('./git-shadow.js');
+  const branches = listShadowBranches(projectRoot);
+
+  if (branches.length === 0) {
+    console.log('No shadow branches found.');
+    console.log('Shadow branches are created on session-end.');
+    return;
+  }
+
+  console.log(`${branches.length} shadow branch(es):\n`);
+  branches.forEach(b => {
+    try {
+      const log = execSync(`git log ${b} --oneline -1`, {
+        cwd: projectRoot, encoding: 'utf-8',
+      }).trim();
+      console.log(`  ${b}  ${log}`);
+    } catch {
+      console.log(`  ${b}`);
+    }
+  });
+
+  console.log('\nUsage:');
+  console.log('  ses shadow info <branch>  # Show branch details');
+  console.log('  git log <branch> --oneline # View commits');
+}

package/lib/status.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+/**
+ * Show current session status
+ * Similar to 'entire status' - displays active session info
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
+
+function getCurrentSession(projectRoot) {
+  const sesLogsDir = join(projectRoot, '.ses-logs');
+  if (!existsSync(sesLogsDir)) {
+    return null;
+  }
+
+  // Find the most recent session directory
+  const sessions = readdirSync(sesLogsDir)
+    .filter(name => {
+      const fullPath = join(sesLogsDir, name);
+      return SESSION_ID_REGEX.test(name) && statSync(fullPath).isDirectory();
+    })
+    .map(name => ({
+      name,
+      path: join(sesLogsDir, name),
+      mtime: statSync(join(sesLogsDir, 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`;
+  }
+}
+
+function getTouchedFileCount(state) {
+  const ops = state?.file_ops;
+  if (!ops || typeof ops !== 'object') {
+    return 0;
+  }
+
+  const touched = new Set([
+    ...(Array.isArray(ops.write) ? ops.write : []),
+    ...(Array.isArray(ops.edit) ? ops.edit : []),
+    ...(Array.isArray(ops.read) ? ops.read : []),
+  ].filter(Boolean));
+
+  return touched.size;
+}
+
+function hasSesHooks(settings) {
+  if (!settings?.hooks || typeof settings.hooks !== 'object') {
+    return false;
+  }
+
+  return Object.values(settings.hooks).some(value => {
+    if (typeof value === 'string') {
+      return value.includes('ses log');
+    }
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    return value.some(entry =>
+      Array.isArray(entry?.hooks) &&
+      entry.hooks.some(hook => typeof hook?.command === 'string' && hook.command.includes('ses log'))
+    );
+  });
+}
+
+export default async function status(args) {
+  try {
+    const projectRoot = getProjectRoot();
+    const gitInfo = getGitInfo(projectRoot);
+    const currentSession = getCurrentSession(projectRoot);
+
+    console.log('📊 ses-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: ${getTouchedFileCount(state)}`);
+
+        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 "ses enable" to start tracking sessions');
+    }
+
+    // Check if ses-cli is enabled
+    const claudeSettings = join(projectRoot, '.claude', 'settings.json');
+    if (existsSync(claudeSettings)) {
+      try {
+        const settings = JSON.parse(readFileSync(claudeSettings, 'utf-8'));
+        const hasHooks = hasSesHooks(settings);
+
+        console.log();
+        if (hasHooks) {
+          console.log('✅ ses-cli: enabled and configured');
+        } else {
+          console.log('⚠️  ses-cli: not configured (run "ses enable")');
+        }
+      } catch {
+        console.log('⚠️  ses-cli: configuration error');
+      }
+    } else {
+      console.log();
+      console.log('❌ ses-cli: not enabled (run "ses enable")');
+    }
+
+  } catch (error) {
+    console.error('❌ Failed to get status:', error.message);
+    process.exit(1);
+  }
+}