agileflow 2.99.0 → 2.99.2

package/lib/session-switching.js

@@ -0,0 +1,191 @@
+/**
+ * session-switching.js - Session switching and thread type management
+ *
+ * Extracted from session-manager.js to reduce file size.
+ * Uses factory pattern for dependency injection.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { getSessionStatePath } = require('./paths');
+const { sessionThreadMachine } = require('./state-machine');
+const { THREAD_TYPES } = require('./worktree-operations');
+
+/**
+ * Create session switching operations bound to the given dependencies.
+ *
+ * @param {object} deps
+ * @param {string} deps.ROOT - Project root path
+ * @param {Function} deps.loadRegistry - Load registry data
+ * @param {Function} deps.saveRegistry - Save registry data
+ */
+function createSessionSwitching(deps) {
+  const { ROOT, loadRegistry, saveRegistry } = deps;
+
+  const SESSION_STATE_PATH = getSessionStatePath(ROOT);
+
+  // ============================================================================
+  // Session Switching
+  // ============================================================================
+
+  function switchSession(sessionIdOrNickname) {
+    const registry = loadRegistry();
+    let targetSession = null,
+      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` };
+    if (!fs.existsSync(targetSession.path))
+      return { success: false, error: `Session directory does not exist: ${targetSession.path}` };
+
+    let sessionState = {};
+    if (fs.existsSync(SESSION_STATE_PATH)) {
+      try {
+        sessionState = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+      } catch (e) {
+        /* start fresh */
+      }
+    }
+
+    sessionState.active_session = {
+      id: targetId,
+      nickname: targetSession.nickname,
+      path: targetSession.path,
+      branch: targetSession.branch,
+      switched_at: new Date().toISOString(),
+      original_cwd: ROOT,
+    };
+
+    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');
+
+    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}`,
+    };
+  }
+
+  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 };
+    }
+  }
+
+  function getActiveSession() {
+    if (!fs.existsSync(SESSION_STATE_PATH)) return { active: false };
+    try {
+      const sessionState = JSON.parse(fs.readFileSync(SESSION_STATE_PATH, 'utf8'));
+      return sessionState.active_session
+        ? { active: true, session: sessionState.active_session }
+        : { active: false };
+    } catch (e) {
+      return { active: false };
+    }
+  }
+
+  // ============================================================================
+  // Thread Type Management
+  // ============================================================================
+
+  function getSessionThreadType(sessionId = null) {
+    const registry = loadRegistry();
+    const cwd = process.cwd();
+    let targetId = sessionId;
+    if (!targetId) {
+      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];
+    const threadType = session.thread_type || (session.is_main ? 'base' : 'parallel');
+    return {
+      success: true,
+      thread_type: threadType,
+      session_id: targetId,
+      is_main: session.is_main,
+    };
+  }
+
+  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 };
+  }
+
+  function transitionThread(sessionId, targetType, options = {}) {
+    const { force = false } = options;
+    const registry = loadRegistry();
+    const session = registry.sessions[sessionId];
+    if (!session) return { success: false, error: `Session ${sessionId} not found` };
+
+    const currentType = session.thread_type || (session.is_main ? 'base' : 'parallel');
+    const result = sessionThreadMachine.transition(currentType, targetType, { force });
+    if (!result.success)
+      return { success: false, from: currentType, to: targetType, error: result.error };
+    if (result.noop) return { success: true, from: currentType, to: targetType, noop: true };
+
+    registry.sessions[sessionId].thread_type = targetType;
+    registry.sessions[sessionId].thread_transitioned_at = new Date().toISOString();
+    saveRegistry(registry);
+    return { success: true, from: currentType, to: targetType, forced: result.forced || false };
+  }
+
+  function getValidThreadTransitions(sessionId) {
+    const registry = loadRegistry();
+    const session = registry.sessions[sessionId];
+    if (!session) return { success: false, error: `Session ${sessionId} not found` };
+    const currentType = session.thread_type || (session.is_main ? 'base' : 'parallel');
+    const validTransitions = sessionThreadMachine.getValidTransitions(currentType);
+    return { success: true, current: currentType, validTransitions };
+  }
+
+  return {
+    switchSession,
+    clearActiveSession,
+    getActiveSession,
+    getSessionThreadType,
+    setSessionThreadType,
+    transitionThread,
+    getValidThreadTransitions,
+  };
+}
+
+module.exports = { createSessionSwitching };

