@claudemini/ses-cli 1.4.3

package/lib/report.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+
+/**
+ * Report generation module.
+ * Produces summary.json (v2, bot-readable), summary.txt (human-readable),
+ * prompts.txt, context.md, and metadata.json from session state + semantic data.
+ * Reference: Entire CLI's checkpoint format
+ */
+
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Generate all report files for a session.
+ */
+export function generateReports(sessionDir, sessionId, state, intent, changes, classification) {
+  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);
+
+  writeSummaryJson(sessionDir, sessionId, state, intent, changes, classification, durationMin);
+  writeSummaryTxt(sessionDir, sessionId, state, intent, changes, classification, durationMin);
+  writePromptsTxt(sessionDir, state);
+  writeMetadataJson(sessionDir, sessionId, state, intent, classification, durationMin);
+  writeContextMd(sessionDir, sessionId, state, intent, changes, durationMin);
+}
+
+function writeSummaryJson(sessionDir, sessionId, state, intent, changes, classification, durationMin) {
+  const summary = {
+    version: '2.0',
+    session: {
+      id: sessionId,
+      start: state.start_time,
+      end: state.last_time,
+      duration_minutes: durationMin,
+      type: classification.type,
+      intent: intent.goal,
+      risk: classification.risk,
+      summary: classification.summary,
+    },
+    changes: {
+      files: changes.files
+        .filter(f => f.operations.some(op => op !== 'read'))
+        .map(f => ({
+          path: f.path,
+          category: f.category,
+          operations: f.operations.filter(op => op !== 'read'),
+          editCount: f.editCount,
+          editSummary: f.editSummary,
+        })),
+      summary: changes.summary,
+    },
+    activity: {
+      tools: state.tool_counts,
+      commands: changes.commands,
+      errors: state.errors,
+    },
+    review_hints: {
+      tests_run: classification.reviewHints.testsRun,
+      build_verified: classification.reviewHints.buildVerified,
+      files_without_tests: classification.reviewHints.filesWithoutTests,
+      large_change: classification.reviewHints.largeChange,
+      config_changed: classification.reviewHints.configChanged,
+      migration_added: classification.reviewHints.migrationAdded,
+    },
+    prompts: state.prompts.map(p => typeof p === 'string' ? p : { time: p.time, text: p.text, type: p.type }),
+    transcript: state.transcript_path,
+    model: state.model,
+    scope: intent.scope,
+  };
+  writeFileSync(join(sessionDir, 'summary.json'), JSON.stringify(summary, null, 2));
+}
+
+function writeSummaryTxt(sessionDir, sessionId, state, intent, changes, classification, durationMin) {
+  const lines = [];
+
+  // Header
+  lines.push(`# Session: ${sessionId.slice(0, 8)}...`);
+  lines.push(`Type: ${classification.type} | Risk: ${classification.risk} | Duration: ${durationMin}min`);
+  if (classification.summary) {
+    lines.push(`Summary: ${classification.summary}`);
+  }
+  lines.push('');
+
+  // Intent
+  if (intent.goal) {
+    lines.push('## Intent');
+    lines.push(`  Goal: ${intent.goal.slice(0, 200)}`);
+    if (intent.scope.length > 0) {
+      lines.push(`  Scope: ${intent.scope.join(', ')}`);
+    }
+    lines.push('');
+  }
+
+  // Changes
+  const modified = changes.files.filter(f => f.operations.some(op => op !== 'read'));
+  if (modified.length > 0) {
+    lines.push('## Changes');
+    for (const f of modified.slice(0, 20)) {
+      const ops = f.operations.filter(op => op !== 'read').join(',');
+      lines.push(`  [${f.category}] ${f.path} (${ops}${f.editCount > 0 ? ` x${f.editCount}` : ''})`);
+    }
+    if (modified.length > 20) {
+      lines.push(`  ... and ${modified.length - 20} more files`);
+    }
+    lines.push('');
+  }
+
+  // Tools
+  if (Object.keys(state.tool_counts).length > 0) {
+    lines.push('## Tools');
+    Object.entries(state.tool_counts)
+      .sort((a, b) => b[1] - a[1])
+      .forEach(([t, c]) => lines.push(`  ${t}: ${c}`));
+    lines.push('');
+  }
+
+  // Commands by category
+  const cmdEntries = Object.entries(changes.commands).filter(([, cmds]) => cmds.length > 0);
+  if (cmdEntries.length > 0) {
+    lines.push('## Commands');
+    for (const [cat, cmds] of cmdEntries) {
+      lines.push(`  [${cat}] ${cmds.slice(0, 5).join(' | ')}${cmds.length > 5 ? ` (+${cmds.length - 5})` : ''}`);
+    }
+    lines.push('');
+  }
+
+  // Review hints
+  const hints = classification.reviewHints;
+  lines.push('## Review Hints');
+  lines.push(`  Tests run: ${hints.testsRun ? 'YES' : 'NO'}`);
+  lines.push(`  Build verified: ${hints.buildVerified ? 'YES' : 'NO'}`);
+  if (hints.configChanged) lines.push('  WARNING: Config files changed');
+  if (hints.migrationAdded) lines.push('  WARNING: Database migration added');
+  if (hints.largeChange) lines.push('  WARNING: Large change (>10 files)');
+  if (hints.filesWithoutTests.length > 0) {
+    lines.push(`  Files without tests: ${hints.filesWithoutTests.slice(0, 5).join(', ')}`);
+  }
+  lines.push('');
+
+  // Errors
+  if (state.errors.length > 0) {
+    lines.push('## Errors');
+    state.errors.slice(-5).forEach(e => lines.push(`  [${e.tool}] ${(e.message || '').slice(0, 100)}`));
+    lines.push('');
+  }
+
+  // Prompts
+  if (state.prompts.length > 0) {
+    lines.push('## Prompts');
+    state.prompts.forEach(p => {
+      const text = typeof p === 'string' ? p : p.text;
+      lines.push(`  > ${text.slice(0, 120)}`);
+    });
+  }
+
+  writeFileSync(join(sessionDir, 'summary.txt'), lines.join('\n') + '\n');
+}
+
+function writePromptsTxt(sessionDir, state) {
+  if (state.prompts.length > 0) {
+    const promptLines = state.prompts
+      .map(p => {
+        const time = typeof p === 'string' ? '' : p.time;
+        const text = typeof p === 'string' ? p : p.text;
+        return time ? `=== ${time} ===\n${text}\n` : `${text}\n`;
+      })
+      .join('\n');
+    writeFileSync(join(sessionDir, 'prompts.txt'), promptLines);
+  }
+}
+
+function writeMetadataJson(sessionDir, sessionId, state, intent, classification, durationMin) {
+  writeFileSync(join(sessionDir, 'metadata.json'), JSON.stringify({
+    session_id: sessionId,
+    start_time: state.start_time,
+    last_updated: state.last_time,
+    duration_minutes: durationMin,
+    type: classification.type,
+    intent: intent.goal.slice(0, 200),
+    risk: classification.risk,
+    event_count: state.event_count,
+    tool_calls: Object.values(state.tool_counts).reduce((a, b) => a + b, 0),
+    files_touched: state.file_ops.write.length + state.file_ops.edit.length,
+    errors: state.errors.length,
+    scope: intent.scope,
+    last_hook_type: state.last_hook_type,
+    // Enhanced metadata for Entire-style tracking
+    transcript_path: state.transcript_path || null,
+    model: state.model || null,
+    cwd: state.cwd || null,
+  }, null, 2));
+}
+
+/**
+ * Write context.md - human-readable session context (Entire-style)
+ */
+function writeContextMd(sessionDir, sessionId, state, intent, changes, durationMin) {
+  const lines = [];
+
+  // Header
+  lines.push(`# Session Context: ${sessionId}`);
+  lines.push('');
+  lines.push(`**Started**: ${state.start_time ? new Date(state.start_time).toLocaleString() : 'unknown'}`);
+  lines.push(`**Ended**: ${state.last_time ? new Date(state.last_time).toLocaleString() : 'in progress'}`);
+  lines.push(`**Duration**: ${durationMin} minutes`);
+  lines.push(`**Model**: ${state.model || 'unknown'}`);
+  lines.push(`**Working Directory**: ${state.cwd || 'unknown'}`);
+  lines.push(`**Events**: ${state.event_count}`);
+  lines.push('');
+
+  // Transcript reference (Entire-style)
+  if (state.transcript_path) {
+    lines.push('## Transcript');
+    lines.push(`Full transcript available at: \`${state.transcript_path}\``);
+    lines.push('');
+  }
+
+  // User Prompts
+  if (state.prompts && state.prompts.length > 0) {
+    lines.push('## User Prompts');
+    lines.push('');
+    state.prompts.forEach((p, i) => {
+      const time = p.time ? new Date(p.time).toLocaleString() : '';
+      const text = typeof p === 'string' ? p : p.text;
+      const type = typeof p === 'object' && p.type ? ` [${p.type}]` : '';
+
+      lines.push(`### Prompt ${i + 1}${type}${time ? ` - ${time}` : ''}`);
+      lines.push('');
+      lines.push('```');
+      lines.push(text.slice(0, 2000));
+      lines.push('```');
+      lines.push('');
+    });
+  }
+
+  // Intent & Scope
+  if (intent.goal) {
+    lines.push('## Intent');
+    lines.push('');
+    lines.push(intent.goal);
+    lines.push('');
+  }
+
+  if (intent.scope && intent.scope.length > 0) {
+    lines.push('## Scope');
+    lines.push('');
+    intent.scope.forEach(s => lines.push(`- ${s}`));
+    lines.push('');
+  }
+
+  // Changes Summary
+  const modified = changes.files.filter(f => f.operations.some(op => op !== 'read'));
+  if (modified.length > 0) {
+    lines.push('## Files Changed');
+    lines.push('');
+    modified.slice(0, 30).forEach(f => {
+      const ops = f.operations.filter(op => op !== 'read').join(', ');
+      lines.push(`- \`${f.path}\` (${ops})`);
+    });
+    if (modified.length > 30) {
+      lines.push(`- ... and ${modified.length - 30} more files`);
+    }
+    lines.push('');
+  }
+
+  // Tool Usage
+  if (Object.keys(state.tool_counts).length > 0) {
+    lines.push('## Tool Usage');
+    lines.push('');
+    Object.entries(state.tool_counts)
+      .sort((a, b) => b[1] - a[1])
+      .forEach(([tool, count]) => {
+        lines.push(`- ${tool}: ${count}`);
+      });
+    lines.push('');
+  }
+
+  // Errors
+  if (state.errors.length > 0) {
+    lines.push('## Errors');
+    lines.push('');
+    state.errors.slice(0, 10).forEach(e => {
+      lines.push(`- **[${e.tool}]** ${(e.message || '').slice(0, 200)}`);
+    });
+    lines.push('');
+  }
+
+  // Footer
+  lines.push('---');
+  lines.push('');
+  lines.push(`*Generated by ses-cli at ${new Date().toISOString()}*`);
+  lines.push(`*See \`events.jsonl\` for complete event history*`);
+
+  writeFileSync(join(sessionDir, 'context.md'), lines.join('\n') + '\n');
+}

