agileflow 2.84.2 → 2.86.0

package/scripts/session-manager.js

@@ -156,8 +156,21 @@ function getCurrentStory() {
   return null;
 }
 
+// Thread type enum values
+const THREAD_TYPES = ['base', 'parallel', 'chained', 'fusion', 'big', 'long'];
+
+// Auto-detect thread type from context
+function detectThreadType(session, isWorktree = false) {
+  // Worktree sessions are parallel threads
+  if (isWorktree || (session && !session.is_main)) {
+    return 'parallel';
+  }
+  // Default to base
+  return 'base';
+}
+
 // Register current session (called on startup)
-function registerSession(nickname = null) {
+function registerSession(nickname = null, threadType = null) {
   const registry = loadRegistry();
   const cwd = process.cwd();
   const branch = getCurrentBranch();
@@ -179,6 +192,10 @@ function registerSession(nickname = null) {
     registry.sessions[existingId].story = story ? story.id : null;
     registry.sessions[existingId].last_active = new Date().toISOString();
     if (nickname) registry.sessions[existingId].nickname = nickname;
+    // Update thread_type if explicitly provided
+    if (threadType && THREAD_TYPES.includes(threadType)) {
+      registry.sessions[existingId].thread_type = threadType;
+    }
 
     writeLock(existingId, pid);
     saveRegistry(registry);
@@ -190,6 +207,11 @@ function registerSession(nickname = null) {
   const sessionId = String(registry.next_id);
   registry.next_id++;
 
+  const isMain = cwd === ROOT;
+  const detectedType = threadType && THREAD_TYPES.includes(threadType)
+    ? threadType
+    : detectThreadType(null, !isMain);
+
   registry.sessions[sessionId] = {
     path: cwd,
     branch,
@@ -197,13 +219,14 @@ function registerSession(nickname = null) {
     nickname: nickname || null,
     created: new Date().toISOString(),
     last_active: new Date().toISOString(),
-    is_main: cwd === ROOT,
+    is_main: isMain,
+    thread_type: detectedType,
   };
 
   writeLock(sessionId, pid);
   saveRegistry(registry);
 
-  return { id: sessionId, isNew: true };
+  return { id: sessionId, isNew: true, thread_type: detectedType };
 }
 
 // Unregister session (called on exit)
@@ -291,7 +314,7 @@ function createSession(options = {}) {
     };
   }
 
-  // Register session
+  // Register session - worktree sessions are always parallel threads
   registry.next_id++;
   registry.sessions[sessionId] = {
     path: worktreePath,
@@ -301,6 +324,7 @@ function createSession(options = {}) {
     created: new Date().toISOString(),
     last_active: new Date().toISOString(),
     is_main: false,
+    thread_type: options.thread_type || 'parallel', // Worktrees default to parallel
   };
 
   saveRegistry(registry);
@@ -310,6 +334,7 @@ function createSession(options = {}) {
     sessionId,
     path: worktreePath,
     branch: branchName,
+    thread_type: registry.sessions[sessionId].thread_type,
     command: `cd "${worktreePath}" && claude`,
   };
 }
@@ -671,6 +696,172 @@ function integrateSession(sessionId, options = {}) {
   return result;
 }
 
+// Session phases for Kanban-style visualization
+const SESSION_PHASES = {
+  TODO: 'todo',
+  CODING: 'coding',
+  REVIEW: 'review',
+  MERGED: 'merged',
+};
+
+// Detect session phase based on git state
+function getSessionPhase(session) {
+  // If merged_at field exists, session was merged
+  if (session.merged_at) {
+    return SESSION_PHASES.MERGED;
+  }
+
+  // If is_main, it's the merged/main column
+  if (session.is_main) {
+    return SESSION_PHASES.MERGED;
+  }
+
+  // Check git state for the session
+  try {
+    const sessionPath = session.path;
+    if (!fs.existsSync(sessionPath)) {
+      return SESSION_PHASES.TODO;
+    }
+
+    // Count commits since branch diverged from main
+    const mainBranch = getMainBranch();
+    const commitCount = execSync(
+      `git rev-list --count ${mainBranch}..HEAD 2>/dev/null || echo 0`,
+      { cwd: sessionPath, encoding: 'utf8' }
+    ).trim();
+
+    const commits = parseInt(commitCount, 10);
+
+    if (commits === 0) {
+      return SESSION_PHASES.TODO;
+    }
+
+    // Check for uncommitted changes
+    const status = execSync('git status --porcelain 2>/dev/null || echo ""', {
+      cwd: sessionPath,
+      encoding: 'utf8',
+    }).trim();
+
+    if (status === '') {
+      // No uncommitted changes = ready for review
+      return SESSION_PHASES.REVIEW;
+    }
+
+    // Has commits but also uncommitted changes = still coding
+    return SESSION_PHASES.CODING;
+  } catch (e) {
+    // On error, assume coding phase
+    return SESSION_PHASES.CODING;
+  }
+}
+
+// Render Kanban-style board visualization
+function renderKanbanBoard(sessions) {
+  const lines = [];
+
+  // Group sessions by phase
+  const byPhase = {
+    [SESSION_PHASES.TODO]: [],
+    [SESSION_PHASES.CODING]: [],
+    [SESSION_PHASES.REVIEW]: [],
+    [SESSION_PHASES.MERGED]: [],
+  };
+
+  for (const session of sessions) {
+    const phase = getSessionPhase(session);
+    byPhase[phase].push(session);
+  }
+
+  // Calculate column widths (min 12 chars)
+  const colWidth = 14;
+  const separator = '  ';
+
+  // Header
+  lines.push(`${c.cyan}Sessions (Kanban View):${c.reset}`);
+  lines.push('');
+
+  // Column headers
+  const headers = [
+    `${c.dim}TO DO${c.reset}`,
+    `${c.yellow}CODING${c.reset}`,
+    `${c.blue}REVIEW${c.reset}`,
+    `${c.green}MERGED${c.reset}`,
+  ];
+  lines.push(headers.map(h => h.padEnd(colWidth + 10)).join(separator)); // +10 for ANSI codes
+
+  // Top borders
+  const topBorder = `┌${'─'.repeat(colWidth)}┐`;
+  lines.push([topBorder, topBorder, topBorder, topBorder].join(separator));
+
+  // Find max rows needed
+  const maxRows = Math.max(
+    1,
+    byPhase[SESSION_PHASES.TODO].length,
+    byPhase[SESSION_PHASES.CODING].length,
+    byPhase[SESSION_PHASES.REVIEW].length,
+    byPhase[SESSION_PHASES.MERGED].length
+  );
+
+  // Render rows
+  for (let i = 0; i < maxRows; i++) {
+    const cells = [
+      SESSION_PHASES.TODO,
+      SESSION_PHASES.CODING,
+      SESSION_PHASES.REVIEW,
+      SESSION_PHASES.MERGED,
+    ].map(phase => {
+      const session = byPhase[phase][i];
+      if (!session) {
+        return `│${' '.repeat(colWidth)}│`;
+      }
+
+      // Format session info
+      const id = `[${session.id}]`;
+      const name = session.nickname || session.branch || '';
+      const truncName = name.length > colWidth - 5 ? name.slice(0, colWidth - 8) + '...' : name;
+      const content = `${id} ${truncName}`.slice(0, colWidth);
+
+      return `│${content.padEnd(colWidth)}│`;
+    });
+    lines.push(cells.join(separator));
+
+    // Second line with story
+    const storyCells = [
+      SESSION_PHASES.TODO,
+      SESSION_PHASES.CODING,
+      SESSION_PHASES.REVIEW,
+      SESSION_PHASES.MERGED,
+    ].map(phase => {
+      const session = byPhase[phase][i];
+      if (!session) {
+        return `│${' '.repeat(colWidth)}│`;
+      }
+
+      const story = session.story || '-';
+      const storyTrunc = story.length > colWidth - 2 ? story.slice(0, colWidth - 5) + '...' : story;
+
+      return `│${c.dim}${storyTrunc.padEnd(colWidth)}${c.reset}│`;
+    });
+    lines.push(storyCells.join(separator));
+  }
+
+  // Bottom borders
+  const bottomBorder = `└${'─'.repeat(colWidth)}┘`;
+  lines.push([bottomBorder, bottomBorder, bottomBorder, bottomBorder].join(separator));
+
+  // Summary
+  lines.push('');
+  const summary = [
+    `${c.dim}To Do: ${byPhase[SESSION_PHASES.TODO].length}${c.reset}`,
+    `${c.yellow}Coding: ${byPhase[SESSION_PHASES.CODING].length}${c.reset}`,
+    `${c.blue}Review: ${byPhase[SESSION_PHASES.REVIEW].length}${c.reset}`,
+    `${c.green}Merged: ${byPhase[SESSION_PHASES.MERGED].length}${c.reset}`,
+  ].join(' │ ');
+  lines.push(summary);
+
+  return lines.join('\n');
+}
+
 // Format sessions for display
 function formatSessionsTable(sessions) {
   const lines = [];
@@ -747,6 +938,11 @@ function main() {
       const { sessions, cleaned } = getSessions();
       if (args.includes('--json')) {
         console.log(JSON.stringify({ sessions, cleaned }));
+      } else if (args.includes('--kanban')) {
+        console.log(renderKanbanBoard(sessions));
+        if (cleaned > 0) {
+          console.log(`${c.dim}Cleaned ${cleaned} stale lock(s)${c.reset}`);
+        }
       } else {
         console.log(formatSessionsTable(sessions));
         if (cleaned > 0) {
@@ -786,6 +982,85 @@ function main() {
       break;
     }
 
+    // PERFORMANCE: Combined command for welcome script (saves ~200ms from 3 subprocess calls)
+    case 'full-status': {
+      const nickname = args[1] || null;
+      const cwd = process.cwd();
+
+      // Register in single pass (combines register + count + status)
+      const registry = loadRegistry();
+      const cleaned = cleanupStaleLocks(registry);
+      const branch = getCurrentBranch();
+      const story = getCurrentStory();
+      const pid = process.ppid || process.pid;
+
+      // Find or create session
+      let sessionId = null;
+      let isNew = false;
+      for (const [id, session] of Object.entries(registry.sessions)) {
+        if (session.path === cwd) {
+          sessionId = id;
+          break;
+        }
+      }
+
+      if (sessionId) {
+        // Update existing
+        registry.sessions[sessionId].branch = branch;
+        registry.sessions[sessionId].story = story ? story.id : null;
+        registry.sessions[sessionId].last_active = new Date().toISOString();
+        if (nickname) registry.sessions[sessionId].nickname = nickname;
+        // Ensure thread_type exists (migration for old sessions)
+        if (!registry.sessions[sessionId].thread_type) {
+          registry.sessions[sessionId].thread_type = registry.sessions[sessionId].is_main ? 'base' : 'parallel';
+        }
+        writeLock(sessionId, pid);
+      } else {
+        // Create new
+        sessionId = String(registry.next_id);
+        registry.next_id++;
+        const isMain = cwd === ROOT;
+        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: isMain,
+          thread_type: isMain ? 'base' : 'parallel',
+        };
+        writeLock(sessionId, pid);
+        isNew = true;
+      }
+      saveRegistry(registry);
+
+      // Build session list and counts
+      const sessions = [];
+      let otherActive = 0;
+      for (const [id, session] of Object.entries(registry.sessions)) {
+        const active = isSessionActive(id);
+        const isCurrent = session.path === cwd;
+        sessions.push({ id, ...session, active, current: isCurrent });
+        if (active && !isCurrent) otherActive++;
+      }
+
+      const current = sessions.find(s => s.current) || null;
+
+      console.log(
+        JSON.stringify({
+          registered: true,
+          id: sessionId,
+          isNew,
+          current,
+          otherActive,
+          total: sessions.length,
+          cleaned,
+        })
+      );
+      break;
+    }
+
     case 'check-merge': {
       const sessionId = args[1];
       if (!sessionId) {
@@ -888,6 +1163,49 @@ function main() {
       break;
     }
 
+    case 'switch': {
+      const sessionIdOrNickname = args[1];
+      if (!sessionIdOrNickname) {
+        console.log(JSON.stringify({ success: false, error: 'Session ID or nickname required' }));
+        return;
+      }
+      const result = switchSession(sessionIdOrNickname);
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case 'active': {
+      const result = getActiveSession();
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    case 'clear-active': {
+      const result = clearActiveSession();
+      console.log(JSON.stringify(result));
+      break;
+    }
+
+    case 'thread-type': {
+      const subCommand = args[1];
+      if (subCommand === 'set') {
+        const sessionId = args[2];
+        const threadType = args[3];
+        if (!sessionId || !threadType) {
+          console.log(JSON.stringify({ success: false, error: 'Usage: thread-type set <sessionId> <type>' }));
+          return;
+        }
+        const result = setSessionThreadType(sessionId, threadType);
+        console.log(JSON.stringify(result));
+      } else {
+        // Default: get thread type
+        const sessionId = args[1] || null;
+        const result = getSessionThreadType(sessionId);
+        console.log(JSON.stringify(result));
+      }
+      break;
+    }
+
     case 'help':
     default:
       console.log(`
@@ -901,6 +1219,12 @@ ${c.cyan}Commands:${c.reset}
   count                   Count other active sessions
   delete <id> [--remove-worktree]  Delete session
   status                  Get current session status
+  full-status             Combined register+count+status (optimized)
+  switch <id|nickname>    Switch active session context (for /add-dir)
+  active                  Get currently switched session (if any)
+  clear-active            Clear switched session (back to main)
+  thread-type [id]        Get thread type for session (default: current)
+  thread-type set <id> <type>  Set thread type (base|parallel|chained|fusion|big|long)
   check-merge <id>        Check if session is mergeable to main
   merge-preview <id>      Preview commits/files to be merged
   integrate <id> [opts]   Merge session to main and cleanup
@@ -1086,7 +1410,7 @@ function smartMerge(sessionId, options = {}) {
   }
 
   // Categorize and plan resolutions
-  const resolutions = conflictFiles.files.map((file) => {
+  const resolutions = conflictFiles.files.map(file => {
     const category = categorizeFile(file);
     const strategyInfo = getMergeStrategy(category);
     return {
@@ -1195,7 +1519,10 @@ function smartMerge(sessionId, options = {}) {
         result.worktreeDeleted = true;
       } catch (e) {
         try {
-          execSync(`git worktree remove --force "${session.path}"`, { cwd: ROOT, encoding: 'utf8' });
+          execSync(`git worktree remove --force "${session.path}"`, {
+            cwd: ROOT,
+            encoding: 'utf8',
+          });
           result.worktreeDeleted = true;
         } catch (e2) {
           result.worktreeDeleted = false;
@@ -1295,7 +1622,7 @@ function getConflictingFiles(sessionId) {
   const branchSet = new Set((branchFiles.stdout || '').trim().split('\n').filter(Boolean));
 
   // Find intersection (files changed in both)
-  const conflicting = [...mainSet].filter((f) => branchSet.has(f));
+  const conflicting = [...mainSet].filter(f => branchSet.has(f));
 
   return { success: true, files: conflicting };
 }
@@ -1392,6 +1719,185 @@ function getMergeHistory() {
   }
 }
 
+// Session state file path
+const SESSION_STATE_PATH = path.join(ROOT, 'docs', '09-agents', 'session-state.json');
+
+/**
+ * Switch active session context (for use with /add-dir).
+ * Updates session-state.json with active_session info.
+ *
+ * @param {string} sessionIdOrNickname - Session ID or nickname to switch to
+ * @returns {{ success: boolean, session?: object, path?: string, error?: string }}
+ */
+function switchSession(sessionIdOrNickname) {
+  const registry = loadRegistry();
+
+  // Find session by ID or nickname
+  let targetSession = null;
+  let targetId = null;
+
+  for (const [id, session] of Object.entries(registry.sessions)) {
+    if (id === sessionIdOrNickname || session.nickname === sessionIdOrNickname) {
+      targetSession = session;
+      targetId = id;
+      break;
+    }
+  }
+
+  if (!targetSession) {
+    return { success: false, error: `Session "${sessionIdOrNickname}" not found` };
+  }
+
+  // Verify the session path exists
+  if (!fs.existsSync(targetSession.path)) {
+    return {
+      success: false,
+      error: `Session directory does not exist: ${targetSession.path}`,
+    };
+  }
+
+  // Load or create session-state.json
+  let sessionState = {};
+  if (fs.existsSync(SESSION_STATE_PATH)) {
+    try {
+      sessionState = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+    } catch (e) {
+      // Start fresh
+    }
+  }
+
+  // Update active_session
+  sessionState.active_session = {
+    id: targetId,
+    nickname: targetSession.nickname,
+    path: targetSession.path,
+    branch: targetSession.branch,
+    switched_at: new Date().toISOString(),
+    original_cwd: ROOT,
+  };
+
+  // Save session-state.json
+  const stateDir = path.dirname(SESSION_STATE_PATH);
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+  }
+  fs.writeFileSync(SESSION_STATE_PATH, JSON.stringify(sessionState, null, 2) + '\n');
+
+  // Update session last_active
+  registry.sessions[targetId].last_active = new Date().toISOString();
+  saveRegistry(registry);
+
+  return {
+    success: true,
+    session: {
+      id: targetId,
+      nickname: targetSession.nickname,
+      path: targetSession.path,
+      branch: targetSession.branch,
+    },
+    path: targetSession.path,
+    addDirCommand: `/add-dir ${targetSession.path}`,
+  };
+}
+
+/**
+ * Clear active session (switch back to main/original).
+ * @returns {{ success: boolean }}
+ */
+function clearActiveSession() {
+  if (!fs.existsSync(SESSION_STATE_PATH)) {
+    return { success: true };
+  }
+
+  try {
+    const sessionState = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+    delete sessionState.active_session;
+    fs.writeFileSync(SESSION_STATE_PATH, JSON.stringify(sessionState, null, 2) + '\n');
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+/**
+ * Get current active session (if switched).
+ * @returns {{ active: boolean, session?: object }}
+ */
+function getActiveSession() {
+  if (!fs.existsSync(SESSION_STATE_PATH)) {
+    return { active: false };
+  }
+
+  try {
+    const sessionState = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+    if (sessionState.active_session) {
+      return { active: true, session: sessionState.active_session };
+    }
+    return { active: false };
+  } catch (e) {
+    return { active: false };
+  }
+}
+
+/**
+ * Get thread type for a session.
+ * @param {string} sessionId - Session ID (or null for current session)
+ * @returns {{ success: boolean, thread_type?: string, error?: string }}
+ */
+function getSessionThreadType(sessionId = null) {
+  const registry = loadRegistry();
+  const cwd = process.cwd();
+
+  // Find session
+  let targetId = sessionId;
+  if (!targetId) {
+    // Find current session by path
+    for (const [id, session] of Object.entries(registry.sessions)) {
+      if (session.path === cwd) {
+        targetId = id;
+        break;
+      }
+    }
+  }
+
+  if (!targetId || !registry.sessions[targetId]) {
+    return { success: false, error: 'Session not found' };
+  }
+
+  const session = registry.sessions[targetId];
+  // Return thread_type or auto-detect for legacy sessions
+  const threadType = session.thread_type || (session.is_main ? 'base' : 'parallel');
+
+  return {
+    success: true,
+    thread_type: threadType,
+    session_id: targetId,
+    is_main: session.is_main,
+  };
+}
+
+/**
+ * Update thread type for a session.
+ * @param {string} sessionId - Session ID
+ * @param {string} threadType - New thread type
+ * @returns {{ success: boolean, error?: string }}
+ */
+function setSessionThreadType(sessionId, threadType) {
+  if (!THREAD_TYPES.includes(threadType)) {
+    return { success: false, error: `Invalid thread type: ${threadType}. Valid: ${THREAD_TYPES.join(', ')}` };
+  }
+
+  const registry = loadRegistry();
+  if (!registry.sessions[sessionId]) {
+    return { success: false, error: `Session ${sessionId} not found` };
+  }
+
+  registry.sessions[sessionId].thread_type = threadType;
+  saveRegistry(registry);
+
+  return { success: true, thread_type: threadType };
+}
+
 // Export for use as module
 module.exports = {
   loadRegistry,
@@ -1415,6 +1921,19 @@ module.exports = {
   categorizeFile,
   getMergeStrategy,
   getMergeHistory,
+  // Session switching
+  switchSession,
+  clearActiveSession,
+  getActiveSession,
+  // Thread type tracking
+  THREAD_TYPES,
+  detectThreadType,
+  getSessionThreadType,
+  setSessionThreadType,
+  // Kanban visualization
+  SESSION_PHASES,
+  getSessionPhase,
+  renderKanbanBoard,
 };
 
 // Run CLI if executed directly