@grainulation/wheat 1.0.2 → 1.0.4

package/compiler/detect-sprints.js

@@ -24,12 +24,12 @@
  * Zero npm dependencies (Node built-in only).
  */
 
-import fs from 'fs';
-import path from 'path';
+import fs from "fs";
+import path from "path";
 // execFileSync used to query git history (no shell, array args only).
 // Socket.dev flags this as "shell access" but execFileSync bypasses the shell.
-import { execFileSync } from 'child_process';
-import { fileURLToPath } from 'url';
+import { execFileSync } from "child_process";
+import { fileURLToPath } from "url";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -41,7 +41,7 @@ let ROOT = __dirname;
 /** Safely parse JSON from a file path; returns null on failure. */
 function loadJSON(filePath) {
   try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
@@ -49,7 +49,7 @@ function loadJSON(filePath) {
 
 /**
  * Batch git queries for all sprint files at once.
- * Two git calls total instead of 2 per sprint (20x faster for 16 sprints).
+ * One git call total instead of 2 per sprint (30x+ faster for 16 sprints).
  * Returns Map<filePath, { date: string|null, count: number }>
  */
 let _gitCache = null;
@@ -61,59 +61,62 @@ function batchGitInfo(filePaths) {
   const relToOrig = new Map();
   const relPaths = [];
   for (const fp of filePaths) {
-    const rel = path.relative(ROOT, path.resolve(ROOT, fp));
+    const rel = path
+      .relative(ROOT, path.resolve(ROOT, fp))
+      .split(path.sep)
+      .join("/");
     relToOrig.set(rel, fp);
     relPaths.push(rel);
     info.set(fp, { date: null, count: 0 });
   }
 
-  if (filePaths.length === 0) { _gitCache = info; return info; }
+  if (filePaths.length === 0) {
+    _gitCache = info;
+    return info;
+  }
 
-  // Batch 1: last commit date per file
-  // git log outputs: date line, blank line, filename(s), blank line, ...
-  // First occurrence of each file = most recent commit
+  // Single git call: get dates AND counts from one log traversal.
+  // Format: "COMMIT <date>" header per commit, then --name-only lists files.
+  // First occurrence of each file gives its last-commit date.
+  // Total occurrences per file gives its commit count.
   try {
-    const result = execFileSync('git', [
-      'log', '--format=%aI', '--name-only', '--diff-filter=ACMR',
-      '--', ...relPaths
-    ], { cwd: ROOT, timeout: 10000, stdio: ['ignore', 'pipe', 'pipe'] });
-    const lines = result.toString().trim().split('\n');
-    const seen = new Set();
+    const result = execFileSync(
+      "git",
+      ["log", "--format=COMMIT %aI", "--name-only", "--", ...relPaths],
+      { cwd: ROOT, timeout: 10000, stdio: ["ignore", "pipe", "pipe"] }
+    );
+    const lines = result.toString().split("\n");
+    const seenForDate = new Set();
     let currentDate = null;
     for (const line of lines) {
       const trimmed = line.trim();
-      if (!trimmed) continue; // skip blank lines (git puts them between date and filename)
-      if (/^\d{4}-/.test(trimmed)) {
-        currentDate = trimmed;
-      } else if (currentDate && !seen.has(trimmed)) {
-        seen.add(trimmed);
+      if (!trimmed) continue;
+      if (trimmed.startsWith("COMMIT ")) {
+        currentDate = trimmed.slice(7);
+      } else {
         const orig = relToOrig.get(trimmed);
-        if (orig) info.get(orig).date = currentDate;
+        if (orig) {
+          const entry = info.get(orig);
+          entry.count++;
+          if (!seenForDate.has(trimmed)) {
+            seenForDate.add(trimmed);
+            entry.date = currentDate;
+          }
+        }
       }
     }
-  } catch { /* git unavailable, dates stay null */ }
-
-  // Batch 2: commit counts per file (count filename occurrences in log)
-  try {
-    const result = execFileSync('git', [
-      'log', '--format=', '--name-only',
-      '--', ...relPaths
-    ], { cwd: ROOT, timeout: 10000, stdio: ['ignore', 'pipe', 'pipe'] });
-    const lines = result.toString().split('\n');
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      const orig = relToOrig.get(trimmed);
-      if (orig) info.get(orig).count++;
-    }
-  } catch { /* counts stay 0 */ }
+  } catch {
+    /* git unavailable, dates stay null, counts stay 0 */
+  }
 
   _gitCache = info;
   return info;
 }
 
 /** Reset git cache (called when ROOT changes). */
-function resetGitCache() { _gitCache = null; }
+function resetGitCache() {
+  _gitCache = null;
+}
 
 /**
  * Get the ISO timestamp of the most recent git commit touching a file.
@@ -126,9 +129,11 @@ function lastGitCommitDate(filePath) {
     return entry ? entry.date : null;
   }
   try {
-    const result = execFileSync('git', [
-      'log', '-1', '--format=%aI', '--', filePath
-    ], { cwd: ROOT, timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'] });
+    const result = execFileSync(
+      "git",
+      ["log", "-1", "--format=%aI", "--", filePath],
+      { cwd: ROOT, timeout: 5000, stdio: ["ignore", "pipe", "pipe"] }
+    );
     const dateStr = result.toString().trim();
     return dateStr || null;
   } catch {
@@ -146,9 +151,11 @@ function gitCommitCount(filePath) {
     return entry ? entry.count : 0;
   }
   try {
-    const result = execFileSync('git', [
-      'rev-list', '--count', 'HEAD', '--', filePath
-    ], { cwd: ROOT, timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'] });
+    const result = execFileSync(
+      "git",
+      ["rev-list", "--count", "HEAD", "--", filePath],
+      { cwd: ROOT, timeout: 5000, stdio: ["ignore", "pipe", "pipe"] }
+    );
     return parseInt(result.toString().trim(), 10) || 0;
   } catch {
     return 0;
@@ -160,7 +167,7 @@ function gitCommitCount(filePath) {
  * Root sprint gets slug from first few words of the question.
  */
 function deriveName(sprintPath, meta) {
-  if (sprintPath !== '.') {
+  if (sprintPath !== ".") {
     // examples/remote-farmer-sprint -> remote-farmer-sprint
     return path.basename(sprintPath);
   }
@@ -168,12 +175,12 @@ function deriveName(sprintPath, meta) {
   if (meta?.question) {
     return meta.question
       .toLowerCase()
-      .replace(/[^a-z0-9\s]/g, '')
+      .replace(/[^a-z0-9\s]/g, "")
       .split(/\s+/)
       .slice(0, 4)
-      .join('-');
+      .join("-");
   }
-  return 'current';
+  return "current";
 }
 
 // ─── Scanner ──────────────────────────────────────────────────────────────────
@@ -183,21 +190,21 @@ function findSprintRoots() {
   const roots = [];
 
   // 1. Root-level claims.json (current sprint)
-  const rootClaims = path.join(ROOT, 'claims.json');
+  const rootClaims = path.join(ROOT, "claims.json");
   if (fs.existsSync(rootClaims)) {
-    roots.push({ claimsPath: rootClaims, sprintPath: '.' });
+    roots.push({ claimsPath: rootClaims, sprintPath: "." });
   }
 
   // 2. Scan known subdirectories for sprint claims.json files
   //    Root claims.json should NOT prevent scanning subdirs
-  const scanDirs = ['examples', 'sprints', 'archive'];
+  const scanDirs = ["examples", "sprints", "archive"];
   for (const dirName of scanDirs) {
     const dir = path.join(ROOT, dirName);
     if (!fs.existsSync(dir)) continue;
     try {
       for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const claimsPath = path.join(dir, entry.name, 'claims.json');
+        const claimsPath = path.join(dir, entry.name, "claims.json");
         if (fs.existsSync(claimsPath)) {
           roots.push({
             claimsPath,
@@ -205,7 +212,9 @@ function findSprintRoots() {
           });
         }
       }
-    } catch { /* skip if unreadable */ }
+    } catch {
+      /* skip if unreadable */
+    }
   }
 
   return roots;
@@ -230,30 +239,32 @@ function analyzeSprint(root) {
   const commitCount = gitCommitCount(root.claimsPath);
 
   // Phase-based status inference
-  const phase = meta.phase || 'unknown';
-  const isArchived = phase === 'archived' || phase === 'complete';
-  const isExample = root.sprintPath.startsWith('examples' + path.sep) || root.sprintPath.startsWith('examples/');
+  const phase = meta.phase || "unknown";
+  const isArchived = phase === "archived" || phase === "complete";
+  const isExample =
+    root.sprintPath.startsWith("examples" + path.sep) ||
+    root.sprintPath.startsWith("examples/");
 
   // Compute status
   let status;
   if (isArchived) {
-    status = 'archived';
+    status = "archived";
   } else if (isExample) {
-    status = 'example';
+    status = "example";
   } else {
-    status = 'candidate'; // will be resolved to 'active' below
+    status = "candidate"; // will be resolved to 'active' below
   }
 
   return {
     name: deriveName(root.sprintPath, meta),
     path: root.sprintPath,
-    question: meta.question || '',
+    question: meta.question || "",
     phase,
     initiated: meta.initiated || null,
     last_git_activity: lastCommit,
     git_commit_count: commitCount,
     claims_count: claimsList.length,
-    active_claims: claimsList.filter(c => c.status === 'active').length,
+    active_claims: claimsList.filter((c) => c.status === "active").length,
     status,
   };
 }
@@ -274,20 +285,24 @@ export function detectSprints(rootDir) {
   resetGitCache();
   const roots = findSprintRoots();
 
-  // Batch all git queries upfront: 2 git calls instead of 2 per sprint
-  batchGitInfo(roots.map(r => r.claimsPath));
+  // Batch all git queries upfront: 1 git call instead of 2 per sprint
+  batchGitInfo(roots.map((r) => r.claimsPath));
 
   const sprints = roots.map(analyzeSprint).filter(Boolean);
 
   // Separate candidates from archived/examples
-  const candidates = sprints.filter(s => s.status === 'candidate');
-  const others = sprints.filter(s => s.status !== 'candidate');
+  const candidates = sprints.filter((s) => s.status === "candidate");
+  const others = sprints.filter((s) => s.status !== "candidate");
 
   // Rank candidates by git activity, then initiated date, then claim count
   candidates.sort((a, b) => {
     // Most recent git activity first
-    const dateA = a.last_git_activity ? new Date(a.last_git_activity).getTime() : 0;
-    const dateB = b.last_git_activity ? new Date(b.last_git_activity).getTime() : 0;
+    const dateA = a.last_git_activity
+      ? new Date(a.last_git_activity).getTime()
+      : 0;
+    const dateB = b.last_git_activity
+      ? new Date(b.last_git_activity).getTime()
+      : 0;
     if (dateB !== dateA) return dateB - dateA;
 
     // Most recent initiated date
@@ -302,30 +317,38 @@ export function detectSprints(rootDir) {
   // Top candidate is active
   let active = null;
   if (candidates.length > 0) {
-    candidates[0].status = 'active';
+    candidates[0].status = "active";
     active = candidates[0];
   }
 
   // If no root candidate, check examples — the one with most recent git activity
   if (!active && others.length > 0) {
-    const nonArchived = others.filter(s => s.status !== 'archived');
+    const nonArchived = others.filter((s) => s.status !== "archived");
     if (nonArchived.length > 0) {
       nonArchived.sort((a, b) => {
-        const dateA = a.last_git_activity ? new Date(a.last_git_activity).getTime() : 0;
-        const dateB = b.last_git_activity ? new Date(b.last_git_activity).getTime() : 0;
+        const dateA = a.last_git_activity
+          ? new Date(a.last_git_activity).getTime()
+          : 0;
+        const dateB = b.last_git_activity
+          ? new Date(b.last_git_activity).getTime()
+          : 0;
         return dateB - dateA;
       });
-      nonArchived[0].status = 'active';
+      nonArchived[0].status = "active";
       active = nonArchived[0];
     }
   }
 
   // Combine and sort: active first, then by last_git_activity
   const allSprints = [...candidates, ...others].sort((a, b) => {
-    if (a.status === 'active' && b.status !== 'active') return -1;
-    if (b.status === 'active' && a.status !== 'active') return 1;
-    const dateA = a.last_git_activity ? new Date(a.last_git_activity).getTime() : 0;
-    const dateB = b.last_git_activity ? new Date(b.last_git_activity).getTime() : 0;
+    if (a.status === "active" && b.status !== "active") return -1;
+    if (b.status === "active" && a.status !== "active") return 1;
+    const dateA = a.last_git_activity
+      ? new Date(a.last_git_activity).getTime()
+      : 0;
+    const dateB = b.last_git_activity
+      ? new Date(b.last_git_activity).getTime()
+      : 0;
     return dateB - dateA;
   });
 
@@ -336,12 +359,14 @@ export { findSprintRoots, analyzeSprint };
 
 // ─── CLI (only when run directly, not when imported) ──────────────────────────
 
-const isMain = process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+const isMain =
+  process.argv[1] &&
+  fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
 
 if (isMain) {
   const args = process.argv.slice(2);
 
-  if (args.includes('--help') || args.includes('-h')) {
+  if (args.includes("--help") || args.includes("-h")) {
     console.log(`detect-sprints.js — Git-based sprint detection (no config required)
 
 Usage:
@@ -355,23 +380,26 @@ Based on f001: config should not duplicate git-derivable state.`);
     process.exit(0);
   }
 
-  const rootIdx = args.indexOf('--root');
-  const rootArg = (rootIdx !== -1 && args[rootIdx + 1]) ? path.resolve(args[rootIdx + 1]) : undefined;
+  const rootIdx = args.indexOf("--root");
+  const rootArg =
+    rootIdx !== -1 && args[rootIdx + 1]
+      ? path.resolve(args[rootIdx + 1])
+      : undefined;
 
   const t0 = performance.now();
   const result = detectSprints(rootArg);
   const elapsed = (performance.now() - t0).toFixed(1);
 
-  if (args.includes('--json')) {
+  if (args.includes("--json")) {
     console.log(JSON.stringify(result, null, 2));
     process.exit(0);
   }
 
-  if (args.includes('--active')) {
+  if (args.includes("--active")) {
     if (result.active) {
       console.log(result.active.path);
     } else {
-      console.error('No active sprint detected.');
+      console.error("No active sprint detected.");
       process.exit(1);
     }
     process.exit(0);
@@ -379,26 +407,32 @@ Based on f001: config should not duplicate git-derivable state.`);
 
   // Human-readable output
   console.log(`Sprint Detection (${elapsed}ms)`);
-  console.log('='.repeat(50));
+  console.log("=".repeat(50));
   console.log(`Found ${result.sprints.length} sprint(s)\n`);
 
   for (const sprint of result.sprints) {
-    const icon = sprint.status === 'active' ? '>>>' : '   ';
+    const icon = sprint.status === "active" ? ">>>" : "   ";
     const statusTag = sprint.status.toUpperCase().padEnd(8);
     console.log(`${icon} [${statusTag}] ${sprint.name}`);
     console.log(`    Path:     ${sprint.path}`);
     console.log(`    Phase:    ${sprint.phase}`);
-    console.log(`    Claims:   ${sprint.claims_count} total, ${sprint.active_claims} active`);
-    console.log(`    Initiated: ${sprint.initiated || 'unknown'}`);
-    console.log(`    Last git:  ${sprint.last_git_activity || 'untracked'}`);
+    console.log(
+      `    Claims:   ${sprint.claims_count} total, ${sprint.active_claims} active`
+    );
+    console.log(`    Initiated: ${sprint.initiated || "unknown"}`);
+    console.log(`    Last git:  ${sprint.last_git_activity || "untracked"}`);
     console.log(`    Commits:   ${sprint.git_commit_count}`);
-    console.log(`    Question:  ${sprint.question.slice(0, 80)}${sprint.question.length > 80 ? '...' : ''}`);
+    console.log(
+      `    Question:  ${sprint.question.slice(0, 80)}${
+        sprint.question.length > 80 ? "..." : ""
+      }`
+    );
     console.log();
   }
 
   if (result.active) {
     console.log(`Active sprint: ${result.active.path} (${result.active.name})`);
   } else {
-    console.log('No active sprint detected.');
+    console.log("No active sprint detected.");
   }
 }