@girardmedia/bootspring 2.0.15 → 2.0.16

package/cli/build.js

@@ -84,8 +84,9 @@ async function run(args) {
     case 'complete':
       return markTaskDone(projectRoot, parsedArgs);
 
+    case 'loop':
     case 'all':
-      return buildAll(projectRoot, parsedArgs);
+      return buildLoop(projectRoot, parsedArgs);
 
     case 'help':
     case '-h':
@@ -102,7 +103,6 @@ async function run(args) {
  * Interactive build mode - guides user through options
  */
 async function interactiveBuild(projectRoot, args = {}) {
-  const readline = require('readline');
   const state = buildState.load(projectRoot);
 
   console.log(`
@@ -206,7 +206,7 @@ Some tasks may be blocked. Run ${c.cyan}bootspring build status${c.reset} for de
       return buildNextTask(projectRoot, args);
 
     case '2':
-      return buildAll(projectRoot, args);
+      return buildLoop(projectRoot, args);
 
     case '3':
       showCurrentTask(projectRoot, { prompt: true });
@@ -273,7 +273,7 @@ ${c.dim}When done, run: bootspring build done${c.reset}
 /**
  * Generate a prompt for Claude Code to execute
  */
-function generateTaskPrompt(task, projectRoot) {
+function _generateTaskPrompt(task, _projectRoot) {
   const lines = [];
 
   lines.push(`**Objective:** ${task.title}`);
@@ -331,6 +331,15 @@ async function markTaskDone(projectRoot, _args = {}) {
 
   console.log(`${c.green}✓${c.reset} Completed: ${c.bold}${inProgressTask.title}${c.reset}`);
 
+  // Check if loop mode is active - if so, commit and push
+  const loopState = loadLoopState(projectRoot);
+  if (loopState && loopState.active) {
+    await commitAndPush(projectRoot, inProgressTask, {
+      noCommit: loopState.noCommit,
+      noPush: loopState.noPush
+    });
+  }
+
   // Get stats
   const stats = buildState.getStats(projectRoot);
   console.log(`${c.dim}Progress: ${stats.completed}/${stats.total} tasks (${Math.round(stats.completedPercent)}%)${c.reset}`);
@@ -342,6 +351,15 @@ async function markTaskDone(projectRoot, _args = {}) {
     // Mark as in progress
     buildState.updateProgress(projectRoot, nextTask.id, 'in_progress');
 
+    // Update loop state with new task
+    if (loopState && loopState.active) {
+      saveLoopState(projectRoot, {
+        ...loopState,
+        currentTaskId: nextTask.id,
+        lastTaskCompletedAt: new Date().toISOString()
+      });
+    }
+
     console.log(`
 ${c.cyan}${c.bold}▶ Next: ${nextTask.title}${c.reset} (${nextTask.id})
 
@@ -349,6 +367,15 @@ ${c.bold}Continue building:${c.reset} Read planning/TASK_QUEUE.md, implement ${n
 ${c.dim}Then run: bootspring build done${c.reset}
 `);
   } else {
+    // Clear loop state - build complete
+    if (loopState && loopState.active) {
+      saveLoopState(projectRoot, {
+        ...loopState,
+        active: false,
+        completedAt: new Date().toISOString()
+      });
+    }
+
     console.log(`
 ${c.green}${c.bold}🎉 MVP BUILD COMPLETE!${c.reset}
 
@@ -363,34 +390,171 @@ ${c.bold}Next steps:${c.reset}
 }
 
 /**
- * Build all remaining tasks
+ * Build loop - autonomous task execution with commit/push after each task
+ *
+ * Usage:
+ *   bootspring build loop              # Start/resume the loop
+ *   bootspring build loop --no-push    # Commit but don't push
+ *   bootspring build loop --no-commit  # No git operations
  */
-async function buildAll(projectRoot, args = {}) {
+async function buildLoop(projectRoot, args = {}) {
   const state = buildState.load(projectRoot);
 
   if (!state) {
-    console.log(`${c.yellow}No build state found. Run 'bootspring build' to start.${c.reset}`);
+    console.log(`${c.yellow}No build state found. Run 'bootspring seed synthesize' first.${c.reset}`);
     return;
   }
 
   const stats = buildState.getStats(projectRoot);
+  const noCommit = args['no-commit'] || args.noCommit;
+  const noPush = args['no-push'] || args.noPush || noCommit;
+
+  // Check for in-progress task (crash recovery)
+  const inProgress = state.implementationQueue.find(t => t.status === 'in_progress');
+
+  if (inProgress) {
+    console.log(`
+${c.yellow}${c.bold}⚠ Resuming from crash${c.reset}
+
+Found in-progress task: ${c.cyan}${inProgress.title}${c.reset} (${inProgress.id})
+
+${c.dim}This task was in progress when the loop stopped.
+Continue implementing it, then run 'bootspring build done'.${c.reset}
+`);
+  } else {
+    // Queue next task
+    const nextTask = buildState.getNextTask(projectRoot);
+    if (!nextTask) {
+      console.log(`${c.green}${c.bold}🎉 All tasks complete!${c.reset}`);
+      return;
+    }
+    buildState.updateProgress(projectRoot, nextTask.id, 'in_progress');
+  }
+
+  const currentTask = state.implementationQueue.find(t => t.status === 'in_progress')
+    || buildState.getNextTask(projectRoot);
 
   console.log(`
-${c.cyan}${c.bold}Building all ${stats.pending} remaining tasks...${c.reset}
-${c.dim}Press Ctrl+C to stop at any time${c.reset}
+${c.cyan}${c.bold}⚡ Bootspring Build Loop${c.reset}
+
+${c.bold}Current Task:${c.reset} ${currentTask?.title || 'None'} (${currentTask?.id || '-'})
+${c.bold}Progress:${c.reset} ${stats.completed}/${stats.total} tasks (${Math.round(stats.completedPercent)}%)
+${c.bold}Git Mode:${c.reset} ${noCommit ? 'Disabled' : noPush ? 'Commit only' : 'Commit + Push'}
+
+${c.bold}Workflow:${c.reset}
+  1. Read planning/TASK_QUEUE.md, find ${currentTask?.id || 'current task'}
+  2. Implement the task
+  3. Run: ${c.cyan}bootspring build done${c.reset}${!noCommit ? `
+     (Auto-commits: "feat(${currentTask?.id}): ${currentTask?.title?.slice(0, 40) || 'task'}...")${!noPush ? `
+     (Auto-pushes to origin)` : ''}` : ''}
+  4. Continue to next task...
+
+${c.dim}Press Ctrl+C to stop. Run 'bootspring build loop' to resume.${c.reset}
 `);
 
-  // Start the full loop - force to clear any stale session
-  const loop = require('./loop');
-  await loop.runLoop(projectRoot, {
-    source: 'build',
-    iterations: args.iterations || 50,
-    live: true,  // Always show live output so user can see Claude working
-    verbose: args.verbose || args.v,
-    force: true  // Always force to avoid "session already running" issues
+  // Save loop state for crash recovery
+  saveLoopState(projectRoot, {
+    active: true,
+    startedAt: new Date().toISOString(),
+    noCommit,
+    noPush
   });
 }
 
+/**
+ * Save loop state for crash recovery
+ */
+function saveLoopState(projectRoot, state) {
+  const loopFile = path.join(projectRoot, '.bootspring', 'loop-state.json');
+  const dir = path.dirname(loopFile);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(loopFile, JSON.stringify(state, null, 2));
+}
+
+/**
+ * Load loop state
+ */
+function loadLoopState(projectRoot) {
+  const loopFile = path.join(projectRoot, '.bootspring', 'loop-state.json');
+  if (fs.existsSync(loopFile)) {
+    try {
+      return JSON.parse(fs.readFileSync(loopFile, 'utf-8'));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+/**
+ * Clear loop state (used when stopping or completing)
+ */
+function _clearLoopState(projectRoot) {
+  const loopFile = path.join(projectRoot, '.bootspring', 'loop-state.json');
+  if (fs.existsSync(loopFile)) {
+    fs.unlinkSync(loopFile);
+  }
+}
+
+/**
+ * Commit and push changes for a completed task
+ */
+async function commitAndPush(projectRoot, task, options = {}) {
+  const { noCommit, noPush } = options;
+
+  if (noCommit) return { committed: false, pushed: false };
+
+  const { execSync } = require('child_process');
+
+  try {
+    // Check if there are changes to commit
+    const status = execSync('git status --porcelain', { cwd: projectRoot, encoding: 'utf-8' });
+    if (!status.trim()) {
+      console.log(`${c.dim}No changes to commit${c.reset}`);
+      return { committed: false, pushed: false };
+    }
+
+    // Stage all changes
+    execSync('git add -A', { cwd: projectRoot });
+
+    // Create commit message
+    const shortTitle = task.title.length > 50 ? task.title.slice(0, 47) + '...' : task.title;
+    const commitMsg = `feat(${task.id}): ${shortTitle}
+
+Task: ${task.title}
+Phase: ${task.phase || 'MVP'}
+Source: ${task.source || 'planning'}
+
+Acceptance Criteria:
+${(task.acceptanceCriteria || []).map(ac => `- [x] ${ac}`).join('\n')}
+
+Built with Bootspring autonomous loop.`;
+
+    // Commit
+    execSync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { cwd: projectRoot });
+    console.log(`${c.green}✓${c.reset} Committed: ${c.bold}${task.id}${c.reset}`);
+
+    if (noPush) {
+      return { committed: true, pushed: false };
+    }
+
+    // Push
+    try {
+      execSync('git push', { cwd: projectRoot, stdio: 'pipe' });
+      console.log(`${c.green}✓${c.reset} Pushed to origin`);
+      return { committed: true, pushed: true };
+    } catch (pushError) {
+      console.log(`${c.yellow}⚠${c.reset} Push failed (commit saved locally): ${pushError.message}`);
+      return { committed: true, pushed: false };
+    }
+  } catch (error) {
+    console.log(`${c.yellow}⚠${c.reset} Git operation failed: ${error.message}`);
+    return { committed: false, pushed: false };
+  }
+}
+
 /**
  * Ask a question and get user input
  */
@@ -412,7 +576,7 @@ function askQuestion(question) {
 /**
  * Show build status
  */
-function showBuildStatus(projectRoot, args = {}) {
+function showBuildStatus(projectRoot, _args = {}) {
   const state = buildState.load(projectRoot);
 
   if (!state) {
@@ -476,7 +640,7 @@ ${c.bold}Loop Session${c.reset}
 /**
  * Show suggested next actions
  */
-function showNextActions(state, stats) {
+function showNextActions(state, _stats) {
   console.log(`${c.bold}Next Actions:${c.reset}`);
 
   if (state.status === 'paused') {
@@ -523,6 +687,16 @@ function pauseBuildLoop(projectRoot) {
 
   buildState.pause(projectRoot);
 
+  // Update loop state to inactive
+  const loopState = loadLoopState(projectRoot);
+  if (loopState) {
+    saveLoopState(projectRoot, {
+      ...loopState,
+      active: false,
+      pausedAt: new Date().toISOString()
+    });
+  }
+
   console.log(`
 ${c.green}Build paused.${c.reset}
 
@@ -555,14 +729,21 @@ function resumeBuildLoop(projectRoot) {
 
   buildState.resume(projectRoot);
 
+  // Restore loop state if it exists
+  const loopState = loadLoopState(projectRoot);
+  if (loopState) {
+    saveLoopState(projectRoot, {
+      ...loopState,
+      active: true,
+      resumedAt: new Date().toISOString()
+    });
+  }
+
   console.log(`
 ${c.green}Build resumed.${c.reset}
 
-To continue the build loop:
-  ${c.cyan}bootspring loop start --source=build${c.reset}
-
-Or start fresh:
-  ${c.cyan}bootspring seed build --loop${c.reset}
+Continue with: ${c.cyan}bootspring build next${c.reset}
+Or run loop: ${c.cyan}bootspring build loop${c.reset}
 `);
 }
 
@@ -769,18 +950,19 @@ ${c.cyan}${c.bold}Bootspring Build${c.reset}
 ${c.dim}Task-driven build system for Claude Code${c.reset}
 
 ${c.bold}Quick Start:${c.reset}
-  ${c.cyan}bootspring build${c.reset}       Interactive mode (recommended)
+  ${c.cyan}bootspring build next${c.reset}  Get next task and start building
 
 ${c.bold}Workflow:${c.reset}
-  1. Run ${c.cyan}bootspring build${c.reset} and select a task
-  2. Claude Code executes the task prompt
+  1. Run ${c.cyan}bootspring build next${c.reset} to get the next task
+  2. Implement the task in your codebase
   3. Run ${c.cyan}bootspring build done${c.reset} when complete
   4. Repeat until MVP is complete
 
 ${c.bold}Commands:${c.reset}
   ${c.cyan}bootspring build${c.reset}           Start interactive build
-  ${c.cyan}bootspring build next${c.reset}      Show next task prompt
+  ${c.cyan}bootspring build next${c.reset}      Get next task (start here!)
   ${c.cyan}bootspring build done${c.reset}      Mark current task complete
+  ${c.cyan}bootspring build loop${c.reset}      Start autonomous loop (commit+push each task)
   ${c.cyan}bootspring build skip${c.reset}      Skip current task
   ${c.cyan}bootspring build stop${c.reset}      Graceful stop (finish current task, then pause)
   ${c.cyan}bootspring build status${c.reset}    View detailed progress
@@ -788,7 +970,12 @@ ${c.bold}Commands:${c.reset}
   ${c.cyan}bootspring build plan${c.reset}      View the full master plan
   ${c.cyan}bootspring build reset${c.reset}     Start over
 
-${c.bold}Options:${c.reset}
+${c.bold}Loop Options:${c.reset}
+  ${c.cyan}bootspring build loop${c.reset}              Commit + push after each task
+  ${c.cyan}bootspring build loop --no-push${c.reset}    Commit only (no push)
+  ${c.cyan}bootspring build loop --no-commit${c.reset}  No git operations
+
+${c.bold}Other Options:${c.reset}
   --prompt          Show AI prompt for current task
   --force           Force reset even if in progress
 `);

package/mcp/contracts/mcp-contract.v1.json

@@ -1,7 +1,7 @@
 {
   "contractVersion": "v1",
   "packageName": "@girardmedia/bootspring",
-  "packageVersion": "2.0.15",
+  "packageVersion": "2.0.16",
   "tools": [
     {
       "name": "bootspring_assist",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girardmedia/bootspring",
-  "version": "2.0.15",
+  "version": "2.0.16",
   "description": "Development scaffolding with intelligence - AI-powered context, agents, and workflows for any MCP-compatible assistant",
   "keywords": [
     "ai",