@claudemini/ses-cli 1.4.3

package/lib/doctor.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+/**
+ * Doctor command - fix or clean stuck sessions
+ * Similar to 'entire doctor' - repairs corrupted state and cleans up
+ */
+
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, statSync } 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 checkSesLogsStructure(projectRoot) {
+  const issues = [];
+  const sesLogsDir = join(projectRoot, '.ses-logs');
+
+  if (!existsSync(sesLogsDir)) {
+    issues.push({
+      type: 'missing_directory',
+      message: '.ses-logs directory not found',
+      fix: () => {
+        mkdirSync(sesLogsDir, { recursive: true });
+        return 'Created .ses-logs directory';
+      }
+    });
+    return issues;
+  }
+
+  // Check index.json
+  const indexFile = join(sesLogsDir, '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()}`;
+          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 sesLogsDir = join(projectRoot, '.ses-logs');
+
+  if (!existsSync(sesLogsDir)) {
+    return issues;
+  }
+
+  const entries = readdirSync(sesLogsDir);
+  const sessionDirs = entries.filter(name => {
+    const fullPath = join(sesLogsDir, name);
+    return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
+  });
+
+  for (const sessionDir of sessionDirs) {
+    const sessionPath = join(sesLogsDir, 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()}`;
+            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 sesLogsDir = join(projectRoot, '.ses-logs');
+
+  try {
+    const branches = git('branch --list "ses/*"', projectRoot)
+      .split('\n')
+      .map(b => b.trim().replace(/^\*?\s*/, ''))
+      .filter(Boolean);
+
+    const sessionDirs = existsSync(sesLogsDir) ?
+      readdirSync(sesLogsDir).filter(name => {
+        const fullPath = join(sesLogsDir, name);
+        return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
+      }) : [];
+
+    for (const branch of branches) {
+      const match = branch.match(/^ses\/([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 sesLogsDir = join(projectRoot, '.ses-logs');
+
+  if (!existsSync(sesLogsDir)) {
+    return issues;
+  }
+
+  const entries = readdirSync(sesLogsDir);
+  const sessionDirs = entries.filter(name => {
+    const fullPath = join(sesLogsDir, name);
+    return statSync(fullPath).isDirectory() && SESSION_ID_REGEX.test(name);
+  });
+
+  const now = new Date();
+  const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+  const endedHookTypes = new Set(['session-end', 'SessionEnd', 'stop', 'session_end', 'end']);
+
+  for (const sessionDir of sessionDirs) {
+    const sessionPath = join(sesLogsDir, sessionDir);
+    const stateFile = join(sessionPath, 'state.json');
+
+    if (existsSync(stateFile)) {
+      try {
+        const state = JSON.parse(readFileSync(stateFile, 'utf-8'));
+        const lastActivity = new Date(state.last_time || state.start_time);
+        const hasValidLastActivity = !Number.isNaN(lastActivity.getTime());
+        const endedByHook = endedHookTypes.has(state.last_hook_type);
+        const hasShadowBranch = typeof state.shadow_branch === 'string' && state.shadow_branch.length > 0;
+        const hasCheckpoint = Array.isArray(state.checkpoints) && state.checkpoints.length > 0;
+        const consideredEnded = Boolean(state.end_time) || endedByHook || hasShadowBranch || hasCheckpoint;
+
+        // Stuck means inactive for >24h and not explicitly/implicitly ended.
+        if (!consideredEnded && hasValidLastActivity && lastActivity < oneDayAgo) {
+          issues.push({
+            type: 'stuck_session',
+            message: `Stuck session: ${sessionDir} (last activity ${lastActivity.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 = getProjectRoot();
+    const autoFix = args.includes('--fix') || args.includes('--auto-fix');
+    const verbose = args.includes('--verbose') || args.includes('-v');
+
+    console.log('🩺 Running ses-cli diagnostics...\n');
+
+    // Collect all issues
+    const allIssues = [
+      ...checkSesLogsStructure(projectRoot),
+      ...checkSessionDirectories(projectRoot),
+      ...checkOrphanedShadowBranches(projectRoot),
+      ...checkStuckSessions(projectRoot)
+    ];
+
+    if (allIssues.length === 0) {
+      console.log('✅ No issues found! ses-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('   ses doctor --fix');
+    }
+
+  } catch (error) {
+    console.error('❌ Doctor failed:', error.message);
+    process.exit(1);
+  }
+}

package/lib/enable.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+
+/**
+ * Enable ses-cli in repository
+ * Similar to 'entire enable' - sets up hooks and configuration
+ * Supports multiple agents: Claude Code, Gemini CLI, Cursor, OpenCode
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import { getProjectRoot } from './config.js';
+
+// Agent-specific hook configurations
+const AGENT_HOOKS = {
+  'claude-code': {
+    dir: '.claude',
+    settingsFile: '.claude/settings.json',
+    hooks: {
+      'SessionStart': 'ses log session-start',
+      'SessionEnd': 'ses log session-end',
+      'UserPromptSubmit': 'ses log user-prompt-submit',
+      'PreToolUse': 'ses log pre-tool-use',
+      'PostToolUse': 'ses log post-tool-use',
+      'Stop': 'ses log stop',
+      'Notification': 'ses log notification',
+    }
+  },
+  'gemini-cli': {
+    dir: '.gemini',
+    settingsFile: '.gemini/settings.json',
+    hooks: {
+      'start': 'ses log start',
+      'end': 'ses log end',
+      'prompt': 'ses log prompt',
+      'tool_call': 'ses log tool_call',
+      'tool_result': 'ses log tool_result',
+    }
+  },
+  'cursor': {
+    dir: '.cursor',
+    settingsFile: '.cursor/hooks.json',
+    hooks: {
+      'session_start': 'ses log session_start',
+      'session_end': 'ses log session_end',
+      'user_message': 'ses log user_message',
+      'tool_before': 'ses log tool_before',
+      'tool_after': 'ses log tool_after',
+    }
+  },
+  'opencode': {
+    dir: '.opencode',
+    settingsFile: '.opencode/plugins/ses.ts',
+    hooks: {
+      'onSessionStart': 'ses log onSessionStart',
+      'onSessionEnd': 'ses log onSessionEnd',
+      'onUserMessage': 'ses log onUserMessage',
+      'onToolCall': 'ses log onToolCall',
+      'onToolResult': 'ses log onToolResult',
+    }
+  }
+};
+
+function setupAgentHooks(projectRoot, agentType) {
+  const config = AGENT_HOOKS[agentType];
+  if (!config) {
+    throw new Error(`Unknown agent: ${agentType}. Supported: ${Object.keys(AGENT_HOOKS).join(', ')}`);
+  }
+
+  const agentDir = join(projectRoot, config.dir);
+  const settingsFile = join(projectRoot, config.settingsFile);
+
+  // Create agent directory if it doesn't exist
+  if (!existsSync(agentDir)) {
+    mkdirSync(agentDir, { recursive: true });
+  }
+
+  let settings = {};
+  if (existsSync(settingsFile)) {
+    try {
+      settings = JSON.parse(readFileSync(settingsFile, 'utf-8'));
+    } catch {
+      // Invalid JSON, start fresh
+    }
+  }
+
+  // Add ses-cli hooks
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  for (const [hookName, command] of Object.entries(config.hooks)) {
+    if (agentType === 'claude-code') {
+      const current = settings.hooks[hookName];
+      const existing = Array.isArray(current)
+        ? current
+        : (typeof current === 'string'
+          ? [{ matcher: '', hooks: [{ type: 'command', command: current }] }]
+          : []);
+      const alreadyExists = existing.some(entry =>
+        Array.isArray(entry?.hooks) &&
+        entry.hooks.some(hook => typeof hook?.command === 'string' && hook.command.includes('ses log'))
+      );
+
+      if (!alreadyExists) {
+        existing.push({ matcher: '', hooks: [{ type: 'command', command }] });
+      }
+      settings.hooks[hookName] = existing;
+      continue;
+    }
+
+    settings.hooks[hookName] = command;
+  }
+
+  // Ensure directory structure for opencode
+  if (agentType === 'opencode') {
+    const pluginsDir = join(projectRoot, '.opencode', 'plugins');
+    if (!existsSync(pluginsDir)) {
+      mkdirSync(pluginsDir, { recursive: true });
+    }
+  }
+
+  writeFileSync(settingsFile, JSON.stringify(settings, null, 2));
+  return settingsFile;
+}
+
+function setupGitCommitHook(projectRoot) {
+  // Add a git alias for automatic checkpoint on commit
+  const gitConfigFile = join(projectRoot, '.git', 'config');
+
+  try {
+    // Check if alias already exists
+    const config = existsSync(gitConfigFile) ? readFileSync(gitConfigFile, 'utf-8') : '';
+
+    if (!config.includes('ses-commit')) {
+      // Create a post-commit hook instead of using alias
+      const hooksDir = join(projectRoot, '.git', 'hooks');
+      if (!existsSync(hooksDir)) {
+        mkdirSync(hooksDir, { recursive: true });
+      }
+
+      const postCommitHook = join(hooksDir, 'post-commit');
+      const hookContent = `#!/bin/bash
+# ses-cli: Create checkpoint on git commit
+ses commit $GIT_COMMIT 2>/dev/null || true
+`;
+
+      writeFileSync(postCommitHook, hookContent);
+      execSync(`chmod +x "${postCommitHook}"`, { stdio: 'ignore' });
+      console.log('✅ Created post-commit hook for automatic checkpoints');
+    }
+  } catch {
+    // Best effort - git hooks are optional
+  }
+}
+
+function initializeSesLogs(projectRoot) {
+  const sesDir = join(projectRoot, '.ses-logs');
+  if (!existsSync(sesDir)) {
+    mkdirSync(sesDir, { recursive: true });
+  }
+
+  // Create index.json if it doesn't exist
+  const indexFile = join(sesDir, '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 = getProjectRoot();
+
+    // Parse arguments
+    const agents = [];
+    let addCheckpointHook = false;
+    let useLocal = false;
+    let force = false;
+    let pushSessions = true;
+    let telemetry = true;
+    let summarize = true;
+
+    for (const arg of args) {
+      if (arg === '--all') {
+        // Enable for all supported agents
+        agents.push(...Object.keys(AGENT_HOOKS));
+      } else if (arg === '--checkpoint' || arg === '-c') {
+        addCheckpointHook = true;
+      } else if (arg === '--local') {
+        useLocal = true;
+      } else if (arg === '--project') {
+        useLocal = false; // Force project-level settings
+      } else if (arg === '--force' || arg === '-f') {
+        force = true;
+      } else if (arg === '--skip-push-sessions') {
+        pushSessions = false;
+      } else if (arg === '--no-summarize') {
+        summarize = false;
+      } else if (arg.startsWith('--telemetry=')) {
+        telemetry = arg.split('=')[1] !== 'false';
+      } else if (arg === '--telemetry') {
+        telemetry = true;
+      } else if (!arg.startsWith('-')) {
+        // Assume it's an agent name
+        if (AGENT_HOOKS[arg]) {
+          agents.push(arg);
+        } else {
+          console.log(`⚠️  Unknown agent: ${arg}. Supported: ${Object.keys(AGENT_HOOKS).join(', ')}`);
+        }
+      }
+    }
+
+    // Default to Claude Code if no agent specified
+    if (agents.length === 0) {
+      agents.push('claude-code');
+    }
+
+    console.log('🔧 Enabling ses-cli in repository...\n');
+
+    // Write configuration
+    const configData = {
+      enabled: true,
+      push_sessions: pushSessions,
+      summarize: summarize,
+      telemetry: telemetry,
+      log_level: 'info'
+    };
+
+    const settingsFileName = useLocal ? 'settings.local.json' : 'settings.json';
+
+    // Write to .claude/ directory (project or local)
+    const configDir = join(projectRoot, '.claude');
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+
+    const configFile = join(configDir, settingsFileName);
+    writeFileSync(configFile, JSON.stringify(configData, null, 2));
+    console.log(`✅ Wrote configuration: ${configFile}`);
+
+    // Setup hooks for each agent
+    for (const agent of agents) {
+      const settingsFile = setupAgentHooks(projectRoot, agent);
+      console.log(`✅ Enabled ${AGENT_HOOKS[agent].dir} hooks: ${settingsFile}`);
+    }
+
+    // Setup git commit hook for checkpoints
+    if (addCheckpointHook) {
+      setupGitCommitHook(projectRoot);
+    }
+
+    // Initialize .ses-logs directory
+    initializeSesLogs(projectRoot);
+    console.log('✅ Initialized .ses-logs directory');
+
+    // Add .ses-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('.ses-logs')) {
+      const newLine = gitignore.endsWith('\n') || gitignore === '' ? '' : '\n';
+      writeFileSync(gitignoreFile, gitignore + newLine + '.ses-logs/\n');
+      console.log('✅ Added .ses-logs to .gitignore');
+    }
+
+    console.log('\n🎉 ses-cli enabled successfully!');
+    console.log('\nUsage:');
+    console.log('  ses status          # Show current session');
+    console.log('  ses list            # List all sessions');
+    console.log('  ses checkpoints    # List all checkpoints');
+    console.log('  ses commit          # Manually create checkpoint after git commit');
+    console.log('\nOptions:');
+    console.log('  --all                # Enable for all supported agents');
+    console.log('  --checkpoint, -c    # Enable automatic checkpoint on git commit');
+    console.log('  --no-summarize       # Disable AI summary generation');
+    console.log('  --skip-push-sessions # Disable auto-push to remote');
+    console.log('  --telemetry=false    # Disable anonymous telemetry');
+    console.log('\nAI Summary:');
+    console.log('  Set OPENAI_API_KEY or ANTHROPIC_API_KEY to enable AI summaries');
+
+  } catch (error) {
+    console.error('❌ Failed to enable ses-cli:', error.message);
+    process.exit(1);
+  }
+}