package/lib/reset.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * Reset - delete checkpoint for current HEAD commit
+ * Similar to 'entire reset' - removes shadow branch and session state
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
+
+function git(cmd, cwd) {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
+}
+
+function findCheckpointForCommit(projectRoot, commitSha) {
+  try {
+    const branches = git('branch --list "ses/checkpoints/v1/*"', projectRoot)
+      .split('\n')
+      .map(b => b.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
+
+    for (const branch of branches) {
+      try {
+        const log = git(`log ${branch} --oneline -1`, projectRoot);
+        if (log.includes(commitSha.slice(0, 12))) {
+          return branch;
+        }
+      } catch {
+        // Skip
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function findActiveSession(projectRoot) {
+  const sesLogsDir = join(projectRoot, '.ses-logs');
+  if (!existsSync(sesLogsDir)) {
+    return null;
+  }
+
+  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);
+
+  return sessions.length > 0 ? sessions[0] : null;
+}
+
+export default async function reset(args) {
+  try {
+    const projectRoot = getProjectRoot();
+    const force = args.includes('--force') || args.includes('-f');
+
+    // Get current commit
+    const commitSha = git('rev-parse HEAD', projectRoot);
+    const commitShort = commitSha.slice(0, 12);
+
+    console.log(`🔄 Resetting checkpoint for commit: ${commitShort}\n`);
+
+    // Find checkpoint for this commit
+    const branch = findCheckpointForCommit(projectRoot, commitSha);
+
+    if (!branch) {
+      console.log('ℹ️  No checkpoint found for current commit.');
+      console.log('   Checkpoints are created on git commit, not automatically on session start.');
+      process.exit(0);
+    }
+
+    console.log(`📸 Found checkpoint branch: ${branch}`);
+
+    if (!force) {
+      console.log('\n⚠️  This will delete the checkpoint and its branch.');
+      console.log('   Use --force to proceed without confirmation.');
+      process.exit(1);
+    }
+
+    // Delete the checkpoint branch
+    try {
+      git(`branch -D ${branch}`, projectRoot);
+      console.log(`✅ Deleted checkpoint branch: ${branch}`);
+    } catch {
+      console.log('ℹ️  Branch already deleted or not found');
+    }
+
+    // Optionally clean active session if it's linked to this commit
+    const activeSession = findActiveSession(projectRoot);
+    if (activeSession) {
+      const stateFile = join(activeSession.path, 'state.json');
+      if (existsSync(stateFile)) {
+        try {
+          const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+          if (state.checkpoints && state.checkpoints.some(cp => cp.linked_commit === commitSha)) {
+            // Remove checkpoint references
+            state.checkpoints = state.checkpoints.filter(cp => cp.linked_commit !== commitSha);
+            writeFileSync(stateFile, JSON.stringify(state, null, 2));
+            console.log('✅ Updated session state');
+          }
+        } catch {
+          // Best effort
+        }
+      }
+    }
+
+    console.log('\n✅ Reset complete!');
+
+  } catch (error) {
+    console.error('❌ Failed to reset:', error.message);
+    process.exit(1);
+  }
+}

package/lib/resume.js

@@ -0,0 +1,224 @@
+#!/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';
+import { randomUUID } from 'crypto';
+import { getProjectRoot } from './config.js';
+
+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 "ses/checkpoints/v1/*" "ses/*"', projectRoot)
+      .split('\n')
+      .map(b => b.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
+
+    for (const branch of branches) {
+      const timestamp = git(`log ${branch} --format=%ci -1`, projectRoot);
+      const log = git(`log ${branch} --oneline -1`, projectRoot);
+
+      const checkpointMatch = branch.match(/^ses\/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(/^ses\/([a-f0-9]+)-([a-f0-9]+)$/);
+      if (shadowMatch) {
+        const [, baseCommit, sessionShort] = shadowMatch;
+        if (sessionShort.startsWith(checkpointId) || baseCommit.startsWith(checkpointId)) {
+          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('.ses-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 sesLogsDir = join(projectRoot, '.ses-logs');
+  if (!existsSync(sesLogsDir)) {
+    mkdirSync(sesLogsDir, { recursive: true });
+  }
+
+  const sessionDir = join(sesLogsDir, 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(/^\.ses-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() {
+  return randomUUID();
+}
+
+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 = getProjectRoot();
+    const checkpointId = args.find(arg => !arg.startsWith('-'));
+
+    if (!checkpointId) {
+      console.error('❌ Please specify a checkpoint ID');
+      console.error('   Usage: ses resume <checkpoint-id>');
+      console.error('   Use "ses 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 "ses 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 || '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 (checkpoint.baseCommit && !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 "ses status" to verify session tracking');
+    console.log('   3. Use "ses view" to see session history');
+
+  } catch (error) {
+    console.error('❌ Failed to resume session:', error.message);
+    process.exit(1);
+  }
+}