@grainulation/wheat 1.0.1 → 1.0.3

package/compiler/detect-sprints.js

@@ -47,11 +47,76 @@ function loadJSON(filePath) {
   }
 }
 
+/**
+ * Batch git queries for all sprint files at once.
+ * 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;
+
+function batchGitInfo(filePaths) {
+  if (_gitCache) return _gitCache;
+  const info = new Map();
+  // Build a map from relative path (as git returns it) back to original filePath
+  const relToOrig = new Map();
+  const relPaths = [];
+  for (const fp of filePaths) {
+    const rel = path.relative(ROOT, path.resolve(ROOT, fp));
+    relToOrig.set(rel, fp);
+    relPaths.push(rel);
+    info.set(fp, { date: null, count: 0 });
+  }
+
+  if (filePaths.length === 0) { _gitCache = info; return info; }
+
+  // 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=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;
+      if (trimmed.startsWith('COMMIT ')) {
+        currentDate = trimmed.slice(7);
+      } else {
+        const orig = relToOrig.get(trimmed);
+        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, counts stay 0 */ }
+
+  _gitCache = info;
+  return info;
+}
+
+/** Reset git cache (called when ROOT changes). */
+function resetGitCache() { _gitCache = null; }
+
 /**
  * Get the ISO timestamp of the most recent git commit touching a file.
  * Returns null if file is untracked or git is unavailable.
+ * Uses batch cache when available.
  */
 function lastGitCommitDate(filePath) {
+  if (_gitCache) {
+    const entry = _gitCache.get(filePath);
+    return entry ? entry.date : null;
+  }
   try {
     const result = execFileSync('git', [
       'log', '-1', '--format=%aI', '--', filePath
@@ -65,8 +130,13 @@ function lastGitCommitDate(filePath) {
 
 /**
  * Count git commits touching a file (proxy for activity level).
+ * Uses batch cache when available.
  */
 function gitCommitCount(filePath) {
+  if (_gitCache) {
+    const entry = _gitCache.get(filePath);
+    return entry ? entry.count : 0;
+  }
   try {
     const result = execFileSync('git', [
       'rev-list', '--count', 'HEAD', '--', filePath
@@ -193,7 +263,12 @@ function analyzeSprint(root) {
  */
 export function detectSprints(rootDir) {
   if (rootDir) ROOT = rootDir;
+  resetGitCache();
   const roots = findSprintRoots();
+
+  // 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

package/compiler/generate-manifest.js

@@ -13,7 +13,7 @@
 
 import fs from 'fs';
 import path from 'path';
-import { execFileSync } from 'child_process';
+
 import { fileURLToPath } from 'url';
 import { detectSprints } from './detect-sprints.js';
 
@@ -98,6 +98,27 @@ export function highestEvidence(claims) {
  * Falls back to a minimal scan if detect-sprints.js is unavailable.
  */
 function detectSprintsForManifest() {
+  // Check for cached sprint data from compiler (avoids re-running detectSprints)
+  if (process.env.WHEAT_SPRINTS_CACHE) {
+    try {
+      const parsed = JSON.parse(process.env.WHEAT_SPRINTS_CACHE);
+      const sprints = {};
+      for (const s of (parsed.sprints || [])) {
+        sprints[s.name] = {
+          question: s.question || '',
+          phase: s.phase || 'unknown',
+          claims_count: s.claims_count || 0,
+          active_claims: s.active_claims || 0,
+          path: s.path,
+          status: s.status,
+          last_git_activity: s.last_git_activity,
+          git_commit_count: s.git_commit_count,
+        };
+      }
+      return sprints;
+    } catch { /* fall through to live detection */ }
+  }
+
   // Try to use the exported function directly
   try {
     const parsed = detectSprints(ROOT);
@@ -148,20 +169,21 @@ function detectSprintsForManifest() {
   return sprints;
 }
 
-// --- Main (only when run directly) ---
+// --- Callable manifest generation ---
 
-const isMain = process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
-
-if (isMain) {
-  const t0 = performance.now();
-
-  const claims = loadJSON(path.join(ROOT, 'claims.json'));
-  const compilation = loadJSON(path.join(ROOT, 'compilation.json'));
+/**
+ * Generate the manifest. Can be called directly (no subprocess needed).
+ * @param {string} dir - Root directory of the sprint
+ * @param {object} [opts] - Options
+ * @param {object} [opts.sprintsInfo] - Pre-computed sprint data (avoids re-running detectSprints)
+ * @returns {{ manifest: object, topicCount: number, fileCount: number, sprintCount: number }}
+ */
+export function buildManifest(dir, opts = {}) {
+  const rootDir = dir || ROOT;
+  const claims = loadJSON(path.join(rootDir, 'claims.json'));
+  const compilation = loadJSON(path.join(rootDir, 'compilation.json'));
 
-  if (!claims) {
-    console.error('Error: claims.json not found or invalid at', path.join(ROOT, 'claims.json'));
-    process.exit(1);
-  }
+  if (!claims) return null;
 
   // 1. Build topic map from claims
   const topicMap = {};
@@ -183,8 +205,8 @@ if (isMain) {
   const scanDirs = ['research', 'prototypes', 'output', 'evidence', 'templates', 'test', 'docs'];
   const allFiles = {};
 
-  for (const dir of scanDirs) {
-    const files = walk(path.join(ROOT, dir));
+  for (const d of scanDirs) {
+    const files = walk(path.join(rootDir, d));
     for (const f of files) {
       const type = classifyFile(f);
       allFiles[f] = { topics: [], type };
@@ -192,18 +214,20 @@ if (isMain) {
   }
 
   // Also include root-level scripts/configs
-  for (const entry of fs.readdirSync(ROOT)) {
-    if (entry.startsWith('.') || entry === 'node_modules') continue;
-    const full = path.join(ROOT, entry);
-    try {
-      if (fs.statSync(full).isFile()) {
-        const type = classifyFile(entry);
-        if (type !== 'other') {
-          allFiles[entry] = { topics: [], type };
+  try {
+    for (const entry of fs.readdirSync(rootDir)) {
+      if (entry.startsWith('.') || entry === 'node_modules') continue;
+      const full = path.join(rootDir, entry);
+      try {
+        if (fs.statSync(full).isFile()) {
+          const type = classifyFile(entry);
+          if (type !== 'other') {
+            allFiles[entry] = { topics: [], type };
+          }
         }
-      }
-    } catch { /* skip */ }
-  }
+      } catch { /* skip */ }
+    }
+  } catch { /* skip */ }
 
   // 3. Map files to topics using claim source artifacts and keyword heuristics
   const topicKeywords = {
@@ -217,14 +241,12 @@ if (isMain) {
   for (const [filePath, fileInfo] of Object.entries(allFiles)) {
     const lower = filePath.toLowerCase();
 
-    // Heuristic: match file paths to topics via keywords
     for (const [topic, keywords] of Object.entries(topicKeywords)) {
       if (keywords.some(kw => lower.includes(kw))) {
         if (!fileInfo.topics.includes(topic)) fileInfo.topics.push(topic);
       }
     }
 
-    // Claims that reference files as artifacts
     for (const claim of claims.claims) {
       if (claim.source?.artifact && filePath.includes(claim.source.artifact.replace(/^.*[/\\]prototypes[/\\]/, 'prototypes/'))) {
         if (!fileInfo.topics.includes(claim.topic)) {
@@ -233,7 +255,6 @@ if (isMain) {
       }
     }
 
-    // Add files to topic map
     for (const topic of fileInfo.topics) {
       if (topicMap[topic]) {
         topicMap[topic].files.add(filePath);
@@ -246,14 +267,31 @@ if (isMain) {
     topicMap[topic].files = [...topicMap[topic].files].sort();
   }
 
-  // 5. Detect sprints
-  const sprints = detectSprintsForManifest();
+  // 5. Detect sprints (use cached data if provided)
+  let sprints;
+  if (opts.sprintsInfo) {
+    sprints = {};
+    for (const s of (opts.sprintsInfo.sprints || [])) {
+      sprints[s.name] = {
+        question: s.question || '',
+        phase: s.phase || 'unknown',
+        claims_count: s.claims_count || 0,
+        active_claims: s.active_claims || 0,
+        path: s.path,
+        status: s.status,
+        last_git_activity: s.last_git_activity,
+        git_commit_count: s.git_commit_count,
+      };
+    }
+  } else {
+    sprints = detectSprintsForManifest();
+  }
 
   // 6. Build final manifest
   const topicFiles = {};
-  for (const [filePath, info] of Object.entries(allFiles)) {
-    if (info.topics.length > 0) {
-      topicFiles[filePath] = info;
+  for (const [filePath, mInfo] of Object.entries(allFiles)) {
+    if (mInfo.topics.length > 0) {
+      topicFiles[filePath] = mInfo;
     }
   }
 
@@ -266,15 +304,32 @@ if (isMain) {
     files: topicFiles
   };
 
-  fs.writeFileSync(OUT_PATH, JSON.stringify(manifest, null, 2) + '\n');
-  const elapsed = (performance.now() - t0).toFixed(1);
+  const outPath = path.join(rootDir, 'wheat-manifest.json');
+  fs.writeFileSync(outPath, JSON.stringify(manifest, null, 2) + '\n');
+
+  return {
+    manifest,
+    topicCount: Object.keys(topicMap).length,
+    fileCount: Object.keys(topicFiles).length,
+    sprintCount: Object.keys(sprints).length,
+  };
+}
+
+// --- Main (only when run directly) ---
+
+const isMain = process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+
+if (isMain) {
+  const t0 = performance.now();
 
-  // Summary
-  const topicCount = Object.keys(topicMap).length;
-  const fileCount = Object.keys(topicFiles).length;
-  const sprintCount = Object.keys(sprints).length;
-  const sizeBytes = Buffer.byteLength(JSON.stringify(manifest, null, 2));
+  const result = buildManifest(ROOT);
+  if (!result) {
+    console.error('Error: claims.json not found or invalid at', path.join(ROOT, 'claims.json'));
+    process.exit(1);
+  }
 
+  const elapsed = (performance.now() - t0).toFixed(1);
+  const sizeBytes = Buffer.byteLength(JSON.stringify(result.manifest, null, 2));
   console.log(`wheat-manifest.json generated in ${elapsed}ms`);
-  console.log(`  Topics: ${topicCount}  |  Files: ${fileCount}  |  Sprints: ${sprintCount}  |  Size: ${(sizeBytes / 1024).toFixed(1)}KB`);
+  console.log(`  Topics: ${result.topicCount}  |  Files: ${result.fileCount}  |  Sprints: ${result.sprintCount}  |  Size: ${(sizeBytes / 1024).toFixed(1)}KB`);
 }

package/compiler/wheat-compiler.js

@@ -17,11 +17,13 @@
 import fs from 'fs';
 import crypto from 'crypto';
 import path from 'path';
-import { execFileSync } from 'child_process';
+
 import { fileURLToPath } from 'url';
 
 // Sprint detection — git-based, no config pointer needed (p013/f001)
 import { detectSprints } from './detect-sprints.js';
+// Direct manifest generation — avoids subprocess + redundant detectSprints call
+import { buildManifest } from './generate-manifest.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -570,33 +572,21 @@ function diffCompilations(before, after) {
 
 // ─── Manifest Generation (topic map) ─────────────────────────────────────────
 /**
- * Run generate-manifest.js to produce wheat-manifest.json.
- * Called automatically after each compilation. Failures are non-fatal
- * (manifest is an optimization, not a correctness requirement).
- * @param {object} compilation - The compiled output (unused, but available for future use)
+ * Generate wheat-manifest.json by calling buildManifest() directly.
+ * No subprocess — reuses the already-imported module and sprint data.
+ * Failures are non-fatal (manifest is an optimization, not a correctness requirement).
  */
-function generateManifest(compilation, dir) {
+function generateManifest(compilation, dir, sprintsInfo) {
   const baseDir = dir || TARGET_DIR;
-  const manifestScript = path.join(baseDir, 'generate-manifest.js');
-  if (!fs.existsSync(manifestScript)) {
-    // Manifest generator not present — skip silently
-    return;
-  }
   try {
-    const result = execFileSync(process.execPath, [manifestScript], {
-      cwd: baseDir,
-      timeout: 10000,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    // Print manifest summary on --summary runs (stdout captured above)
-    const output = result.toString().trim();
-    if (output && process.argv.includes('--summary')) {
-      console.log(`\nManifest: ${output}`);
+    const result = buildManifest(baseDir, { sprintsInfo });
+    if (result && process.argv.includes('--summary')) {
+      console.log(`\nManifest: wheat-manifest.json generated`);
+      console.log(`  Topics: ${result.topicCount}  |  Files: ${result.fileCount}  |  Sprints: ${result.sprintCount}`);
     }
   } catch (err) {
     // Non-fatal: warn but don't block compilation
-    const stderr = err.stderr ? err.stderr.toString().trim() : err.message;
-    console.error(`Warning: manifest generation failed — ${stderr}`);
+    console.error(`Warning: manifest generation failed — ${err.message}`);
   }
 }
 
@@ -607,7 +597,7 @@ function generateManifest(compilation, dir) {
  * @param {string|null} outputPath - Path to write compilation.json (null = default from config)
  * @returns {object} The compiled output object
  */
-function compile(inputPath, outputPath, dir) {
+function compile(inputPath, outputPath, dir, opts = {}) {
   const compilerVersion = '0.2.0';
   const baseDir = dir || TARGET_DIR;
   const claimsPath = inputPath || path.join(baseDir, config.compiler.claims);
@@ -671,25 +661,28 @@ function compile(inputPath, outputPath, dir) {
 
   // ── Sprint detection (git-based, non-fatal) ──────────────────────────────
   let sprintsInfo = { active: null, sprints: [] };
-  try {
-    sprintsInfo = detectSprints(baseDir);
-  } catch (err) {
-    // Non-fatal: sprint detection failure should not block compilation
-    console.error(`Warning: sprint detection failed — ${err.message}`);
-  }
+  let sprintSummaries = [];
+  if (!opts.skipSprintDetection) {
+    try {
+      sprintsInfo = detectSprints(baseDir);
+    } catch (err) {
+      // Non-fatal: sprint detection failure should not block compilation
+      console.error(`Warning: sprint detection failed — ${err.message}`);
+    }
 
-  // Build sprint summaries: active sprint gets full compilation, others get summary entries
-  const sprintSummaries = sprintsInfo.sprints.map(s => ({
-    name: s.name,
-    path: s.path,
-    status: s.status,
-    phase: s.phase,
-    question: s.question,
-    claims_count: s.claims_count,
-    active_claims: s.active_claims,
-    last_git_activity: s.last_git_activity,
-    git_commit_count: s.git_commit_count,
-  }));
+    // Build sprint summaries: active sprint gets full compilation, others get summary entries
+    sprintSummaries = sprintsInfo.sprints.map(s => ({
+      name: s.name,
+      path: s.path,
+      status: s.status,
+      phase: s.phase,
+      question: s.question,
+      claims_count: s.claims_count,
+      active_claims: s.active_claims,
+      last_git_activity: s.last_git_activity,
+      git_commit_count: s.git_commit_count,
+    }));
+  }
 
   const compilation = {
     compiled_at: new Date().toISOString(),  // Non-deterministic metadata (excluded from certificate)
@@ -698,7 +691,12 @@ function compile(inputPath, outputPath, dir) {
     status,
     errors: readiness.blockers,
     warnings: readiness.warnings,
-    resolved_claims: resolvedClaims,
+    resolved_claims: resolvedClaims.map(c => ({
+      id: c.id, type: c.type, topic: c.topic,
+      evidence: c.evidence, status: c.status, phase_added: c.phase_added,
+      source: c.source, conflicts_with: c.conflicts_with, resolved_by: c.resolved_by,
+      tags: c.tags,
+    })),
     conflict_graph: conflictGraph,
     coverage: coverageResult.coverage,
     corroboration: coverageResult.corroboration,
@@ -722,7 +720,10 @@ function compile(inputPath, outputPath, dir) {
   fs.writeFileSync(compilationOutputPath, JSON.stringify(compilation, null, 2));
 
   // Generate topic-map manifest (wheat-manifest.json)
-  generateManifest(compilation, baseDir);
+  // Pass sprintsInfo to avoid re-running detectSprints in manifest generator
+  if (!opts.skipSprintDetection) {
+    generateManifest(compilation, baseDir, sprintsInfo);
+  }
 
   return compilation;
 }
@@ -788,6 +789,7 @@ Usage:
 
 Options:
   --dir <path>  Resolve all paths relative to <path> instead of script location
+  --quiet, -q   One-liner output (for scripts and AI agents)
   --help, -h    Show this help message
   --json        Output as JSON (works with --summary, --check, --gate, --scan, --next)`);
   process.exit(0);
@@ -864,8 +866,31 @@ if (outputIdx !== -1 && args[outputIdx + 1]) {
   outputPath = path.resolve(args[outputIdx + 1]);
 }
 
-const compilation = compile(inputPath, outputPath);
 const jsonFlag = args.includes('--json');
+const quietFlag = args.includes('--quiet') || args.includes('-q');
+const compilation = compile(inputPath, outputPath, undefined, { skipSprintDetection: quietFlag && !args.includes('--summary') });
+
+// --quiet / -q: one-liner output for scripts and AI agents (~13 tokens vs ~4,600)
+if (quietFlag && !args.includes('--summary')) {
+  const c = compilation;
+  const conflicts = c.sprint_meta.conflicted_claims || 0;
+  const suffix = conflicts > 0 ? ` (${conflicts} conflicts)` : '';
+  const line = `wheat: compiled ${c.sprint_meta.total_claims} claims, ${Object.keys(c.coverage).length} topics${suffix}`;
+  if (jsonFlag) {
+    console.log(JSON.stringify({
+      status: c.status,
+      claims: c.sprint_meta.total_claims,
+      active: c.sprint_meta.active_claims,
+      conflicts,
+      topics: Object.keys(c.coverage).length,
+      errors: c.errors.length,
+      warnings: c.warnings.length,
+    }));
+  } else {
+    console.log(line);
+  }
+  process.exit(c.status === 'blocked' ? 1 : 0);
+}
 
 if (args.includes('--summary')) {
   const c = compilation;

package/lib/serve-mcp.js

@@ -37,7 +37,7 @@ const __dirname = path.dirname(__filename);
 // --- Constants ---------------------------------------------------------------
 
 const SERVER_NAME = 'wheat';
-const SERVER_VERSION = '1.0.0';
+const SERVER_VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version;
 const PROTOCOL_VERSION = '2024-11-05';
 
 const VALID_TYPES = ['constraint', 'factual', 'estimate', 'risk', 'recommendation', 'feedback'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@grainulation/wheat",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Research-driven development framework — structured claims, compiled evidence, deterministic output",
   "license": "MIT",
   "author": "grainulation contributors",

package/templates/commands/brief.md

@@ -2,6 +2,8 @@
 
 You are compiling the final decision brief for this Wheat sprint. This is the Bran compilation step — deterministic output from resolved claims.
 
+**Default behavior:** Generate next steps only (fast). The full brief is opt-in via `--full`.
+
 ## Process
 
 1. **Run the compiler with check**:
@@ -15,9 +17,17 @@ You are compiling the final decision brief for this Wheat sprint. This is the Br
    - Suggest specific commands to fix each blocker
    - Do NOT proceed until compilation passes
 
-2. **Read compilation.json** — use ONLY `resolved_claims` as your source material. Never read claims.json directly for the brief.
+2. **Always: Generate next steps** — Read compilation.json, summarize sprint state (claim counts, conflicts, coverage), and suggest 2-4 concrete next actions. Then run `/next` to route through Farmer.
+
+3. **If `--full` flag is passed OR user explicitly asks for the brief:** Launch brief generation as a background agent so it's non-blocking. The user continues deciding next steps while the brief builds.
+
+   To launch in background: use the Agent tool with `run_in_background: true` to generate the full brief (steps 4-7 below). Tell the user "Brief generating in background — I'll let you know when it's ready."
+
+   If no `--full` flag, skip steps 4-7 entirely.
 
-3. **Generate the brief as markdown**: Create `output/brief.md` with this structure:
+4. **Read compilation.json** — use ONLY `resolved_claims` as your source material. Never read claims.json directly for the brief.
+
+5. **Generate the brief as markdown**: Create `output/brief.md` with this structure:
 
    ```markdown
    # Decision Brief: [Sprint Question]
@@ -47,7 +57,12 @@ You are compiling the final decision brief for this Wheat sprint. This is the Br
    Compilation certificate: [hash] | Compiler: wheat v[version] | Claims: [count] | Compiled: [timestamp]
    ```
 
-4. **Also generate brief as HTML**: Create `output/brief.html` — a clean, print-friendly HTML version for browser viewing.
+6. **Generate PDF** (if build-pdf.js exists):
+   ```bash
+   node build-pdf.js output/brief.md
+   ```
+
+7. **Also generate brief as HTML**: Create `output/brief.html` — a clean, print-friendly HTML version for browser viewing.
 
 ## Key rules
 
@@ -64,9 +79,10 @@ Commit: `wheat: /brief compiled — [total] claims, [conflicts resolved] conflic
 
 ## Tell the user
 
-- The brief is ready at `output/brief.md` and `output/brief.html`
+- If next-steps only: show the sprint summary and route via `/next`
+- If `--full`: confirm brief is generating in background, show next steps immediately
+- When brief completes: notify with paths to `output/brief.md` and `output/brief.html`
 - Show the compilation certificate
-- Remind them they can share these with stakeholders
 - Mention `/present` if they need a presentation version
 - Mention `/feedback` for incorporating stakeholder responses