package/lib/template-loader.js

@@ -90,8 +90,10 @@ function extractSimpleFrontmatter(raw) {
       const key = line.substring(0, colonIdx).trim();
       let value = line.substring(colonIdx + 1).trim();
       // Remove quotes if present
-      if ((value.startsWith('"') && value.endsWith('"')) ||
-          (value.startsWith("'") && value.endsWith("'"))) {
+      if (
+        (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))
+      ) {
         value = value.slice(1, -1);
       }
       frontmatter[key] = value;

package/lib/worktree-operations.js

@@ -57,36 +57,16 @@ function detectThreadType(session, isWorktree = false) {
 /**
  * Display progress feedback during long operations.
  * Returns a function to stop the progress indicator.
+ * Uses stderr to avoid corrupting stdout JSON output from callers.
  *
  * @param {string} message - Progress message
  * @returns {function} Stop function
  */
 function progressIndicator(message) {
-  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-  let frameIndex = 0;
-  let elapsed = 0;
-
-  // For TTY (interactive terminal), show spinner
-  if (process.stderr.isTTY) {
-    const interval = setInterval(() => {
-      process.stderr.write(`\r${frames[frameIndex++ % frames.length]} ${message}`);
-    }, 80);
-    return () => {
-      clearInterval(interval);
-      process.stderr.write(`\r${' '.repeat(message.length + 2)}\r`);
-    };
-  }
-
-  // For non-TTY (Claude Code, piped output), emit periodic updates to stderr
-  process.stderr.write(`⏳ ${message}...\n`);
-  const interval = setInterval(() => {
-    elapsed += 10;
-    process.stderr.write(`⏳ Still working... (${elapsed}s elapsed)\n`);
-  }, 10000); // Update every 10 seconds
-
-  return () => {
-    clearInterval(interval);
-  };
+  const { FeedbackSpinner } = require('./feedback');
+  const spinner = new FeedbackSpinner(message, { stream: process.stderr });
+  spinner.start();
+  return () => spinner.succeed();
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agileflow",
-  "version": "2.99.0",
+  "version": "2.99.2",
   "description": "AI-driven agile development system for Claude Code, Cursor, Windsurf, and more",
   "keywords": [
     "agile",

package/scripts/agileflow-configure.js

@@ -44,6 +44,7 @@ const {
   upgradeFeatures,
 } = require('./lib/configure-features');
 const { listScripts, showVersionInfo, repairScripts } = require('./lib/configure-repair');
+const { feedback } = require('../lib/feedback');
 
 // ============================================================================
 // VERSION
@@ -281,7 +282,10 @@ function main() {
   }
 
   // Always detect first
+  const spinner = feedback.spinner('Detecting configuration...');
+  spinner.start();
   const status = detectConfig(VERSION);
+  spinner.succeed('Configuration detected');
   const { hasIssues, hasOutdated } = printStatus(status);
 
   // Detect only mode
@@ -317,11 +321,17 @@ function main() {
     actions.disabled = p.disable || [];
   }
 
+  // Enable/disable specific features with progress tracking
+  const totalChanges = enable.length + disable.length;
+  const featureTask =
+    totalChanges > 1 ? feedback.task('Applying feature changes', totalChanges) : null;
+
   // Enable specific features
   enable.forEach(f => {
     if (enableFeature(f, { archivalDays }, VERSION)) {
       actions.enabled.push(f);
     }
+    if (featureTask) featureTask.step(`Enabled ${f}`);
   });
 
   // Disable specific features
@@ -329,8 +339,11 @@ function main() {
     if (disableFeature(f, VERSION)) {
       actions.disabled.push(f);
     }
+    if (featureTask) featureTask.step(`Disabled ${f}`);
   });
 
+  if (featureTask) featureTask.complete('Feature changes applied');
+
   // Print summary if anything changed
   if (actions.enabled.length > 0 || actions.disabled.length > 0) {
     printSummary(actions);

package/scripts/agileflow-welcome.js

@@ -1965,9 +1965,12 @@ async function main() {
   // Check for multiple Claude processes in the same working directory
   if (processCleanup) {
     try {
-      // Check if auto-kill is enabled in metadata
+      // Auto-kill is explicitly opt-in at runtime.
+      // Even if metadata has autoKill=true from older configs, we require
+      // AGILEFLOW_PROCESS_CLEANUP_AUTOKILL=1 to prevent accidental session kills.
       const metadata = cache?.metadata;
-      const autoKill = metadata?.features?.processCleanup?.autoKill === true;
+      const autoKillConfigured = metadata?.features?.processCleanup?.autoKill === true;
+      const autoKill = autoKillConfigured && process.env.AGILEFLOW_PROCESS_CLEANUP_AUTOKILL === '1';
 
       const cleanupResult = processCleanup.cleanupDuplicateProcesses({
         rootDir,
@@ -1987,15 +1990,17 @@ async function main() {
             console.log(`${c.dim}   └─ PID ${proc.pid} (${proc.method})${c.reset}`);
           });
         } else {
-          // Warn only (auto-kill not enabled)
+          // Warn only (auto-kill disabled or skipped by safety guards)
           console.log(
             `${c.amber}⚠️  ${cleanupResult.duplicates} other Claude process(es) in same directory${c.reset}`
           );
           console.log(`${c.slate}   This may cause slowdowns and freezing. Options:${c.reset}`);
           console.log(`${c.slate}   • Close duplicate Claude windows/tabs${c.reset}`);
-          console.log(
-            `${c.slate}   • Run ${c.skyBlue}/agileflow:configure --enable=processcleanup${c.slate} for auto-cleanup${c.reset}`
-          );
+          if (autoKillConfigured) {
+            console.log(
+              `${c.slate}   • Auto-kill configured but runtime opt-in is off (safer default)${c.reset}`
+            );
+          }
         }
 
         if (cleanupResult.errors.length > 0) {

package/scripts/batch-pmap-loop.js

@@ -27,6 +27,7 @@ const { c } = require('../lib/colors');
 const { getProjectRoot } = require('../lib/paths');
 const { safeReadJSON, safeWriteJSON } = require('../lib/errors');
 const { parseIntBounded } = require('../lib/validate');
+const { feedback } = require('../lib/feedback');
 
 // ===== SESSION STATE HELPERS =====
 
@@ -261,10 +262,14 @@ function handleBatchLoop(rootDir) {
   items[currentItem].iterations = (items[currentItem].iterations || 0) + 1;
 
   // Run tests for this file
-  console.log(`${c.blue}Running tests for:${c.reset} ${currentItem}`);
-  console.log(`${c.dim}${'─'.repeat(50)}${c.reset}`);
-
+  const testSpinner = feedback.spinner(`Running tests for: ${currentItem}`);
+  testSpinner.start();
   const testResult = runTestsForFile(rootDir, currentItem);
+  if (testResult.passed) {
+    testSpinner.succeed(`Tests passed for: ${currentItem}`);
+  } else {
+    testSpinner.fail(`Tests failed for: ${currentItem}`);
+  }
 
   if (testResult.passed) {
     console.log(`${c.green}✓ Tests passed${c.reset} (${(testResult.duration / 1000).toFixed(1)}s)`);
@@ -373,8 +378,10 @@ async function handleInit(args, rootDir) {
   const maxIterations = parseIntBounded(maxArg ? maxArg.split('=')[1] : null, 50, 1, 200);
 
   // Resolve glob pattern
-  console.log(`${c.dim}Resolving pattern: ${pattern}${c.reset}`);
+  const globSpinner = feedback.spinner(`Resolving pattern: ${pattern}`);
+  globSpinner.start();
   const files = await resolveGlob(pattern, rootDir);
+  globSpinner.succeed(`Resolved ${files.length} files`);
 
   if (files.length === 0) {
     console.log(`${c.yellow}No files found matching: ${pattern}${c.reset}`);