projecta-rrr 1.16.5 → 1.16.7

package/rrr/lib/install-roots.js

@@ -535,6 +535,58 @@ if (require.main === module) {
   process.exit(summary.verification.valid ? 0 : 1);
 }
 
+/**
+ * Clean up old quarantine directories
+ * Removes quarantine folders older than maxAgeMs to prevent duplicates from being scanned
+ * @param {object} options
+ * @param {string} [options.configDir] - Explicit config directory
+ * @param {number} [options.maxAgeMs=7*24*60*60*1000] - Max age in ms (default 7 days)
+ * @returns {{cleaned: number, errors: string[]}}
+ */
+function cleanOldQuarantines(options = {}, maxAgeMs = 7 * 24 * 60 * 60 * 1000) {
+  const roots = getCanonicalRoots(options);
+  const quarantineRoot = roots.quarantineRoot;
+  const cleaned = [];
+  const errors = [];
+
+  if (!fs.existsSync(quarantineRoot)) {
+    return { cleaned: 0, errors: [] };
+  }
+
+  const now = Date.now();
+  const entries = fs.readdirSync(quarantineRoot, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name === 'QUARANTINE_LOG.json') continue;
+
+    const dirPath = path.join(quarantineRoot, entry.name);
+    const stats = fs.statSync(dirPath);
+    const age = now - stats.mtimeMs;
+
+    if (age > maxAgeMs) {
+      try {
+        // Delete directory contents and directory itself
+        const files = fs.readdirSync(dirPath);
+        for (const file of files) {
+          const filePath = path.join(dirPath, file);
+          if (fs.statSync(filePath).isDirectory()) {
+            fs.rmSync(filePath, { recursive: true });
+          } else {
+            fs.unlinkSync(filePath);
+          }
+        }
+        fs.rmdirSync(dirPath);
+        cleaned.push(entry.name);
+      } catch (e) {
+        errors.push(`Failed to clean ${entry.name}: ${e.message}`);
+      }
+    }
+  }
+
+  return { cleaned, errors };
+}
+
 module.exports = {
   getCanonicalRoots,
   detectAllCandidateRoots,
@@ -545,5 +597,6 @@ module.exports = {
   getInstallInfo,
   detectAndQuarantineDuplicates,
   verifyInstallation,
-  getInstallationSummary
+  getInstallationSummary,
+  cleanOldQuarantines
 };

package/rrr/lib/memory-store.js

@@ -0,0 +1,412 @@
+/**
+ * RRR Memory Store
+ *
+ * Central memory library for tracking:
+ * - Command history (what commands user ran)
+ * - Intent tracking (what user is trying to accomplish)
+ * - Decision log (key decisions made)
+ * - Drift detection (is user on track?)
+ *
+ * Uses existing LanceDB for semantic memory and JSON for structured data.
+ * NO new commands - this is a library integrated into existing workflows.
+ *
+ * Usage:
+ *   const memory = require('./rrr/lib/memory-store');
+ *   await memory.init();
+ *   await memory.trackCommand('/rrr:execute-plan', '52-01', { intent: 'TTS integration' });
+ *   const drift = await memory.detectDrift(['src/db/schema.ts']);
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const MEMORY_DIR = '.rrr/memory';
+const COMMAND_FILE = '.planning/rrr-command-memory.json';
+const DECISIONS_FILE = '.planning/rrr-decisions.json';
+
+/**
+ * Get active milestone from ROADMAP.md
+ */
+function getActiveMilestone() {
+  const roadmap = path.join(process.cwd(), '.planning', 'ROADMAP.md');
+  if (!fs.existsSync(roadmap)) return null;
+  const content = fs.readFileSync(roadmap, 'utf8');
+  const match = content.match(/^## Current Milestone:\s*(v[0-9]+\.[0-9]+)/m);
+  return match ? match[1] : null;
+}
+
+/**
+ * Initialize memory store
+ */
+async function initMemory() {
+  const projectPath = process.cwd();
+  const memoryPath = path.join(projectPath, MEMORY_DIR);
+  const dbPath = path.join(memoryPath, 'memory.lance');
+
+  // Create memory directory
+  if (!fs.existsSync(memoryPath)) {
+    fs.mkdirSync(memoryPath, { recursive: true });
+  }
+
+  // Connect to LanceDB
+  let semanticDb = null;
+  let semanticTable = null;
+  try {
+    const lancedb = require('@lancedb/lancedb');
+    semanticDb = await lancedb.connect(dbPath);
+    const tableNames = await semanticDb.tableNames();
+    if (!tableNames.includes('memories')) {
+      await semanticDb.createEmptyTable('memories', [
+        { id: 'string', vector: 'float32[1024]', type: 'string', content: 'string', milestone: 'string', created_at: 'int64' }
+      ]);
+    }
+    semanticTable = await semanticDb.openTable('memories');
+  } catch (e) {
+    // LanceDB not available, continue with JSON-only mode
+  }
+
+  return {
+    projectPath,
+    memoryPath,
+    semanticDb,
+    semanticTable,
+    commands: loadJson(COMMAND_FILE, { version: 1, commands: [] }),
+    decisions: loadJson(DECISIONS_FILE, { version: 1, decisions: [] }),
+    sessionStart: Date.now()
+  };
+}
+
+/**
+ * Load JSON or return default
+ */
+function loadJson(file, defaultValue) {
+  if (fs.existsSync(file)) {
+    try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return defaultValue; }
+  }
+  return defaultValue;
+}
+
+/**
+ * Save memory to disk
+ */
+function saveMemory(memory) {
+  fs.writeFileSync(COMMAND_FILE, JSON.stringify(memory.commands, null, 2));
+  fs.writeFileSync(DECISIONS_FILE, JSON.stringify(memory.decisions, null, 2));
+}
+
+/**
+ * Track a command execution
+ */
+async function trackCommand(memory, { command, target, intent, reason, files }) {
+  const entry = {
+    timestamp: Date.now(),
+    command,
+    target,
+    intent,
+    reason,
+    files: files || [],
+    milestone: getActiveMilestone()
+  };
+  memory.commands.commands.push(entry);
+
+  // Keep only last 100 commands
+  if (memory.commands.commands.length > 100) {
+    memory.commands.commands = memory.commands.commands.slice(-100);
+  }
+
+  // Add semantic memory if intent provided
+  if (intent && memory.semanticTable) {
+    try {
+      const embedding = await generateEmbedding(intent);
+      await memory.semanticTable.add([{
+        id: `cmd:${entry.timestamp}`,
+        type: 'intent',
+        content: `${command}: ${intent}`,
+        vector: embedding,
+        milestone: entry.milestone,
+        created_at: entry.timestamp
+      }]);
+    } catch (e) {
+      // Silently fail semantic indexing
+    }
+  }
+
+  saveMemory(memory);
+  return entry;
+}
+
+/**
+ * Record a decision
+ */
+async function recordDecision(memory, { decision, rationale, tradeoffs, alternatives, context, relatedPlans }) {
+  const id = `DEC-${String(memory.decisions.decisions.length + 1).padStart(3, '0')}`;
+  const entry = {
+    id,
+    timestamp: Date.now(),
+    decision,
+    rationale,
+    tradeoffs,
+    alternatives: alternatives || [],
+    context,
+    relatedPlans: relatedPlans || [],
+    outcome: 'pending',
+    milestone: getActiveMilestone()
+  };
+  memory.decisions.decisions.push(entry);
+  saveMemory(memory);
+  return entry;
+}
+
+/**
+ * Get current session intent (last intent mentioned)
+ */
+function getCurrentIntent(memory) {
+  // Find most recent command with intent
+  for (let i = memory.commands.commands.length - 1; i >= 0; i--) {
+    if (memory.commands.commands[i].intent) {
+      return memory.commands.commands[i];
+    }
+  }
+  return null;
+}
+
+/**
+ * Get recent commands
+ */
+function getRecentCommands(memory, limit = 10) {
+  return memory.commands.commands.slice(-limit).reverse();
+}
+
+/**
+ * Get recent decisions
+ */
+function getRecentDecisions(memory, limit = 5) {
+  return memory.decisions.decisions.slice(-limit).reverse();
+}
+
+/**
+ * Detect drift - is user working on things related to their intent?
+ */
+async function detectDrift(memory, currentFiles = []) {
+  const signals = [];
+  const intent = getCurrentIntent(memory);
+
+  if (!intent) {
+    return { drifting: false, signals, message: 'No intent tracked yet' };
+  }
+
+  // 1. Check if current files relate to intent
+  if (currentFiles.length > 0 && intent.intent) {
+    let relatedCount = 0;
+
+    // Simple keyword matching as fallback
+    const intentWords = intent.intent.toLowerCase().split(/\s+/);
+    for (const file of currentFiles) {
+      const fileContent = file.toLowerCase();
+      for (const word of intentWords) {
+        if (word.length > 3 && fileContent.includes(word)) {
+          relatedCount++;
+          break;
+        }
+      }
+    }
+
+    const relatedRatio = currentFiles.length > 0 ? relatedCount / currentFiles.length : 1;
+    if (relatedRatio < 0.3 && currentFiles.length >= 3) {
+      signals.push({
+        type: 'context_drift',
+        severity: 'high',
+        message: `Working on ${currentFiles.length} files but only ${relatedCount} relate to intent`,
+        intent: intent.intent,
+        suggestion: 'Are you switching contexts? Consider /rrr:pause-work'
+      });
+    }
+  }
+
+  // 2. Check for stale incomplete plans (>48 hours)
+  const staleThreshold = 48 * 60 * 60 * 1000;
+  const stalePlans = memory.commands.commands.filter(c =>
+    c.command.includes('execute-plan') &&
+    c.outcome !== 'completed' &&
+    Date.now() - c.timestamp > staleThreshold
+  );
+
+  if (stalePlans.length > 0) {
+    signals.push({
+      type: 'stale_plan',
+      severity: 'low',
+      message: `${stalePlans.length} plans incomplete for >48 hours`,
+      plans: stalePlans.map(p => p.target),
+      suggestion: 'Run /rrr:verify-work or /rrr:pause-work'
+    });
+  }
+
+  // 3. Check for conflicting decisions
+  const recentDecisions = getRecentDecisions(memory, 5);
+  const conflictSignals = recentDecisions.filter(d => {
+    if (d.outcome === 'rejected') return false;
+    return currentFiles.some(f => d.relatedPlans?.some(p => f.includes(p)));
+  });
+
+  if (conflictSignals.length > 0) {
+    signals.push({
+      type: 'decision_conflict',
+      severity: 'medium',
+      message: 'Current work may conflict with past decisions',
+      decisions: conflictSignals.map(d => d.id),
+      suggestion: 'Review past decisions before proceeding'
+    });
+  }
+
+  return {
+    drifting: signals.length > 0,
+    signals,
+    currentIntent: intent.intent,
+    severity: signals.length > 2 ? 'high' : signals.length > 0 ? 'medium' : 'none',
+    message: signals.length === 0 ? 'On track - working on intent-aligned files' : 'Drift detected'
+  };
+}
+
+/**
+ * Generate embedding using existing Ollama setup
+ */
+async function generateEmbedding(text) {
+  try {
+    const embeddings = require('./search/embeddings');
+    const result = await embeddings.generateQwenEmbedding(text);
+    return result.embedding;
+  } catch (e) {
+    // Return zero vector if embedding fails
+    return new Array(1024).fill(0);
+  }
+}
+
+/**
+ * Get memory summary for HUD
+ */
+async function getSummary(memory) {
+  const recentCommands = getRecentCommands(memory, 5);
+  const recentDecisions = getRecentDecisions(memory, 3);
+  const intent = getCurrentIntent(memory);
+  const drift = await detectDrift(memory, []);
+
+  return {
+    sessionStart: new Date(memory.sessionStart).toLocaleString(),
+    lastCommand: recentCommands[0]?.command || 'none',
+    lastTarget: recentCommands[0]?.target || '',
+    currentIntent: intent?.intent || 'tracking...',
+    commandCount: memory.commands.commands.length,
+    decisionCount: memory.decisions.decisions.length,
+    recentCommands: recentCommands.map(c => ({
+      cmd: c.command.replace('/rrr:', ''),
+      target: c.target,
+      time: new Date(c.timestamp).toLocaleTimeString(),
+      intent: c.intent
+    })),
+    recentDecisions: recentDecisions.map(d => ({
+      id: d.id,
+      decision: d.decision.substring(0, 50),
+      outcome: d.outcome
+    })),
+    drift
+  };
+}
+
+/**
+ * Get project state for guidance
+ */
+async function getProjectState() {
+  const planningDir = path.join(process.cwd(), '.planning');
+  const state = {
+    projectType: 'NEW_PROJECT',
+    milestoneState: 'NO_MILESTONE',
+    phaseState: 'NO_PHASES',
+    phases: []
+  };
+
+  if (!fs.existsSync(planningDir)) {
+    return state;
+  }
+
+  // Detect project type
+  const hasProject = fs.existsSync(path.join(planningDir, 'PROJECT.md'));
+  const hasMilestones = fs.existsSync(path.join(planningDir, 'milestones'));
+
+  if (hasProject && hasMilestones) {
+    state.projectType = 'EXISTING_PROJECT';
+  } else if (hasProject) {
+    state.projectType = 'PROJECT_INITIALIZED';
+  }
+
+  // Detect milestone state
+  const roadmap = path.join(planningDir, 'ROADMAP.md');
+  if (fs.existsSync(roadmap)) {
+    const content = fs.readFileSync(roadmap, 'utf8');
+    if (content.includes('## Current Milestone:')) {
+      if (content.includes(':construction:')) {
+        state.milestoneState = 'MILESTONE_STARTING';
+      } else {
+        state.milestoneState = 'ACTIVE_MILESTONE';
+      }
+    } else if (content.includes('SHIPPED') || content.includes('ARCHIVED')) {
+      state.milestoneState = 'COMPLETING_MILESTONE';
+    } else {
+      state.milestoneState = 'NO_MILESTONE';
+    }
+  }
+
+  // Detect phase state
+  if (state.milestoneState === 'ACTIVE_MILESTONE') {
+    const match = content.match(/## Current Milestone:\s*(v[0-9]+\.[0-9]+)/);
+    if (match) {
+      const phasesDir = path.join(planningDir, 'milestones', match[1], 'phases');
+      if (fs.existsSync(phasesDir)) {
+        const phases = [];
+        for (const dir of fs.readdirSync(phasesDir)) {
+          if (!dir.match(/^\d/)) continue;
+          const phaseDir = path.join(phasesDir, dir);
+          const planCount = fs.readdirSync(phaseDir).filter(f => f.endsWith('-PLAN.md')).length;
+          const summaryCount = fs.readdirSync(phaseDir).filter(f => f.endsWith('-SUMMARY.md')).length;
+          phases.push({
+            name: dir,
+            plans: planCount,
+            completed: summaryCount,
+            pct: planCount > 0 ? Math.round((summaryCount / planCount) * 100) : 0
+          });
+        }
+        state.phases = phases.sort((a, b) =>
+          parseInt(a.name.split('-')[0]) - parseInt(b.name.split('-')[0])
+        );
+
+        const totalPlans = state.phases.reduce((sum, p) => sum + p.plans, 0);
+        const donePlans = state.phases.reduce((sum, p) => sum + p.completed, 0);
+
+        if (totalPlans === 0) {
+          state.phaseState = 'NO_PHASES';
+        } else if (donePlans === 0) {
+          state.phaseState = 'PLANNED';
+        } else if (donePlans < totalPlans) {
+          state.phaseState = 'EXECUTING';
+        } else if (donePlans === totalPlans) {
+          state.phaseState = 'COMPLETE';
+        }
+      }
+    }
+  }
+
+  return state;
+}
+
+// Export functions
+module.exports = {
+  initMemory,
+  trackCommand,
+  recordDecision,
+  getCurrentIntent,
+  getRecentCommands,
+  getRecentDecisions,
+  detectDrift,
+  getSummary,
+  getProjectState
+};

package/rrr/lib/phase-paths.md

@@ -28,25 +28,45 @@ get_phase_base_dir() {
   local planning_dir="${1:-.planning}"
   local roadmap_file="$planning_dir/ROADMAP.md"
 
-  # Check if we have milestone-based structure with active milestone
-  if [ -d "$planning_dir/milestones" ]; then
-    # Get active milestone from ROADMAP.md
-    local active_milestone=""
-    if [ -f "$roadmap_file" ]; then
-      # Look for "Current Milestone:" or ":construction:" marker for in-progress milestone
-      active_milestone=$(grep -E "Current Milestone:|:construction:" "$roadmap_file" 2>/dev/null | head -1 | grep -oE "v[0-9]+\.[0-9]+" | head -1)
-    fi
+  # Strategy 1: Look for ## Current Milestone: header
+  local active_milestone=""
+  if [ -f "$roadmap_file" ]; then
+    active_milestone=$(grep -E "^## Current Milestone:" "$roadmap_file" 2>/dev/null | \
+      grep -oE "v[0-9]+\.[0-9]+" | head -1)
+  fi
 
-    # If we found an active milestone, use its phases directory (create if needed)
-    if [ -n "$active_milestone" ]; then
-      local phases_dir="$planning_dir/milestones/$active_milestone/phases"
-      mkdir -p "$phases_dir" 2>/dev/null
-      echo "$phases_dir"
-      return 0
-    fi
+  # Strategy 2: Look for :construction: marker
+  if [ -z "$active_milestone" ]; then
+    active_milestone=$(grep -E ":construction:" "$roadmap_file" 2>/dev/null | \
+      grep -oE "v[0-9]+\.[0-9]+" | head -1)
   fi
 
-  # Fallback to old structure only if no milestones directory exists
+  # Strategy 3: Find milestone directory with phases (even without ROADMAP entry)
+  if [ -z "$active_milestone" ] && [ -d "$planning_dir/milestones" ]; then
+    for milestone_dir in "$planning_dir/milestones"/v*/; do
+      if [ -d "${milestone_dir}phases" ] && [ "$(ls -A "${milestone_dir}phases" 2>/dev/null)" ]; then
+        active_milestone=$(basename "$milestone_dir")
+        break
+      fi
+    done
+  fi
+
+  # ERROR if milestones dir exists but no active milestone
+  if [ -d "$planning_dir/milestones" ] && [ -z "$active_milestone" ]; then
+    echo "ERROR: .planning/milestones/ exists but no active milestone detected" >&2
+    echo "Add '## Current Milestone: vX.Y Name' to ROADMAP.md" >&2
+    return 1
+  fi
+
+  # Use milestone phases dir if found
+  if [ -n "$active_milestone" ]; then
+    local phases_dir="$planning_dir/milestones/$active_milestone/phases"
+    mkdir -p "$phases_dir" 2>/dev/null
+    echo "$phases_dir"
+    return 0
+  fi
+
+  # Legacy fallback ONLY if no milestones directory at all
   echo "$planning_dir/phases"
   return 0
 }
@@ -57,12 +77,16 @@ get_phase_base_dir() {
 
 **Returns:**
 - Path to the phase base directory (e.g., `.planning/phases` or `.planning/milestones/v1.11/phases`)
+- Exits with error if `.planning/milestones/` exists but no active milestone is detected
 
 **Example:**
 ```bash
 base_dir=$(get_phase_base_dir)
 echo "Phases stored in: $base_dir"
 # Output: "Phases stored in: .planning/milestones/v1.11/phases"
+
+# Error case (milestones dir exists but no active milestone):
+# ERROR: .planning/milestones/ exists but no active milestone detected
 ```
 
 ---