@claudemini/ses-cli 1.4.3

package/lib/checkpoint.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+
+/**
+ * Checkpoint module - manages checkpoints on git commit
+ * Inspired by Entire's approach:
+ *   - Branch: ses/checkpoints/v1/YYYY-MM-DD-<uuid>
+ *   - Each checkpoint is a commit linked to a code commit
+ *   - Supports multiple agents (Claude Code, Gemini CLI, Cursor, etc.)
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { join, dirname } from 'path';
+import { redactSecrets } from './redact.js';
+
+function git(cmd, cwd) {
+  return execSync(`git ${cmd}`, { cwd, encoding: 'utf-8', timeout: 10000 }).trim();
+}
+
+function gitRaw(cmd, cwd, input) {
+  return execSync(`git ${cmd}`, {
+    cwd, encoding: 'utf-8', timeout: 10000,
+    input,
+  }).trim();
+}
+
+/**
+ * Detect which agent is running based on environment/hooks
+ */
+export function detectAgent() {
+  // Check for Claude Code
+  if (process.env.CLAUDE_AGENT_ID || process.env.CLAUDE_SESSION_ID) {
+    return { type: 'claude-code', name: 'Claude Code' };
+  }
+
+  // Check for Gemini CLI
+  if (process.env.GEMINI_API_KEY || process.env.GEMINI_CLI) {
+    return { type: 'gemini-cli', name: 'Gemini CLI' };
+  }
+
+  // Check for Cursor
+  if (process.env.CURSOR_SESSION_ID) {
+    return { type: 'cursor', name: 'Cursor' };
+  }
+
+  // Check for OpenCode
+  if (process.env.OPENCODE_SESSION_ID) {
+    return { type: 'opencode', name: 'OpenCode' };
+  }
+
+  // Check for common hook files
+  if (existsSync(join(process.cwd(), '.claude', 'settings.json'))) {
+    return { type: 'claude-code', name: 'Claude Code' };
+  }
+  if (existsSync(join(process.cwd(), '.gemini', 'settings.json'))) {
+    return { type: 'gemini-cli', name: 'Gemini CLI' };
+  }
+  if (existsSync(join(process.cwd(), '.cursor', 'hooks.json'))) {
+    return { type: 'cursor', name: 'Cursor' };
+  }
+
+  return { type: 'unknown', name: 'Unknown' };
+}
+
+/**
+ * Get agent-specific hook configuration
+ */
+export function getAgentHooks(agentType) {
+  const hooks = {
+    'claude-code': {
+      settingsFile: '.claude/settings.json',
+      sessionStart: 'SessionStart',
+      sessionEnd: 'SessionEnd',
+      prompt: 'UserPromptSubmit',
+      toolPre: 'PreToolUse',
+      toolPost: 'PostToolUse',
+    },
+    'gemini-cli': {
+      settingsFile: '.gemini/settings.json',
+      sessionStart: 'start',
+      sessionEnd: 'end',
+      prompt: 'prompt',
+      toolPre: 'tool_call',
+      toolPost: 'tool_result',
+    },
+    'cursor': {
+      settingsFile: '.cursor/hooks.json',
+      sessionStart: 'session_start',
+      sessionEnd: 'session_end',
+      prompt: 'user_message',
+      toolPre: 'tool_before',
+      toolPost: 'tool_after',
+    },
+    'opencode': {
+      settingsFile: '.opencode/plugins/ses.ts',
+      sessionStart: 'onSessionStart',
+      sessionEnd: 'onSessionEnd',
+      prompt: 'onUserMessage',
+      toolPre: 'onToolCall',
+      toolPost: 'onToolResult',
+    },
+  };
+
+  return hooks[agentType] || hooks['claude-code'];
+}
+
+/**
+ * Build a git tree from a directory with secret redaction
+ */
+function buildTree(cwd, dirPath, redact = true) {
+  const entries = readdirSync(dirPath);
+  const treeLines = [];
+
+  for (const name of entries) {
+    const fullPath = join(dirPath, name);
+    const stat = statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      const subTreeSha = buildTree(cwd, fullPath, redact);
+      treeLines.push(`040000 tree ${subTreeSha}\t${name}`);
+    } else {
+      let content = readFileSync(fullPath);
+
+      // Redact secrets for sensitive files
+      if (redact && (name === 'events.jsonl' || name === 'prompts.txt')) {
+        content = redactSecrets(content.toString());
+      }
+
+      const blobSha = gitRaw('hash-object -w --stdin', cwd, content);
+      treeLines.push(`100644 blob ${blobSha}\t${name}`);
+    }
+  }
+
+  if (treeLines.length === 0) return null;
+  return gitRaw('mktree', cwd, treeLines.join('\n'));
+}
+
+/**
+ * Commit session checkpoint to shadow branch
+ * Branch format: ses/checkpoints/v1/YYYY-MM-DD-<session-id>
+ */
+export async function commitCheckpoint(projectRoot, sessionDir, sessionId, commitSha = null, options = {}) {
+  const autoSummarize = options.autoSummarize !== false; // default true
+
+  // Verify we're in a git repo
+  try {
+    git('rev-parse --git-dir', projectRoot);
+  } catch {
+    return { success: false, reason: 'not a git repo' };
+  }
+
+  // Branch naming: ses/checkpoints/v1/YYYY-MM-DD-<session-short>
+  const datePart = new Date().toISOString().slice(0, 10);
+  const sessionCompact = sessionId.toLowerCase().replace(/[^a-f0-9]/g, '');
+  const uuidPart = (sessionCompact.slice(-8) || sessionCompact.slice(0, 8) || 'unknown00').padEnd(8, '0');
+  const branchName = `ses/checkpoints/v1/${datePart}-${uuidPart}`;
+  const refPath = `refs/heads/${branchName}`;
+
+  // Get linked commit SHA
+  const linkedCommit = commitSha || git('rev-parse HEAD', projectRoot);
+  const linkedCommitShort = linkedCommit.slice(0, 12);
+
+  // Build tree from session directory with redaction
+  const sessionTree = buildTree(projectRoot, sessionDir, true);
+  if (!sessionTree) {
+    return { success: false, reason: 'empty session' };
+  }
+
+  // Wrap session files: .ses-logs/<session-id>/files
+  const wrapperLine = `040000 tree ${sessionTree}\t${sessionId}`;
+  const logsTree = gitRaw('mktree', projectRoot, wrapperLine);
+  const rootLine = `040000 tree ${logsTree}\t.ses-logs`;
+  const rootTree = gitRaw('mktree', projectRoot, rootLine);
+
+  // Check if branch already exists (for parent chaining)
+  let parentArg = '';
+  try {
+    const existing = git(`rev-parse ${refPath}`, projectRoot);
+    parentArg = `-p ${existing}`;
+  } catch {
+    // orphan - no parent
+  }
+
+  // Create commit message with linked commit
+  const timestamp = new Date().toISOString().replace('T', ' ').split('.')[0];
+  const message = `checkpoint ${sessionId.slice(0, 8)} @ ${linkedCommitShort} | ${timestamp}`;
+
+  const commitHash = git(
+    `commit-tree ${rootTree} ${parentArg} -m "${message}"`,
+    projectRoot
+  );
+
+  // Update branch ref
+  git(`update-ref ${refPath} ${commitHash}`, projectRoot);
+
+  // Save checkpoint info to state
+  const stateFile = join(sessionDir, 'state.json');
+  try {
+    let state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+    state.checkpoints = state.checkpoints || [];
+    state.checkpoints.push({
+      branch: branchName,
+      commit: commitHash,
+      linked_commit: linkedCommit,
+      timestamp: new Date().toISOString(),
+    });
+    writeFileSync(stateFile, JSON.stringify(state, null, 2));
+  } catch {
+    // best effort
+  }
+
+  // Auto-summarize if enabled
+  if (autoSummarize) {
+    try {
+      const { summarizeSession } = await import('./summarize.js');
+      const summaryResult = await summarizeSession(projectRoot, sessionId, sessionDir);
+      if (summaryResult.success) {
+        console.log(`✅ AI summary generated: ${summaryResult.model}`);
+      }
+    } catch {
+      // Best effort - summarize is optional
+    }
+  }
+
+  return {
+    success: true,
+    branch: branchName,
+    commit: commitHash,
+    linked_commit: linkedCommit,
+  };
+}
+
+/**
+ * List all checkpoints in the repo
+ */
+export function listCheckpoints(projectRoot) {
+  try {
+    const output = git('branch --list "ses/checkpoints/v1/*"', projectRoot);
+    const branches = output.split('\n').map(b => b.trim().replace(/^\*?\s*/, '')).filter(Boolean);
+
+    const checkpoints = [];
+
+    for (const branch of branches) {
+      try {
+        // Extract session info from branch name (supports current and legacy formats)
+        const match = branch.match(/^(?:ses|shit)\/checkpoints\/v1\/(\d{4}-\d{2}-\d{2})-([a-f0-9]+)$/);
+        const legacyMatch = branch.match(/^(?:ses|shit)\/checkpoints\/v1\/([a-f0-9-]+)$/);
+        if (!match && !legacyMatch) {
+          continue;
+        }
+
+        const date = match ? match[1] : git(`log ${branch} --format=%cs -1`, projectRoot);
+        const uuidShort = match
+          ? match[2]
+          : ((legacyMatch[1].replace(/[^a-f0-9]/g, '').slice(-8) || legacyMatch[1].slice(0, 8)).toLowerCase());
+
+        // Get commit info
+        const log = git(`log ${branch} --oneline -1`, projectRoot);
+        const commitMatch = log.match(/^([a-f0-9]+)\s+checkpoint/);
+        const commit = commitMatch ? commitMatch[1] : log.split(' ')[0];
+
+        // Get linked commit from message
+        const fullLog = git(`log ${branch} --format=%B -1`, projectRoot);
+        const linkedMatch = fullLog.match(/@ ([a-f0-9]+)/);
+        const linkedCommit = linkedMatch ? linkedMatch[1] : null;
+
+        checkpoints.push({
+          branch,
+          commit: commit.slice(0, 12),
+          linked_commit: linkedCommit,
+          date,
+          uuid: uuidShort,
+        });
+      } catch {
+        // Skip invalid branches
+      }
+    }
+
+    return checkpoints.sort((a, b) => b.date.localeCompare(a.date));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get checkpoint details
+ */
+export function getCheckpoint(projectRoot, branchOrCommit) {
+  try {
+    // Try as branch first
+    let branch = branchOrCommit;
+    try {
+      git('rev-parse --verify ' + branch, projectRoot);
+    } catch {
+      // Try as short commit
+      try {
+        branch = git('rev-parse --verify ' + branchOrCommit + '^{commit}', projectRoot);
+      } catch {
+        return null;
+      }
+    }
+
+    const log = git(`log ${branch} --format=%B -1`, projectRoot);
+    const files = git(`ls-tree -r --name-only ${branch}`, projectRoot);
+
+    // Extract linked commit
+    const linkedMatch = log.match(/@ ([a-f0-9]+)/);
+    const linkedCommit = linkedMatch ? linkedMatch[1] : null;
+
+    return {
+      branch,
+      commit: branch.slice(0, 12),
+      linked_commit: linkedCommit,
+      message: log,
+      files: files.split('\n').filter(Boolean),
+    };
+  } catch {
+    return null;
+  }
+}

package/lib/checkpoints.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+/**
+ * List checkpoints - shows all checkpoints created on git commits
+ * Inspired by Entire's checkpoint system
+ */
+
+import { listCheckpoints } from './checkpoint.js';
+import { getProjectRoot } from './config.js';
+
+export default async function checkpoints(args) {
+  try {
+    const projectRoot = getProjectRoot();
+    const verbose = args.includes('--verbose') || args.includes('-v');
+    const json = args.includes('--json');
+
+    const list = listCheckpoints(projectRoot);
+
+    if (list.length === 0) {
+      if (json) {
+        console.log(JSON.stringify({ checkpoints: [] }));
+      } else {
+        console.log('No checkpoints found.');
+        console.log('Checkpoints are created when you run "ses commit" after git commit.');
+      }
+      return;
+    }
+
+    if (json) {
+      console.log(JSON.stringify({ checkpoints: list }, null, 2));
+      return;
+    }
+
+    console.log(`📸 Found ${list.length} checkpoint(s):\n`);
+
+    for (const cp of list) {
+      console.log(`Branch: ${cp.branch}`);
+      console.log(`  Commit: ${cp.commit}`);
+      console.log(`  Linked: ${cp.linked_commit || 'none'}`);
+      console.log(`  Date: ${cp.date}`);
+      console.log();
+    }
+
+    if (verbose) {
+      console.log('💡 Usage:');
+      console.log('  ses rewind <branch>     # Rollback to checkpoint');
+      console.log('  ses view <checkpoint>  # View checkpoint details');
+    }
+
+  } catch (error) {
+    console.error('❌ Failed to list checkpoints:', error.message);
+    process.exit(1);
+  }
+}

package/lib/clean.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { readdirSync, statSync, rmSync } from 'fs';
+import { join } from 'path';
+import { getProjectRoot, getLogDir, SESSION_ID_REGEX } from './config.js';
+
+export default async function clean(args) {
+  const logDir = getLogDir(getProjectRoot());
+  const daysArg = args.find(a => a.startsWith('--days='));
+  const days = daysArg ? parseInt(daysArg.split('=')[1]) : 7;
+  const dryRun = args.includes('--dry-run');
+  const cutoffTime = Date.now() - days * 24 * 60 * 60 * 1000;
+
+  try {
+    const entries = readdirSync(logDir);
+    const old = entries
+      .filter(name => SESSION_ID_REGEX.test(name))
+      .map(id => {
+        const dir = join(logDir, id);
+        return { id, dir, mtime: statSync(dir).mtime.getTime() };
+      })
+      .filter(s => s.mtime < cutoffTime);
+
+    if (old.length === 0) {
+      console.log(`No sessions older than ${days} days.`);
+      return;
+    }
+
+    console.log(`${old.length} session(s) older than ${days} days:`);
+    old.forEach(s => {
+      const age = Math.floor((Date.now() - s.mtime) / 86400000);
+      console.log(`  ${s.id.slice(0, 8)}... (${age}d)`);
+    });
+
+    if (dryRun) {
+      console.log('\n[DRY RUN] No files deleted.');
+    } else {
+      old.forEach(s => rmSync(s.dir, { recursive: true, force: true }));
+      console.log(`\nDeleted ${old.length} session(s).`);
+    }
+  } catch (error) {
+    if (error.code === 'ENOENT') console.log('No log directory found.');
+    else throw error;
+  }
+}

package/lib/commit.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * Git commit hook - creates checkpoint on every git commit
+ * Similar to Entire's approach: checkpoint created on git commit
+ */
+
+import { existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { commitCheckpoint } from './checkpoint.js';
+import { getProjectRoot, SESSION_ID_REGEX } from './config.js';
+
+export default async function commitHook(args) {
+  try {
+    const projectRoot = getProjectRoot();
+
+    // Get the commit that was just created
+    const commitSha = args[0] || execSync('git rev-parse HEAD', { cwd: projectRoot, encoding: 'utf-8' }).trim();
+    const commitShort = commitSha.slice(0, 12);
+
+    console.log(`📸 Creating checkpoint for commit ${commitShort}...`);
+
+    // Find active session
+    const sesLogsDir = join(projectRoot, '.ses-logs');
+    if (!existsSync(sesLogsDir)) {
+      console.log('No .ses-logs directory found, skipping checkpoint');
+      return;
+    }
+
+    // Find the most recent session
+    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) {
+      console.log('No active session found, skipping checkpoint');
+      return;
+    }
+
+    const activeSession = sessions[0];
+
+    // Create checkpoint
+    await commitCheckpoint(projectRoot, activeSession.path, activeSession.name, commitSha);
+
+    console.log(`✅ Checkpoint created for session ${activeSession.name}`);
+
+  } catch (error) {
+    console.error('Checkpoint creation failed:', error.message);
+    // Don't exit with error - checkpoint is best-effort
+  }
+}

package/lib/config.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+
+import { join, relative } from 'path';
+import { execSync } from 'child_process';
+
+export const UUID_SESSION_ID_REGEX = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+export const LEGACY_SESSION_ID_REGEX = /^\d{4}-\d{2}-\d{2}-[a-f0-9-]+$/;
+export const SESSION_ID_REGEX = /^(?:[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}|\d{4}-\d{2}-\d{2}-[a-f0-9-]+)$/;
+
+export function getProjectRoot() {
+  try {
+    return execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return process.cwd();
+  }
+}
+
+export function getLogDir(projectRoot) {
+  return process.env.SES_LOG_DIR || join(projectRoot || getProjectRoot(), '.ses-logs');
+}
+
+export function toRelative(projectRoot, filePath) {
+  if (!filePath || !filePath.startsWith('/')) return filePath;
+  return relative(projectRoot, filePath) || filePath;
+}

package/lib/disable.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+
+/**
+ * Disable ses-cli in repository
+ * Similar to 'entire disable' - removes hooks and optionally cleans data
+ */
+
+import { existsSync, readFileSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+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');
+
+  if (!existsSync(settingsFile)) {
+    return false;
+  }
+
+  try {
+    const settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+    let removed = false;
+
+    if (settings.hooks) {
+      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('ses 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('ses 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) {
+        delete settings.hooks;
+      }
+    }
+
+    writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+    return removed;
+  } 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('.ses-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 = getProjectRoot();
+    const cleanData = args.includes('--clean') || args.includes('--purge');
+
+    console.log('🔧 Disabling ses-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 .ses-logs from .gitignore');
+    }
+
+    // Optionally clean data
+    if (cleanData) {
+      const sesLogsDir = join(projectRoot, '.ses-logs');
+      if (existsSync(sesLogsDir)) {
+        rmSync(sesLogsDir, { recursive: true, force: true });
+        console.log('✅ Removed .ses-logs directory');
+      }
+    }
+
+    console.log('\n🎉 ses-cli disabled successfully!');
+
+    if (!cleanData) {
+      console.log('\nNote: .ses-logs directory preserved.');
+      console.log('Use "ses disable --clean" to remove all data.');
+    }
+
+  } catch (error) {
+    console.error('❌ Failed to disable ses-cli:', error.message);
+    process.exit(1);
+  }
+}