@polymorphism-tech/morph-spec 8.1.2 → 8.2.1

package/src/lib/worktree/fleet-scanner.js

@@ -0,0 +1,156 @@
+/**
+ * fleet-scanner.js — aggregate view of every active feature across the fleet.
+ *
+ * A fleet is N Claude Code instances, one per feature worktree, plus whatever
+ * is active in the primary root. Each instance only sees its own cwd; the
+ * operator loses track of "what is each session doing, what is waiting on me".
+ * This scanner answers that from the primary root's vantage point: one entry
+ * per active feature, worktree or root-resident, with the operational facts
+ * (phase, pending gates, task counts, port block, handoff freshness, last
+ * commit, dirtiness) resolved per entry.
+ *
+ * Read-only and fail-open per FIELD: a corrupt feature.json or a git hiccup
+ * nulls that field, never the scan.
+ */
+
+import { execSync, execFileSync } from 'child_process';
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { isGitRepo, resolvePrimaryRoot, parseWorktreeList } from '../../commands/project/worktree.js';
+import { registryPath, resolveFleetConfig } from './env-allocator.js';
+import {
+  getFeature,
+  derivePhaseForFeature,
+  getPendingGates,
+} from '../../../framework/hooks/shared/state-reader.js';
+
+function taskCounts(featureDir) {
+  try {
+    const data = JSON.parse(readFileSync(join(featureDir, '2-plan', 'tasks.json'), 'utf8'));
+    if (!Array.isArray(data.tasks)) return null;
+    return { done: data.tasks.filter((t) => t.status === 'done').length, total: data.tasks.length };
+  } catch {
+    return null;
+  }
+}
+
+function handoffInfo(featureDir) {
+  try {
+    const path = join(featureDir, 'handoff.md');
+    if (!existsSync(path)) return { exists: false, generatedAt: null };
+    const generatedAt = readFileSync(path, 'utf8').match(/gerado em (\d{4}-\d{2}-\d{2}T[\d:.]+Z)/)?.[1] || null;
+    return { exists: true, generatedAt };
+  } catch {
+    return { exists: false, generatedAt: null };
+  }
+}
+
+function lastCommitRelative(root, branch) {
+  try {
+    return execFileSync('git', ['log', '-1', '--format=%cr', branch], { cwd: root, stdio: 'pipe' })
+      .toString().trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function dirtyCount(worktreePath) {
+  try {
+    const out = execFileSync('git', ['status', '--porcelain'], { cwd: worktreePath, stdio: 'pipe' }).toString();
+    return out.split('\n').filter((l) => l.trim()).length;
+  } catch {
+    return null;
+  }
+}
+
+function buildEntry(feature, { location, path, branch, root, allocations, blockSize }) {
+  let workType = null;
+  let status = 'unknown';
+  let phase = 'proposal';
+  let pendingGates = [];
+  try {
+    const fj = getFeature(feature, path);
+    workType = fj?.workType || null;
+    status = fj?.status || 'unknown';
+    phase = derivePhaseForFeature(feature, path);
+    pendingGates = getPendingGates(feature, path);
+  } catch { /* field-level fail-open */ }
+
+  const featureDir = join(path, '.morph', 'features', feature);
+  const alloc = allocations[feature];
+  return {
+    feature,
+    workType,
+    phase,
+    status,
+    pendingGates,
+    location,
+    path,
+    branch,
+    tasks: taskCounts(featureDir),
+    env: alloc && Number.isInteger(alloc.base)
+      ? { base: alloc.base, range: [alloc.base, alloc.base + blockSize - 1] }
+      : null,
+    handoff: handoffInfo(featureDir),
+    lastCommit: location === 'worktree' && branch ? lastCommitRelative(root, branch) : null,
+    dirty: location === 'worktree' ? dirtyCount(path) : null,
+  };
+}
+
+/**
+ * Scan the fleet from anywhere inside the repo.
+ *
+ * @param {string} [cwd]
+ * @returns {{ root: string, entries: object[] }}
+ */
+export function scanFleet(cwd = process.cwd()) {
+  if (!isGitRepo(cwd)) {
+    return { root: resolve(cwd).replace(/\\/g, '/'), entries: [] };
+  }
+  const root = resolvePrimaryRoot(cwd);
+
+  let allocations = {};
+  try {
+    const common = execSync('git rev-parse --git-common-dir', { cwd: root, stdio: 'pipe' }).toString().trim();
+    if (common) {
+      const reg = JSON.parse(readFileSync(registryPath(resolve(root, common)), 'utf8'));
+      if (reg && typeof reg.allocations === 'object' && reg.allocations !== null) allocations = reg.allocations;
+    }
+  } catch { /* no registry yet — env stays null per entry */ }
+  const { blockSize } = resolveFleetConfig(root);
+
+  const entries = [];
+  const inWorktree = new Set();
+
+  for (const e of parseWorktreeList(root)) {
+    const m = e.branch && e.branch.match(/^refs\/heads\/morph\/(.+)$/);
+    if (!m) continue; // primary root entry and non-morph worktrees
+    inWorktree.add(m[1]);
+    entries.push(buildEntry(m[1], {
+      location: 'worktree',
+      path: e.path,
+      branch: e.branch.replace(/^refs\/heads\//, ''),
+      root,
+      allocations,
+      blockSize,
+    }));
+  }
+
+  // Root-resident features (no live worktree): whatever has a feature.json.
+  try {
+    const featuresDir = join(root, '.morph', 'features');
+    if (existsSync(featuresDir)) {
+      const names = readdirSync(featuresDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+        .filter((name) => !inWorktree.has(name) && existsSync(join(featuresDir, name, 'feature.json')));
+      for (const name of names) {
+        entries.push(buildEntry(name, {
+          location: 'root', path: root, branch: null, root, allocations, blockSize,
+        }));
+      }
+    }
+  } catch { /* fail-open */ }
+
+  return { root, entries };
+}

package/src/lib/context/context-builder.js

@@ -1,289 +0,0 @@
-/**
- * @fileoverview Context-Aware Dispatch — Agent Context Builder
- *
- * Assembles curated context payloads per agent, based on domain persona,
- * phase, and active task. Agents get only what they need — not everything.
- *
- * @module context-builder
- */
-
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const AGENTS_JSON_PATH = join(__dirname, '../../../framework/agents.json');
-const STANDARDS_JSON_PATH = join(__dirname, '../../../framework/standards/STANDARDS.json');
-
-let _agentsCache = null;
-let _standardsCache = null;
-
-function loadAgents() {
-  if (_agentsCache) return _agentsCache;
-  if (!existsSync(AGENTS_JSON_PATH)) return { agents: {} };
-  try {
-    _agentsCache = JSON.parse(readFileSync(AGENTS_JSON_PATH, 'utf8'));
-    return _agentsCache;
-  } catch { return { agents: {} }; }
-}
-
-function loadStandards() {
-  if (_standardsCache) return _standardsCache;
-  if (!existsSync(STANDARDS_JSON_PATH)) return { standards: [] };
-  try {
-    _standardsCache = JSON.parse(readFileSync(STANDARDS_JSON_PATH, 'utf8'));
-    return _standardsCache;
-  } catch { return { standards: [] }; }
-}
-
-/** Max chars for spec content (flat — v5 has no tier hierarchy) */
-const SPEC_BUDGET = 8000;
-
-/** Max number of standard digests */
-const STANDARDS_BUDGET = 10;
-
-/**
- * Context assembly rules by phase.
- * Controls which context sections are included.
- */
-const PHASE_CONTEXT_PROFILES = {
-  proposal: {
-    includeSpec: false,
-    includeStandards: false,
-    includeTask: false,
-    includeCodePaths: false,
-    includePhaseArtifacts: false,
-  },
-  uiux: {
-    includeSpec: false,
-    includeStandards: true,
-    includeTask: false,
-    includeCodePaths: false,
-    includePhaseArtifacts: false,
-  },
-  plan: {
-    includeSpec: true,
-    includeStandards: true,
-    includeTask: false,
-    includeCodePaths: false,
-    includePhaseArtifacts: true,
-  },
-  implement: {
-    includeSpec: true,
-    includeStandards: true,
-    includeTask: true,
-    includeCodePaths: true,
-    includePhaseArtifacts: false,
-  },
-  review: {
-    includeSpec: true,
-    includeStandards: true,
-    includeTask: false,
-    includeCodePaths: true,
-    includePhaseArtifacts: true,
-  },
-};
-
-/**
- * Extract only the FR sections referenced by a task.
- *
- * @param {string} specContent - Full spec.md content
- * @param {string[]} frIds - FR IDs (e.g., ['FR001', 'FR003'])
- * @returns {string} Scoped spec with only referenced FRs
- */
-export function scopeSpecToFRs(specContent, frIds) {
-  if (!frIds || frIds.length === 0 || !specContent) return specContent;
-
-  const sections = [];
-
-  // Always include overview/context sections
-  const overviewMatch = specContent.match(/^(#[^#][\s\S]*?)(?=\n##\s+FR\d)/m);
-  if (overviewMatch) {
-    sections.push(overviewMatch[1].trim());
-  }
-
-  // Extract each referenced FR section
-  for (const frId of frIds) {
-    const pattern = new RegExp(
-      `(##\\s+${frId}[:\\s—–\\-][\\s\\S]*?)(?=\\n##\\s+FR\\d|\\n##\\s+[^F]|$)`,
-      'm'
-    );
-    const match = pattern.exec(specContent);
-    if (match) {
-      sections.push(match[1].trim());
-    }
-  }
-
-  return sections.length > 0 ? sections.join('\n\n---\n\n') : specContent;
-}
-
-/**
- * Build standard digests for an agent based on their standards[] array.
- *
- * @param {string} agentId - Agent ID from agents.json
- * @returns {string[]} Array of digest paragraphs
- */
-export function buildAgentDigests(agentId) {
-  const agents = loadAgents();
-  const agentData = agents.agents?.[agentId];
-  if (!agentData?.standards || agentData.standards.length === 0) return [];
-
-  const standards = loadStandards();
-  const standardsList = standards.standards || [];
-
-  const digests = [];
-  for (const stdId of agentData.standards) {
-    const std = standardsList.find(s => s.id === stdId);
-    if (std?.digest) {
-      digests.push(`[${std.id}] ${std.name}: ${std.digest}`);
-    }
-  }
-
-  return digests;
-}
-
-/**
- * Extract FR IDs referenced by a task. Reads `[FR001, FR003]` markers from the
- * task title and any `FR...` references in the task description/body.
- *
- * @param {string} taskTitle - Task title that may contain [FR...] references
- * @param {string} [taskBlock] - Task description/body for further references
- * @returns {string[]}
- */
-export function extractFRIds(taskTitle, taskBlock) {
-  const frIds = new Set();
-
-  // From title: [FR001, FR003]
-  const titleMatch = (taskTitle || '').match(/\[([^\]]*FR\d+[^\]]*)\]/);
-  if (titleMatch) {
-    const matches = titleMatch[1].match(/FR\d+/g);
-    if (matches) matches.forEach(id => frIds.add(id));
-  }
-
-  // From body: **FRs:** FR001, FR002
-  if (taskBlock) {
-    const bodyMatch = taskBlock.match(/\*\*FRs?:\*\*\s*(.+)/i);
-    if (bodyMatch) {
-      const matches = bodyMatch[1].match(/FR\d+/g);
-      if (matches) matches.forEach(id => frIds.add(id));
-    }
-  }
-
-  return [...frIds];
-}
-
-/**
- * Build a curated context payload for a specific agent.
- *
- * @param {string} agentId - Agent ID from agents.json
- * @param {Object} options
- * @param {string} options.feature - Feature name
- * @param {string} options.phase - Current phase
- * @param {string} [options.taskId] - Active task ID (implement phase)
- * @param {string} [options.projectPath='.'] - Project root
- * @returns {AgentContext}
- *
- * @typedef {Object} AgentContext
- * @property {string|null} spec - Full spec or task-scoped section
- * @property {string[]} standards - Digest paragraphs for this agent's standards
- * @property {string|null} task - Mandate task section or null
- * @property {string[]} codeContext - Relevant file paths
- * @property {string|null} phaseArtifacts - Previous phase outputs
- * @property {Object} budget - Context budget hints
- */
-export async function buildAgentContext(agentId, { feature, phase, taskId, projectPath = '.' }) {
-  const agents = loadAgents();
-  const profile = PHASE_CONTEXT_PROFILES[phase] || PHASE_CONTEXT_PROFILES.implement;
-  const maxSpecChars = SPEC_BUDGET;
-  const maxStandards = STANDARDS_BUDGET;
-
-  const result = {
-    spec: null,
-    standards: [],
-    task: null,
-    codeContext: [],
-    phaseArtifacts: null,
-    budget: { maxSpecChars, maxStandards },
-  };
-
-  // Standards digests
-  if (profile.includeStandards) {
-    result.standards = buildAgentDigests(agentId).slice(0, maxStandards);
-  }
-
-  // Spec content (scoped by task FRs when possible)
-  if (profile.includeSpec) {
-    try {
-      const specPath = getAbsoluteOutputPath(projectPath, feature, 'spec');
-      if (existsSync(specPath)) {
-        let specContent = readFileSync(specPath, 'utf8');
-
-        // If task-scoped, extract mandate section for this task
-        if (taskId) {
-          const mandatePath = getAbsoluteOutputPath(projectPath, feature, 'mandate');
-          if (existsSync(mandatePath)) {
-            try {
-              const { extractTaskSection } = await import('../../lib/generators/mandate-generator.js');
-              const section = extractTaskSection(readFileSync(mandatePath, 'utf8'), taskId);
-              if (section) {
-                result.spec = section.slice(0, maxSpecChars);
-                result.task = section;
-              }
-            } catch { /* fall through to raw spec */ }
-          }
-        }
-
-        if (!result.spec) {
-          result.spec = specContent.slice(0, maxSpecChars);
-        }
-      }
-    } catch { /* spec not available */ }
-  }
-
-  // Task mandate section
-  if (profile.includeTask && taskId && !result.task) {
-    try {
-      const mandatePath = getAbsoluteOutputPath(projectPath, feature, 'mandate');
-      if (existsSync(mandatePath)) {
-        const { extractTaskSection } = await import('../../lib/generators/mandate-generator.js');
-        const section = extractTaskSection(readFileSync(mandatePath, 'utf8'), taskId);
-        if (section) result.task = section;
-      }
-    } catch { /* mandate not available */ }
-  }
-
-  // Code paths from task
-  if (profile.includeCodePaths && taskId) {
-    try {
-      const planPath = getAbsoluteOutputPath(projectPath, feature, 'plan');
-      if (existsSync(planPath)) {
-        const planContent = readFileSync(planPath, 'utf8');
-        const backtickPaths = planContent.match(/`([^`]+\.[a-z]{1,4})`/g);
-        if (backtickPaths) {
-          result.codeContext = [...new Set(backtickPaths.map(p => p.replace(/`/g, '')))].slice(0, 20);
-        }
-      }
-    } catch { /* plan not available */ }
-  }
-
-  // Phase artifacts (decisions, previous outputs)
-  if (profile.includePhaseArtifacts) {
-    try {
-      const decisionsPath = getAbsoluteOutputPath(projectPath, feature, 'decisions');
-      if (existsSync(decisionsPath)) {
-        result.phaseArtifacts = readFileSync(decisionsPath, 'utf8').slice(0, 3000);
-      }
-    } catch { /* decisions not available */ }
-  }
-
-  return result;
-}
-
-/**
- * Invalidate module-level caches. Used in tests.
- */
-export function clearCache() {
-  _agentsCache = null;
-  _standardsCache = null;
-}