agileflow 2.44.0 → 2.45.0

package/scripts/agileflow-welcome.js

@@ -0,0 +1,427 @@
+#!/usr/bin/env node
+
+/**
+ * agileflow-welcome.js - Beautiful SessionStart welcome display
+ *
+ * Shows a transparent ASCII table with:
+ * - Project info (name, version, branch, commit)
+ * - Story stats (WIP, blocked, completed)
+ * - Archival status
+ * - Session cleanup status
+ * - Last commit
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// ANSI color codes
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+
+  brightBlack: '\x1b[90m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightCyan: '\x1b[96m',
+
+  // Brand color (#e8683a)
+  brand: '\x1b[38;2;232;104;58m',
+};
+
+// Box drawing characters
+const box = {
+  tl: '╭', tr: '╮', bl: '╰', br: '╯',
+  h: '─', v: '│',
+  lT: '├', rT: '┤', tT: '┬', bT: '┴',
+  cross: '┼',
+};
+
+function getProjectRoot() {
+  let dir = process.cwd();
+  while (!fs.existsSync(path.join(dir, '.agileflow')) && dir !== '/') {
+    dir = path.dirname(dir);
+  }
+  return dir !== '/' ? dir : process.cwd();
+}
+
+function getProjectInfo(rootDir) {
+  const info = {
+    name: 'agileflow',
+    version: 'unknown',
+    branch: 'unknown',
+    commit: 'unknown',
+    lastCommit: '',
+    wipCount: 0,
+    blockedCount: 0,
+    completedCount: 0,
+    readyCount: 0,
+    totalStories: 0,
+    currentStory: null,
+  };
+
+  // Get package info
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'packages/cli/package.json'), 'utf8'));
+    info.version = pkg.version || info.version;
+  } catch (e) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'));
+      info.version = pkg.version || info.version;
+    } catch (e2) {}
+  }
+
+  // Get git info
+  try {
+    info.branch = execSync('git branch --show-current', { cwd: rootDir, encoding: 'utf8' }).trim();
+    info.commit = execSync('git rev-parse --short HEAD', { cwd: rootDir, encoding: 'utf8' }).trim();
+    info.lastCommit = execSync('git log -1 --format="%s"', { cwd: rootDir, encoding: 'utf8' }).trim();
+  } catch (e) {}
+
+  // Get status info
+  try {
+    const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
+    if (fs.existsSync(statusPath)) {
+      const status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+      if (status.stories) {
+        for (const [id, story] of Object.entries(status.stories)) {
+          info.totalStories++;
+          if (story.status === 'in_progress') {
+            info.wipCount++;
+            if (!info.currentStory) {
+              info.currentStory = { id, title: story.title };
+            }
+          } else if (story.status === 'blocked') {
+            info.blockedCount++;
+          } else if (story.status === 'completed') {
+            info.completedCount++;
+          } else if (story.status === 'ready') {
+            info.readyCount++;
+          }
+        }
+      }
+    }
+  } catch (e) {}
+
+  return info;
+}
+
+function runArchival(rootDir) {
+  const result = { ran: false, threshold: 7, archived: 0, remaining: 0 };
+
+  try {
+    const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
+    if (fs.existsSync(metadataPath)) {
+      const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+      if (metadata.archival?.enabled === false) {
+        result.disabled = true;
+        return result;
+      }
+      result.threshold = metadata.archival?.threshold_days || 7;
+    }
+
+    const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
+    if (!fs.existsSync(statusPath)) return result;
+
+    const status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+    const stories = status.stories || {};
+
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - result.threshold);
+
+    let toArchiveCount = 0;
+    for (const [id, story] of Object.entries(stories)) {
+      if (story.status === 'completed' && story.completed_at) {
+        if (new Date(story.completed_at) < cutoffDate) {
+          toArchiveCount++;
+        }
+      }
+    }
+
+    result.ran = true;
+    result.remaining = Object.keys(stories).length;
+
+    if (toArchiveCount > 0) {
+      // Run archival
+      try {
+        execSync('bash scripts/archive-completed-stories.sh', {
+          cwd: rootDir,
+          encoding: 'utf8',
+          stdio: 'pipe'
+        });
+        result.archived = toArchiveCount;
+        result.remaining -= toArchiveCount;
+      } catch (e) {}
+    }
+  } catch (e) {}
+
+  return result;
+}
+
+function clearActiveCommands(rootDir) {
+  const result = { ran: false, cleared: 0, commandNames: [] };
+
+  try {
+    const sessionStatePath = path.join(rootDir, 'docs/09-agents/session-state.json');
+    if (!fs.existsSync(sessionStatePath)) return result;
+
+    const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+    result.ran = true;
+
+    if (state.active_commands && state.active_commands.length > 0) {
+      result.cleared = state.active_commands.length;
+      // Capture command names before clearing
+      for (const cmd of state.active_commands) {
+        if (cmd.name) result.commandNames.push(cmd.name);
+      }
+      state.active_commands = [];
+    }
+    if (state.active_command !== undefined) {
+      result.cleared++;
+      // Capture single command name
+      if (state.active_command.name) {
+        result.commandNames.push(state.active_command.name);
+      }
+      delete state.active_command;
+    }
+
+    if (result.cleared > 0) {
+      fs.writeFileSync(sessionStatePath, JSON.stringify(state, null, 2) + '\n');
+    }
+  } catch (e) {}
+
+  return result;
+}
+
+function checkPreCompact(rootDir) {
+  const result = { configured: false, scriptExists: false, version: null, outdated: false };
+
+  try {
+    // Check if PreCompact hook is configured in settings
+    const settingsPath = path.join(rootDir, '.claude/settings.json');
+    if (fs.existsSync(settingsPath)) {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      if (settings.hooks?.PreCompact?.length > 0) {
+        result.configured = true;
+      }
+    }
+
+    // Check if the script exists
+    const scriptPath = path.join(rootDir, 'scripts/precompact-context.sh');
+    if (fs.existsSync(scriptPath)) {
+      result.scriptExists = true;
+    }
+
+    // Check configured version from metadata
+    const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
+    if (fs.existsSync(metadataPath)) {
+      const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+      if (metadata.features?.precompact?.configured_version) {
+        result.version = metadata.features.precompact.configured_version;
+        // PreCompact v2.40.0+ has multi-command support
+        result.outdated = compareVersions(result.version, '2.40.0') < 0;
+      } else if (result.configured) {
+        // Hook exists but no version tracked = definitely outdated
+        result.outdated = true;
+        result.version = 'unknown';
+      }
+    }
+  } catch (e) {}
+
+  return result;
+}
+
+// Compare semantic versions: returns -1 if a < b, 0 if equal, 1 if a > b
+function compareVersions(a, b) {
+  if (!a || !b) return 0;
+  const partsA = a.split('.').map(Number);
+  const partsB = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA < numB) return -1;
+    if (numA > numB) return 1;
+  }
+  return 0;
+}
+
+function getFeatureVersions(rootDir) {
+  const result = {
+    hooks: { version: null, outdated: false },
+    archival: { version: null, outdated: false },
+    statusline: { version: null, outdated: false },
+    precompact: { version: null, outdated: false }
+  };
+
+  // Minimum compatible versions for each feature
+  const minVersions = {
+    hooks: '2.35.0',
+    archival: '2.35.0',
+    statusline: '2.35.0',
+    precompact: '2.40.0'  // Multi-command support
+  };
+
+  try {
+    const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
+    if (fs.existsSync(metadataPath)) {
+      const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+
+      for (const feature of Object.keys(result)) {
+        if (metadata.features?.[feature]?.configured_version) {
+          result[feature].version = metadata.features[feature].configured_version;
+          result[feature].outdated = compareVersions(result[feature].version, minVersions[feature]) < 0;
+        }
+      }
+    }
+  } catch (e) {}
+
+  return result;
+}
+
+function pad(str, len, align = 'left') {
+  const stripped = str.replace(/\x1b\[[0-9;]*m/g, '');
+  const diff = len - stripped.length;
+  if (diff <= 0) return str;
+  if (align === 'right') return ' '.repeat(diff) + str;
+  if (align === 'center') return ' '.repeat(Math.floor(diff/2)) + str + ' '.repeat(Math.ceil(diff/2));
+  return str + ' '.repeat(diff);
+}
+
+// Truncate string to max length, respecting ANSI codes
+function truncate(str, maxLen, suffix = '..') {
+  const stripped = str.replace(/\x1b\[[0-9;]*m/g, '');
+  if (stripped.length <= maxLen) return str;
+
+  // Find position in original string that corresponds to maxLen - suffix.length visible chars
+  const targetLen = maxLen - suffix.length;
+  let visibleCount = 0;
+  let cutIndex = 0;
+  let inEscape = false;
+
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === '\x1b') {
+      inEscape = true;
+    } else if (inEscape && str[i] === 'm') {
+      inEscape = false;
+    } else if (!inEscape) {
+      visibleCount++;
+      if (visibleCount >= targetLen) {
+        cutIndex = i + 1;
+        break;
+      }
+    }
+  }
+
+  return str.substring(0, cutIndex) + suffix;
+}
+
+function formatTable(info, archival, session, precompact) {
+  const W = 58; // inner width
+  const R = W - 24; // right column width (34 chars)
+  const lines = [];
+
+  // Helper to create a row (auto-truncates right content to fit)
+  const row = (left, right, leftColor = '', rightColor = '') => {
+    const leftStr = `${leftColor}${left}${leftColor ? c.reset : ''}`;
+    const rightTrunc = truncate(right, R);
+    const rightStr = `${rightColor}${rightTrunc}${rightColor ? c.reset : ''}`;
+    return `${c.dim}${box.v}${c.reset} ${pad(leftStr, 20)} ${c.dim}${box.v}${c.reset} ${pad(rightStr, R)} ${c.dim}${box.v}${c.reset}`;
+  };
+
+  const divider = () => `${c.dim}${box.lT}${box.h.repeat(22)}${box.cross}${box.h.repeat(W - 22)}${box.rT}${c.reset}`;
+  const topBorder = `${c.dim}${box.tl}${box.h.repeat(22)}${box.tT}${box.h.repeat(W - 22)}${box.tr}${c.reset}`;
+  const bottomBorder = `${c.dim}${box.bl}${box.h.repeat(22)}${box.bT}${box.h.repeat(W - 22)}${box.br}${c.reset}`;
+
+  // Header (truncate branch name if too long)
+  const branchColor = info.branch === 'main' ? c.green : info.branch.startsWith('fix') ? c.red : c.cyan;
+  // Fixed parts: "agileflow " (10) + "v" (1) + version + "  " (2) + " (" (2) + commit (7) + ")" (1) = 23 + version.length
+  const maxBranchLen = (W - 1) - 23 - info.version.length;
+  const branchDisplay = info.branch.length > maxBranchLen
+    ? info.branch.substring(0, maxBranchLen - 2) + '..'
+    : info.branch;
+  const header = `${c.brand}${c.bold}agileflow${c.reset} ${c.dim}v${info.version}${c.reset}  ${branchColor}${branchDisplay}${c.reset} ${c.dim}(${info.commit})${c.reset}`;
+  const headerLine = `${c.dim}${box.v}${c.reset} ${pad(header, W - 1)} ${c.dim}${box.v}${c.reset}`;
+
+  lines.push(topBorder);
+  lines.push(headerLine);
+  lines.push(divider());
+
+  // Stories section
+  lines.push(row('In Progress', info.wipCount > 0 ? `${info.wipCount}` : '0', c.dim, info.wipCount > 0 ? c.yellow : c.dim));
+  lines.push(row('Blocked', info.blockedCount > 0 ? `${info.blockedCount}` : '0', c.dim, info.blockedCount > 0 ? c.red : c.dim));
+  lines.push(row('Ready', info.readyCount > 0 ? `${info.readyCount}` : '0', c.dim, info.readyCount > 0 ? c.cyan : c.dim));
+  lines.push(row('Completed', info.completedCount > 0 ? `${info.completedCount}` : '0', c.dim, info.completedCount > 0 ? c.green : c.dim));
+
+  lines.push(divider());
+
+  // Archival section
+  if (archival.disabled) {
+    lines.push(row('Auto-archival', 'disabled', c.dim, c.dim));
+  } else {
+    const archivalStatus = archival.archived > 0
+      ? `archived ${archival.archived} stories`
+      : `nothing to archive`;
+    lines.push(row('Auto-archival', archivalStatus, c.dim, archival.archived > 0 ? c.green : c.dim));
+  }
+
+  // Session cleanup
+  const sessionStatus = session.cleared > 0
+    ? `cleared ${session.cleared} command(s)`
+    : `clean`;
+  lines.push(row('Session state', sessionStatus, c.dim, session.cleared > 0 ? c.green : c.dim));
+
+  // PreCompact status with version check
+  if (precompact.configured && precompact.scriptExists) {
+    if (precompact.outdated) {
+      const verStr = precompact.version ? ` (v${precompact.version})` : '';
+      lines.push(row('Context preserve', `outdated${verStr}`, c.dim, c.yellow));
+    } else if (session.commandNames && session.commandNames.length > 0) {
+      // Show the preserved command names
+      const cmdDisplay = session.commandNames.map(n => `/agileflow:${n}`).join(', ');
+      lines.push(row('Context preserve', cmdDisplay, c.dim, c.green));
+    } else {
+      lines.push(row('Context preserve', 'nothing to compact', c.dim, c.dim));
+    }
+  } else if (precompact.configured) {
+    lines.push(row('Context preserve', 'script missing', c.dim, c.yellow));
+  } else {
+    lines.push(row('Context preserve', 'not configured', c.dim, c.dim));
+  }
+
+  lines.push(divider());
+
+  // Current story (if any) - row() auto-truncates
+  if (info.currentStory) {
+    lines.push(row('Current', `${c.blue}${info.currentStory.id}${c.reset}: ${info.currentStory.title}`, c.dim, ''));
+  } else {
+    lines.push(row('Current', 'No active story', c.dim, c.dim));
+  }
+
+  // Last commit - row() auto-truncates
+  lines.push(row('Last commit', `${info.commit} ${info.lastCommit}`, c.dim, c.dim));
+
+  lines.push(bottomBorder);
+
+  return lines.join('\n');
+}
+
+// Main
+function main() {
+  const rootDir = getProjectRoot();
+  const info = getProjectInfo(rootDir);
+  const archival = runArchival(rootDir);
+  const session = clearActiveCommands(rootDir);
+  const precompact = checkPreCompact(rootDir);
+
+  console.log(formatTable(info, archival, session, precompact));
+}
+
+main();

package/scripts/archive-completed-stories.sh

@@ -0,0 +1,162 @@
+#!/bin/bash
+
+# archive-completed-stories.sh
+# Automatically archives completed stories older than threshold from status.json
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Default paths (relative to project root)
+DOCS_DIR="docs"
+STATUS_FILE="$DOCS_DIR/09-agents/status.json"
+ARCHIVE_DIR="$DOCS_DIR/09-agents/archive"
+METADATA_FILE="$DOCS_DIR/00-meta/agileflow-metadata.json"
+
+# Find project root (directory containing .agileflow)
+PROJECT_ROOT="$(pwd)"
+while [[ ! -d "$PROJECT_ROOT/.agileflow" ]] && [[ "$PROJECT_ROOT" != "/" ]]; do
+  PROJECT_ROOT="$(dirname "$PROJECT_ROOT")"
+done
+
+if [[ "$PROJECT_ROOT" == "/" ]]; then
+  echo -e "${RED}Error: Not in an AgileFlow project (no .agileflow directory found)${NC}"
+  exit 1
+fi
+
+# Update paths to absolute
+STATUS_FILE="$PROJECT_ROOT/$STATUS_FILE"
+ARCHIVE_DIR="$PROJECT_ROOT/$ARCHIVE_DIR"
+METADATA_FILE="$PROJECT_ROOT/$METADATA_FILE"
+
+# Check if status.json exists
+if [[ ! -f "$STATUS_FILE" ]]; then
+  echo -e "${YELLOW}No status.json found at $STATUS_FILE${NC}"
+  exit 0
+fi
+
+# Read archival settings
+THRESHOLD_DAYS=7
+ENABLED=true
+
+if [[ -f "$METADATA_FILE" ]]; then
+  if command -v jq &> /dev/null; then
+    ENABLED=$(jq -r '.archival.enabled // true' "$METADATA_FILE")
+    THRESHOLD_DAYS=$(jq -r '.archival.threshold_days // 7' "$METADATA_FILE")
+  elif command -v node &> /dev/null; then
+    ENABLED=$(node -pe "JSON.parse(require('fs').readFileSync('$METADATA_FILE', 'utf8')).archival?.enabled ?? true")
+    THRESHOLD_DAYS=$(node -pe "JSON.parse(require('fs').readFileSync('$METADATA_FILE', 'utf8')).archival?.threshold_days ?? 7")
+  fi
+fi
+
+if [[ "$ENABLED" != "true" ]]; then
+  echo -e "${BLUE}Auto-archival is disabled${NC}"
+  exit 0
+fi
+
+echo -e "${BLUE}Starting auto-archival (threshold: $THRESHOLD_DAYS days)...${NC}"
+
+# Create archive directory if needed
+mkdir -p "$ARCHIVE_DIR"
+
+# Calculate cutoff date (threshold days ago)
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  # macOS
+  CUTOFF_DATE=$(date -v-${THRESHOLD_DAYS}d -u +"%Y-%m-%dT%H:%M:%S.000Z")
+else
+  # Linux
+  CUTOFF_DATE=$(date -u -d "$THRESHOLD_DAYS days ago" +"%Y-%m-%dT%H:%M:%S.000Z")
+fi
+
+echo -e "${BLUE}Cutoff date: $CUTOFF_DATE${NC}"
+
+# Archive using Node.js (more reliable for JSON manipulation)
+if command -v node &> /dev/null; then
+  STATUS_FILE="$STATUS_FILE" ARCHIVE_DIR="$ARCHIVE_DIR" CUTOFF_DATE="$CUTOFF_DATE" node <<'EOF'
+const fs = require('fs');
+const path = require('path');
+
+const statusFile = process.env.STATUS_FILE;
+const archiveDir = process.env.ARCHIVE_DIR;
+const cutoffDate = process.env.CUTOFF_DATE;
+
+// Read status.json
+const status = JSON.parse(fs.readFileSync(statusFile, 'utf8'));
+const stories = status.stories || {};
+
+// Find stories to archive
+const toArchive = {};
+const toKeep = {};
+let archivedCount = 0;
+
+for (const [storyId, story] of Object.entries(stories)) {
+  if (story.status === 'completed' && story.completed_at) {
+    if (story.completed_at < cutoffDate) {
+      toArchive[storyId] = story;
+      archivedCount++;
+    } else {
+      toKeep[storyId] = story;
+    }
+  } else {
+    toKeep[storyId] = story;
+  }
+}
+
+if (archivedCount === 0) {
+  console.log('\x1b[33mNo stories to archive\x1b[0m');
+  process.exit(0);
+}
+
+// Group archived stories by month
+const byMonth = {};
+for (const [storyId, story] of Object.entries(toArchive)) {
+  const date = new Date(story.completed_at);
+  const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
+
+  if (!byMonth[monthKey]) {
+    byMonth[monthKey] = {
+      month: monthKey,
+      archived_at: new Date().toISOString(),
+      stories: {}
+    };
+  }
+
+  byMonth[monthKey].stories[storyId] = story;
+}
+
+// Write archive files
+for (const [monthKey, archiveData] of Object.entries(byMonth)) {
+  const archiveFile = path.join(archiveDir, `${monthKey}.json`);
+
+  // Merge with existing archive if it exists
+  if (fs.existsSync(archiveFile)) {
+    const existing = JSON.parse(fs.readFileSync(archiveFile, 'utf8'));
+    archiveData.stories = { ...existing.stories, ...archiveData.stories };
+  }
+
+  fs.writeFileSync(archiveFile, JSON.stringify(archiveData, null, 2));
+  const count = Object.keys(archiveData.stories).length;
+  console.log(`\x1b[32m✓ Archived ${count} stories to ${monthKey}.json\x1b[0m`);
+}
+
+// Update status.json
+status.stories = toKeep;
+status.updated = new Date().toISOString();
+fs.writeFileSync(statusFile, JSON.stringify(status, null, 2));
+
+console.log(`\x1b[32m✓ Removed ${archivedCount} archived stories from status.json\x1b[0m`);
+console.log(`\x1b[34mStories remaining: ${Object.keys(toKeep).length}\x1b[0m`);
+EOF
+
+  echo -e "${GREEN}Auto-archival complete!${NC}"
+else
+  echo -e "${RED}Error: Node.js not found. Cannot perform archival.${NC}"
+  exit 1
+fi
+
+exit 0

package/scripts/clear-active-command.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * clear-active-command.js - Clears active_commands on session start
+ *
+ * This script runs on SessionStart to reset the active_commands array
+ * in session-state.json. This ensures that if a user starts a new chat
+ * without running a command like /babysit, they won't get stale command
+ * rules in their PreCompact output.
+ *
+ * Usage: Called automatically by SessionStart hook
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function clearActiveCommands() {
+  const sessionStatePath = path.join(process.cwd(), 'docs/09-agents/session-state.json');
+
+  // Skip if session-state.json doesn't exist
+  if (!fs.existsSync(sessionStatePath)) {
+    return;
+  }
+
+  try {
+    const sessionState = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+
+    // Only update if active_commands has items
+    if (sessionState.active_commands && sessionState.active_commands.length > 0) {
+      sessionState.active_commands = [];
+      fs.writeFileSync(sessionStatePath, JSON.stringify(sessionState, null, 2) + '\n', 'utf8');
+      console.log('Cleared active_commands from previous session');
+    }
+
+    // Migration: also clear old active_command field if present
+    if (sessionState.active_command !== undefined) {
+      delete sessionState.active_command;
+      fs.writeFileSync(sessionStatePath, JSON.stringify(sessionState, null, 2) + '\n', 'utf8');
+    }
+  } catch (err) {
+    // Silently ignore errors - don't break session start
+  }
+}
+
+if (require.main === module) {
+  clearActiveCommands();
+}
+
+module.exports = { clearActiveCommands };