agileflow 2.51.0 → 2.56.0

package/scripts/session-manager.js

@@ -0,0 +1,512 @@
+#!/usr/bin/env node
+/**
+ * session-manager.js - Multi-session coordination for Claude Code
+ *
+ * Manages parallel Claude Code sessions with:
+ * - Numbered session IDs (1, 2, 3...)
+ * - PID-based liveness detection
+ * - Git worktree automation
+ * - Registry persistence
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+// ANSI colors
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  brand: '\x1b[38;2;232;104;58m',
+};
+
+// Find project root (has .agileflow or .git)
+function getProjectRoot() {
+  let dir = process.cwd();
+  while (dir !== '/') {
+    if (fs.existsSync(path.join(dir, '.agileflow')) || fs.existsSync(path.join(dir, '.git'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+const ROOT = getProjectRoot();
+const SESSIONS_DIR = path.join(ROOT, '.agileflow', 'sessions');
+const REGISTRY_PATH = path.join(SESSIONS_DIR, 'registry.json');
+
+// Ensure sessions directory exists
+function ensureSessionsDir() {
+  if (!fs.existsSync(SESSIONS_DIR)) {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+
+// Load or create registry
+function loadRegistry() {
+  ensureSessionsDir();
+
+  if (fs.existsSync(REGISTRY_PATH)) {
+    try {
+      return JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+    } catch (e) {
+      console.error(`${c.red}Error loading registry: ${e.message}${c.reset}`);
+    }
+  }
+
+  // Create default registry
+  const registry = {
+    schema_version: '1.0.0',
+    next_id: 1,
+    project_name: path.basename(ROOT),
+    sessions: {},
+  };
+
+  saveRegistry(registry);
+  return registry;
+}
+
+// Save registry
+function saveRegistry(registry) {
+  ensureSessionsDir();
+  registry.updated = new Date().toISOString();
+  fs.writeFileSync(REGISTRY_PATH, JSON.stringify(registry, null, 2) + '\n');
+}
+
+// Check if PID is alive
+function isPidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Get lock file path for session
+function getLockPath(sessionId) {
+  return path.join(SESSIONS_DIR, `${sessionId}.lock`);
+}
+
+// Read lock file
+function readLock(sessionId) {
+  const lockPath = getLockPath(sessionId);
+  if (!fs.existsSync(lockPath)) return null;
+
+  try {
+    const content = fs.readFileSync(lockPath, 'utf8');
+    const lock = {};
+    content.split('\n').forEach(line => {
+      const [key, value] = line.split('=');
+      if (key && value) lock[key.trim()] = value.trim();
+    });
+    return lock;
+  } catch (e) {
+    return null;
+  }
+}
+
+// Write lock file
+function writeLock(sessionId, pid) {
+  const lockPath = getLockPath(sessionId);
+  const content = `pid=${pid}\nstarted=${Math.floor(Date.now() / 1000)}\n`;
+  fs.writeFileSync(lockPath, content);
+}
+
+// Remove lock file
+function removeLock(sessionId) {
+  const lockPath = getLockPath(sessionId);
+  if (fs.existsSync(lockPath)) {
+    fs.unlinkSync(lockPath);
+  }
+}
+
+// Check if session is active (has lock with alive PID)
+function isSessionActive(sessionId) {
+  const lock = readLock(sessionId);
+  if (!lock || !lock.pid) return false;
+  return isPidAlive(parseInt(lock.pid, 10));
+}
+
+// Clean up stale locks
+function cleanupStaleLocks(registry) {
+  let cleaned = 0;
+
+  for (const [id, session] of Object.entries(registry.sessions)) {
+    const lock = readLock(id);
+    if (lock && !isPidAlive(parseInt(lock.pid, 10))) {
+      removeLock(id);
+      cleaned++;
+    }
+  }
+
+  return cleaned;
+}
+
+// Get current git branch
+function getCurrentBranch() {
+  try {
+    return execSync('git branch --show-current', { cwd: ROOT, encoding: 'utf8' }).trim();
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+// Get current story from status.json
+function getCurrentStory() {
+  try {
+    const statusPath = path.join(ROOT, 'docs', '09-agents', 'status.json');
+    if (!fs.existsSync(statusPath)) return null;
+
+    const status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+    for (const [id, story] of Object.entries(status.stories || {})) {
+      if (story.status === 'in_progress') {
+        return { id, title: story.title };
+      }
+    }
+  } catch (e) {}
+  return null;
+}
+
+// Register current session (called on startup)
+function registerSession(nickname = null) {
+  const registry = loadRegistry();
+  const cwd = process.cwd();
+  const branch = getCurrentBranch();
+  const story = getCurrentStory();
+  const pid = process.ppid || process.pid; // Parent PID (Claude Code) or current
+
+  // Check if this path already has a session
+  let existingId = null;
+  for (const [id, session] of Object.entries(registry.sessions)) {
+    if (session.path === cwd) {
+      existingId = id;
+      break;
+    }
+  }
+
+  if (existingId) {
+    // Update existing session
+    registry.sessions[existingId].branch = branch;
+    registry.sessions[existingId].story = story ? story.id : null;
+    registry.sessions[existingId].last_active = new Date().toISOString();
+    if (nickname) registry.sessions[existingId].nickname = nickname;
+
+    writeLock(existingId, pid);
+    saveRegistry(registry);
+
+    return { id: existingId, isNew: false };
+  }
+
+  // Create new session
+  const sessionId = String(registry.next_id);
+  registry.next_id++;
+
+  registry.sessions[sessionId] = {
+    path: cwd,
+    branch,
+    story: story ? story.id : null,
+    nickname: nickname || null,
+    created: new Date().toISOString(),
+    last_active: new Date().toISOString(),
+    is_main: cwd === ROOT,
+  };
+
+  writeLock(sessionId, pid);
+  saveRegistry(registry);
+
+  return { id: sessionId, isNew: true };
+}
+
+// Unregister session (called on exit)
+function unregisterSession(sessionId) {
+  const registry = loadRegistry();
+
+  if (registry.sessions[sessionId]) {
+    registry.sessions[sessionId].last_active = new Date().toISOString();
+    removeLock(sessionId);
+    saveRegistry(registry);
+  }
+}
+
+// Create new session with worktree
+function createSession(options = {}) {
+  const registry = loadRegistry();
+  const sessionId = String(registry.next_id);
+  const projectName = registry.project_name;
+
+  const nickname = options.nickname || null;
+  const branchName = options.branch || `session-${sessionId}`;
+  const dirName = nickname || sessionId;
+  const worktreePath = path.resolve(ROOT, '..', `${projectName}-${dirName}`);
+
+  // Check if directory already exists
+  if (fs.existsSync(worktreePath)) {
+    return {
+      success: false,
+      error: `Directory already exists: ${worktreePath}`,
+    };
+  }
+
+  // Create branch if it doesn't exist
+  try {
+    execSync(`git show-ref --verify --quiet refs/heads/${branchName}`, { cwd: ROOT });
+  } catch (e) {
+    // Branch doesn't exist, create it
+    try {
+      execSync(`git branch ${branchName}`, { cwd: ROOT, encoding: 'utf8' });
+    } catch (e2) {
+      return { success: false, error: `Failed to create branch: ${e2.message}` };
+    }
+  }
+
+  // Create worktree
+  try {
+    execSync(`git worktree add "${worktreePath}" ${branchName}`, {
+      cwd: ROOT,
+      encoding: 'utf8',
+      stdio: 'pipe',
+    });
+  } catch (e) {
+    return { success: false, error: `Failed to create worktree: ${e.message}` };
+  }
+
+  // Register session
+  registry.next_id++;
+  registry.sessions[sessionId] = {
+    path: worktreePath,
+    branch: branchName,
+    story: null,
+    nickname,
+    created: new Date().toISOString(),
+    last_active: new Date().toISOString(),
+    is_main: false,
+  };
+
+  saveRegistry(registry);
+
+  return {
+    success: true,
+    sessionId,
+    path: worktreePath,
+    branch: branchName,
+    command: `cd "${worktreePath}" && claude`,
+  };
+}
+
+// Get all sessions with status
+function getSessions() {
+  const registry = loadRegistry();
+  const cleaned = cleanupStaleLocks(registry);
+
+  const sessions = [];
+  for (const [id, session] of Object.entries(registry.sessions)) {
+    sessions.push({
+      id,
+      ...session,
+      active: isSessionActive(id),
+      current: session.path === process.cwd(),
+    });
+  }
+
+  // Sort by ID (numeric)
+  sessions.sort((a, b) => parseInt(a.id) - parseInt(b.id));
+
+  return { sessions, cleaned };
+}
+
+// Get count of active sessions (excluding current)
+function getActiveSessionCount() {
+  const { sessions } = getSessions();
+  const cwd = process.cwd();
+  return sessions.filter(s => s.active && s.path !== cwd).length;
+}
+
+// Delete session (and optionally worktree)
+function deleteSession(sessionId, removeWorktree = false) {
+  const registry = loadRegistry();
+  const session = registry.sessions[sessionId];
+
+  if (!session) {
+    return { success: false, error: `Session ${sessionId} not found` };
+  }
+
+  if (session.is_main) {
+    return { success: false, error: 'Cannot delete main session' };
+  }
+
+  // Remove lock
+  removeLock(sessionId);
+
+  // Remove worktree if requested
+  if (removeWorktree && fs.existsSync(session.path)) {
+    try {
+      execSync(`git worktree remove "${session.path}"`, { cwd: ROOT, encoding: 'utf8' });
+    } catch (e) {
+      // Try force remove
+      try {
+        execSync(`git worktree remove --force "${session.path}"`, { cwd: ROOT, encoding: 'utf8' });
+      } catch (e2) {
+        return { success: false, error: `Failed to remove worktree: ${e2.message}` };
+      }
+    }
+  }
+
+  // Remove from registry
+  delete registry.sessions[sessionId];
+  saveRegistry(registry);
+
+  return { success: true };
+}
+
+// Format sessions for display
+function formatSessionsTable(sessions) {
+  const lines = [];
+
+  lines.push(`${c.cyan}Active Sessions:${c.reset}`);
+  lines.push(`${'─'.repeat(70)}`);
+
+  for (const session of sessions) {
+    const status = session.active ? `${c.green}●${c.reset}` : `${c.dim}○${c.reset}`;
+    const current = session.current ? ` ${c.yellow}(current)${c.reset}` : '';
+    const name = session.nickname ? `"${session.nickname}"` : session.branch;
+    const story = session.story ? `${c.blue}${session.story}${c.reset}` : `${c.dim}-${c.reset}`;
+
+    lines.push(`  ${status} [${c.bold}${session.id}${c.reset}] ${name}${current}`);
+    lines.push(`      ${c.dim}Story:${c.reset} ${story} ${c.dim}│ Path:${c.reset} ${session.path}`);
+  }
+
+  lines.push(`${'─'.repeat(70)}`);
+
+  return lines.join('\n');
+}
+
+// CLI interface
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    case 'register': {
+      const nickname = args[1] || null;
+      const result = registerSession(nickname);
+      console.log(JSON.stringify(result));
+      break;
+    }
+
+    case 'unregister': {
+      const sessionId = args[1];
+      if (sessionId) {
+        unregisterSession(sessionId);
+        console.log(JSON.stringify({ success: true }));
+      } else {
+        console.log(JSON.stringify({ success: false, error: 'Session ID required' }));
+      }
+      break;
+    }
+
+    case 'create': {
+      const options = {};
+      for (let i = 1; i < args.length; i += 2) {
+        const key = args[i].replace('--', '');
+        const value = args[i + 1];
+        options[key] = value;
+      }
+      const result = createSession(options);
+      console.log(JSON.stringify(result));
+      break;
+    }
+
+    case 'list': {
+      const { sessions, cleaned } = getSessions();
+      if (args.includes('--json')) {
+        console.log(JSON.stringify({ sessions, cleaned }));
+      } else {
+        console.log(formatSessionsTable(sessions));
+        if (cleaned > 0) {
+          console.log(`${c.dim}Cleaned ${cleaned} stale lock(s)${c.reset}`);
+        }
+      }
+      break;
+    }
+
+    case 'count': {
+      const count = getActiveSessionCount();
+      console.log(JSON.stringify({ count }));
+      break;
+    }
+
+    case 'delete': {
+      const sessionId = args[1];
+      const removeWorktree = args.includes('--remove-worktree');
+      const result = deleteSession(sessionId, removeWorktree);
+      console.log(JSON.stringify(result));
+      break;
+    }
+
+    case 'status': {
+      const { sessions } = getSessions();
+      const cwd = process.cwd();
+      const current = sessions.find(s => s.path === cwd);
+      const others = sessions.filter(s => s.active && s.path !== cwd);
+
+      console.log(
+        JSON.stringify({
+          current: current || null,
+          otherActive: others.length,
+          total: sessions.length,
+        })
+      );
+      break;
+    }
+
+    case 'help':
+    default:
+      console.log(`
+${c.brand}${c.bold}Session Manager${c.reset} - Multi-session coordination for Claude Code
+
+${c.cyan}Commands:${c.reset}
+  register [nickname]     Register current directory as a session
+  unregister <id>         Unregister a session (remove lock)
+  create [--nickname X]   Create new session with git worktree
+  list [--json]           List all sessions
+  count                   Count other active sessions
+  delete <id> [--remove-worktree]  Delete session
+  status                  Get current session status
+  help                    Show this help
+
+${c.cyan}Examples:${c.reset}
+  node session-manager.js register
+  node session-manager.js create --nickname auth
+  node session-manager.js list
+  node session-manager.js delete 2 --remove-worktree
+`);
+  }
+}
+
+// Export for use as module
+module.exports = {
+  loadRegistry,
+  saveRegistry,
+  registerSession,
+  unregisterSession,
+  createSession,
+  getSessions,
+  getActiveSessionCount,
+  deleteSession,
+  isSessionActive,
+  cleanupStaleLocks,
+};
+
+// Run CLI if executed directly
+if (require.main === module) {
+  main();
+}