gbos 1.4.1 → 1.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gbos",
-  "version": "1.4.1",
+  "version": "1.4.5",
   "description": "GBOS - Command line interface for GBOS services",
   "main": "src/index.js",
   "bin": {

package/src/cli.js

@@ -146,6 +146,9 @@ program
   .option('-c, --continuous', 'Continuously process tasks')
   .option('-n, --max-tasks <number>', 'Maximum tasks to process', '1')
   .option('--show-prompt', 'Show the generated prompt')
+  .option('--skip-verification', 'Skip post-processing and test verification')
+  .option('--skip-git', 'Skip git commit and push')
+  .option('--task-id <id>', 'Run a specific task by ID')
   .action(startCommand);
 
 program

package/src/commands/orchestrator.js

@@ -1,15 +1,21 @@
 /**
  * Orchestrator Commands
  * CLI commands for start, resume, and stop
+ * Beautiful terminal output with real-time agent streaming
  */
 
 const config = require('../lib/config');
+const api = require('../lib/api');
 const { displayMessageBox, fg, LOGO_PURPLE, RESET, BOLD, DIM, getTerminalWidth } = require('../lib/display');
 const Orchestrator = require('../orchestrator/orchestrator');
 const { StateMachine, STATES, RUNS_DIR } = require('../orchestrator/state-machine');
 const { checkInstalledAdapters } = require('../orchestrator/adapters');
 const fs = require('fs');
 const path = require('path');
+const readline = require('readline');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
 
 // Colors
 const GREEN = '\x1b[32m';
@@ -17,6 +23,134 @@ const YELLOW = '\x1b[33m';
 const RED = '\x1b[31m';
 const CYAN = '\x1b[36m';
 
+// Spinner characters
+const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+function createSpinner(text) {
+  let i = 0;
+  const interval = setInterval(() => {
+    process.stdout.write(`\r  ${CYAN}${SPINNER[i % SPINNER.length]}${RESET} ${text}`);
+    i++;
+  }, 80);
+  return {
+    stop: (finalText) => {
+      clearInterval(interval);
+      process.stdout.write(`\r  ${GREEN}✓${RESET} ${finalText || text}\n`);
+    },
+    fail: (finalText) => {
+      clearInterval(interval);
+      process.stdout.write(`\r  ${RED}✗${RESET} ${finalText || text}\n`);
+    },
+  };
+}
+
+/**
+ * Prompt user for yes/no confirmation
+ */
+function promptConfirm(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(`  ${CYAN}?${RESET} ${question} ${DIM}(y/N)${RESET}: `, (answer) => {
+      rl.close();
+      const lower = answer.trim().toLowerCase();
+      resolve(lower === 'y' || lower === 'yes');
+    });
+  });
+}
+
+/**
+ * Check if directory is a git repo with a matching remote
+ */
+async function isMatchingGitRepo(dir, repoUrl) {
+  try {
+    const { stdout } = await execAsync('git remote get-url origin', { cwd: dir });
+    const currentUrl = stdout.trim();
+    const normalize = (url) => url
+      .replace(/\.git$/, '')
+      .replace(/^git@([^:]+):/, 'https://$1/')
+      .replace(/^https?:\/\//, '')
+      .toLowerCase();
+    return normalize(currentUrl) === normalize(repoUrl);
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Check if a directory is empty (ignoring hidden files like .DS_Store)
+ */
+function isDirEmpty(dir) {
+  if (!fs.existsSync(dir)) return true;
+  const entries = fs.readdirSync(dir).filter(f => f !== '.DS_Store');
+  return entries.length === 0;
+}
+
+/**
+ * Pre-check workspace: ensure CWD is the app's repo or offer to initialize
+ * Returns the working directory to use, or null to abort
+ */
+async function preCheckWorkspace(connection) {
+  const currentDir = process.cwd();
+
+  // Get application details to find the repo URL
+  let app = connection.application;
+  if (app?.id) {
+    try {
+      const response = await api.getApplication(app.id);
+      app = response.data || response;
+    } catch (e) {
+      // Use connection's app data
+    }
+  }
+
+  const repoUrl = app?.gitlab_repo_url || app?.repo_url || app?.repository_url;
+
+  // If no repo URL configured, use CWD as local-only workspace
+  if (!repoUrl) {
+    console.log(`  ${DIM}No repository configured - using local workspace${RESET}`);
+    return currentDir;
+  }
+
+  // Check if CWD is already the matching repo
+  const isMatching = await isMatchingGitRepo(currentDir, repoUrl);
+  if (isMatching) {
+    console.log(`  ${GREEN}✓${RESET} Current directory matches app repository`);
+    return currentDir;
+  }
+
+  // CWD doesn't match - check if it's empty
+  const empty = isDirEmpty(currentDir);
+
+  if (!empty) {
+    // Directory is not empty and not the repo
+    console.log(`  ${RED}✗${RESET} Current directory is not the app's GitLab repository`);
+    console.log(`    ${DIM}Expected repo: ${repoUrl}${RESET}`);
+    console.log(`    ${DIM}Current dir: ${currentDir}${RESET}\n`);
+    console.log(`  ${YELLOW}!${RESET} To use this directory, it must either be:`);
+    console.log(`    1. The root of the GitLab repository (clone it first)`);
+    console.log(`    2. An empty folder (GBOS will initialize the repo for you)\n`);
+    return null;
+  }
+
+  // Directory is empty - offer to initialize
+  console.log(`  ${YELLOW}!${RESET} Current directory is empty and not a git repository`);
+  console.log(`    ${DIM}App repo: ${repoUrl}${RESET}`);
+  console.log(`    ${DIM}Current dir: ${currentDir}${RESET}\n`);
+
+  const confirmed = await promptConfirm(`Initialize GitLab repository for "${app.name || 'this app'}" in this directory?`);
+
+  if (!confirmed) {
+    console.log(`\n  ${DIM}Aborted. Navigate to the correct repo directory or use an empty folder.${RESET}\n`);
+    return null;
+  }
+
+  console.log('');
+  return currentDir;
+}
+
 /**
  * gbos start - Start the orchestrator
  */
@@ -50,8 +184,16 @@ async function startCommand(options) {
     return;
   }
 
+  // Pre-check workspace (unless --dir is explicitly provided)
+  let workingDir = options.dir ? path.resolve(options.dir) : null;
+  if (!workingDir) {
+    workingDir = await preCheckWorkspace(connection);
+    if (workingDir === null) {
+      process.exit(1);
+    }
+  }
+
   // Check agent availability
-  console.log(`  ${DIM}Checking agent availability...${RESET}`);
   const adapters = await checkInstalledAdapters();
   const agentName = options.agent || 'claude-code';
   const agentInfo = adapters[agentName] || adapters['claude-code'];
@@ -69,28 +211,82 @@ async function startCommand(options) {
   // Create orchestrator
   const orchestrator = new Orchestrator({
     agent: agentName,
-    autoApprove: options.autoApprove || false,
+    autoApprove: options.autoApprove !== false,
     createMR: options.mr !== false,
     continuous: options.continuous || false,
     maxTasks: options.maxTasks ? parseInt(options.maxTasks) : 1,
-    workingDir: options.dir ? path.resolve(options.dir) : null,
+    workingDir: workingDir,
+    skipVerification: options.skipVerification || false,
+    skipGit: options.skipGit || false,
+    taskId: options.taskId || null,
   });
 
+  // Track active spinner
+  let activeSpinner = null;
+
   // Set up event handlers
   orchestrator.on('started', ({ runId }) => {
-    console.log(`  ${GREEN}✓${RESET} Run started: ${runId}\n`);
+    console.log(`  ${GREEN}✓${RESET} Run started: ${DIM}${runId}${RESET}\n`);
   });
 
   orchestrator.on('stage', ({ stage }) => {
-    console.log(`  ${CYAN}▸${RESET} ${stage.replace(/_/g, ' ')}`);
+    // Stop any active spinner
+    if (activeSpinner) {
+      activeSpinner.stop();
+      activeSpinner = null;
+    }
+
+    const stageLabels = {
+      auth_config: 'Authenticating & configuring',
+      workspace_ready: 'Preparing workspace',
+      fetch_task: 'Fetching next task',
+      generate_prompt: 'Generating agent prompt',
+      run_agent: null, // handled by agent_start
+      post_process: 'Post-processing',
+      run_tests: 'Running tests',
+      commit_push: 'Committing & pushing',
+      report_status: 'Reporting status to GBOS',
+    };
+
+    const label = stageLabels[stage];
+    if (label) {
+      activeSpinner = createSpinner(label);
+    }
+  });
+
+  orchestrator.on('agent_start', ({ agent }) => {
+    if (activeSpinner) {
+      activeSpinner.stop();
+      activeSpinner = null;
+    }
+    console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+    console.log(`${BOLD}  Agent Output${RESET} ${DIM}(${agent})${RESET}`);
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+  });
+
+  orchestrator.on('agent_done', ({ exitCode }) => {
+    console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+    if (exitCode === 0) {
+      console.log(`  ${GREEN}✓${RESET} Agent completed successfully`);
+    } else {
+      console.log(`  ${YELLOW}!${RESET} Agent exited with code ${exitCode}`);
+    }
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
   });
 
   orchestrator.on('log', ({ message }) => {
-    console.log(`    ${DIM}${message}${RESET}`);
+    // Only show important logs, not during spinner stages
+    if (!activeSpinner) {
+      // Don't print "Stage: X" logs since we handle those with spinners
+      if (!message.startsWith('Stage:')) {
+        console.log(`    ${DIM}${message}${RESET}`);
+      }
+    }
   });
 
   orchestrator.on('prompt', ({ prompt }) => {
     if (options.showPrompt) {
+      if (activeSpinner) { activeSpinner.stop(); activeSpinner = null; }
       console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
       console.log(`${BOLD}  Task Prompt${RESET}`);
       console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
@@ -100,6 +296,7 @@ async function startCommand(options) {
   });
 
   orchestrator.on('committed', (result) => {
+    if (activeSpinner) { activeSpinner.stop(); activeSpinner = null; }
     if (result.commit) {
       console.log(`    ${GREEN}✓${RESET} Committed: ${result.commit.shortHash}`);
     }
@@ -109,6 +306,7 @@ async function startCommand(options) {
   });
 
   orchestrator.on('completed', ({ tasksCompleted }) => {
+    if (activeSpinner) { activeSpinner.stop(); activeSpinner = null; }
     console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
     console.log(`${GREEN}✓${RESET} ${BOLD}Orchestrator completed${RESET}`);
     console.log(`  ${DIM}Tasks completed: ${tasksCompleted}${RESET}`);
@@ -116,12 +314,14 @@ async function startCommand(options) {
   });
 
   orchestrator.on('failed', ({ error }) => {
+    if (activeSpinner) { activeSpinner.fail(); activeSpinner = null; }
     console.log(`\n${RED}✗${RESET} ${BOLD}Orchestrator failed${RESET}`);
     console.log(`  ${DIM}Error: ${error.message}${RESET}\n`);
   });
 
   // Handle interrupts
   process.on('SIGINT', async () => {
+    if (activeSpinner) { activeSpinner.fail('Interrupted'); activeSpinner = null; }
     console.log(`\n\n  ${YELLOW}!${RESET} Stopping orchestrator...`);
     await orchestrator.stop();
     console.log(`  ${DIM}Run paused. Use "gbos resume" to continue.${RESET}\n`);
@@ -132,6 +332,7 @@ async function startCommand(options) {
   try {
     await orchestrator.start();
   } catch (error) {
+    if (activeSpinner) { activeSpinner.fail(); activeSpinner = null; }
     console.log(`\n${RED}✗${RESET} ${error.message}\n`);
     process.exit(1);
   }

package/src/orchestrator/adapters/claude-adapter.js

@@ -1,12 +1,12 @@
 /**
  * Claude Code Agent Adapter
- * Adapter for Anthropic's Claude Code CLI
+ * Uses `claude -p` (print mode) which reads prompt from stdin,
+ * runs autonomously, streams output, and exits when done.
  */
 
 const BaseAdapter = require('./base-adapter');
 const { exec } = require('child_process');
 const { promisify } = require('util');
-
 const execAsync = promisify(exec);
 
 class ClaudeAdapter extends BaseAdapter {
@@ -18,178 +18,84 @@ class ClaudeAdapter extends BaseAdapter {
   }
 
   async isAvailable() {
-    try {
-      await execAsync('which claude');
-      return true;
-    } catch (e) {
-      return false;
-    }
+    try { await execAsync('which claude'); return true; } catch (e) { return false; }
   }
 
   async getVersion() {
-    try {
-      const { stdout } = await execAsync('claude --version');
-      return stdout.trim();
-    } catch (e) {
-      return 'unknown';
-    }
+    try { const { stdout } = await execAsync('claude --version'); return stdout.trim(); } catch (e) { return 'unknown'; }
   }
 
   getCommand(options = {}) {
-    const args = [];
-
-    // Use print mode for non-interactive (single prompt)
-    if (options.nonInteractive && options.prompt) {
-      args.push('--print');
-      args.push('--dangerously-skip-permissions');
-    }
-
-    // Add model if specified
-    if (options.model) {
-      args.push('--model', options.model);
-    }
-
-    // Add max turns if specified
-    if (options.maxTurns) {
-      args.push('--max-turns', options.maxTurns.toString());
-    }
+    const args = ['-p']; // Print mode: reads from stdin, outputs result, exits
+    if (options.autoApprove) args.push('--dangerously-skip-permissions');
+    if (options.model) args.push('--model', options.model);
+    if (options.maxTurns) args.push('--max-turns', options.maxTurns.toString());
+    if (options.verbose) args.push('--verbose');
 
     return {
       command: 'claude',
       args,
-      env: {
-        ...process.env,
-        ANTHROPIC_API_KEY: options.apiKey || process.env.ANTHROPIC_API_KEY,
-      },
+      env: { ...process.env, ANTHROPIC_API_KEY: options.apiKey || process.env.ANTHROPIC_API_KEY },
+      closeStdinOnWrite: true,
     };
   }
 
   formatPrompt(task, context = {}) {
     const lines = [];
-
-    // Task header
-    lines.push(`# GBOS Task: ${task.title || task.name || 'Task'}`);
-    lines.push('');
-
-    // Task metadata
+    lines.push(`# GBOS Task: ${task.title || task.name || 'Task'}`, '');
     lines.push('## Task Information');
     lines.push(`- **Task ID:** ${task.id}`);
     if (task.task_key) lines.push(`- **Task Key:** ${task.task_key}`);
     if (task.priority) lines.push(`- **Priority:** ${task.priority}`);
     if (task.task_type) lines.push(`- **Type:** ${task.task_type}`);
     lines.push('');
-
-    // Main instructions
-    lines.push('## Instructions');
-    lines.push('');
-    if (task.agent_prompt) {
-      lines.push(task.agent_prompt);
-    } else if (task.prompt) {
-      lines.push(task.prompt);
-    } else if (task.description) {
-      lines.push(task.description);
-    }
+    lines.push('## Instructions', '');
+    if (task.agent_prompt) lines.push(task.agent_prompt);
+    else if (task.prompt) lines.push(task.prompt);
+    else if (task.description) lines.push(task.description);
     lines.push('');
 
-    // Acceptance criteria
-    if (task.acceptance_criteria && task.acceptance_criteria.length > 0) {
+    if (task.acceptance_criteria?.length > 0) {
       lines.push('## Acceptance Criteria');
-      task.acceptance_criteria.forEach((c, i) => {
-        lines.push(`${i + 1}. ${c}`);
-      });
+      task.acceptance_criteria.forEach((c, i) => lines.push(`${i + 1}. ${c}`));
       lines.push('');
     }
-
-    // Target files
-    if (task.target_files && task.target_files.length > 0) {
+    if (task.target_files?.length > 0) {
       lines.push('## Target Files');
       task.target_files.forEach(f => lines.push(`- ${f}`));
       lines.push('');
     }
 
-    // Testing instructions
-    lines.push('## Testing Requirements');
-    lines.push('');
-    lines.push('After implementing the changes, you MUST test your work:');
-    lines.push('');
-
+    lines.push('## Testing Requirements', '', 'After implementing the changes, you MUST test your work:', '');
     if (context.cloudRunUrl) {
       lines.push(`1. The application is deployed at: ${context.cloudRunUrl}`);
       lines.push('2. Write and run Playwright tests to verify the changes');
-      lines.push('3. Use the following test approach:');
-      lines.push('');
-      lines.push('```bash');
-      lines.push('# Install Playwright if not present');
-      lines.push('npm install -D @playwright/test');
-      lines.push('npx playwright install');
-      lines.push('');
-      lines.push('# Run tests against the deployed app');
-      lines.push(`npx playwright test --project=chromium`);
-      lines.push('```');
-      lines.push('');
-      lines.push('Example Playwright test:');
-      lines.push('```typescript');
-      lines.push("import { test, expect } from '@playwright/test';");
-      lines.push('');
-      lines.push("test('verify changes', async ({ page }) => {");
-      lines.push(`  await page.goto('${context.cloudRunUrl}');`);
-      lines.push('  // Add your test assertions here');
-      lines.push('});');
-      lines.push('```');
+      lines.push('3. Use the following test approach:', '');
+      lines.push('```bash', '# Install Playwright if not present', 'npm install -D @playwright/test', 'npx playwright install', '', 'npx playwright test --project=chromium', '```', '');
+      lines.push('Example Playwright test:', '```typescript', "import { test, expect } from '@playwright/test';", '', "test('verify changes', async ({ page }) => {", `  await page.goto('${context.cloudRunUrl}');`, '  // Add your test assertions here', '});', '```');
     } else {
       lines.push('1. Run the existing test suite to ensure no regressions');
       lines.push('2. Add new tests for the implemented functionality');
       lines.push('3. Verify all tests pass before completing');
     }
     lines.push('');
+    lines.push('## Workspace', '', 'You are working inside the `codebase/` directory of the repository. All files you create or modify should be in this directory (your current working directory). Do NOT create files outside of this directory.', '');
 
-    // Completion instructions
-    lines.push('## Completion');
-    lines.push('');
-    lines.push('When you have completed the task:');
-    lines.push('1. Ensure all tests pass');
-    lines.push('2. Review your changes for quality');
-    lines.push('3. The system will automatically commit and push your changes');
-    lines.push('');
-    lines.push('**Important:** Do not run `git commit` or `git push` yourself - the GBOS orchestrator will handle this.');
-    lines.push('');
+    lines.push('## Completion', '', 'When you have completed the task:', '1. Ensure all tests pass', '2. Review your changes for quality', '3. The system will automatically commit and push your changes', '', '**Important:** Do not run `git commit` or `git push` yourself - the GBOS orchestrator will handle this.', '');
 
-    // Context
     if (context.repoUrl) {
-      lines.push('## Repository');
-      lines.push(`- **URL:** ${context.repoUrl}`);
-      lines.push(`- **Branch:** ${context.branch || 'main'}`);
-      lines.push('');
+      lines.push('## Repository', `- **URL:** ${context.repoUrl}`, `- **Branch:** ${context.branch || 'main'}`, '');
     }
-
     return lines.join('\n');
   }
 
   detectCompletion(output) {
-    // Claude Code specific completion patterns
-    const patterns = [
-      /I've completed/i,
-      /changes have been made/i,
-      /implementation is complete/i,
-      /task is done/i,
-      /all tests pass/i,
-      /ready for review/i,
-      /I've finished/i,
-      /I have completed/i,
-    ];
+    const patterns = [/I've completed/i, /changes have been made/i, /implementation is complete/i, /task is done/i, /all tests pass/i, /ready for review/i, /I've finished/i, /I have completed/i];
     return patterns.some(p => p.test(output)) || super.detectCompletion(output);
   }
 
   detectWaitingForInput(output) {
-    // Claude Code specific wait patterns
-    const patterns = [
-      /Do you want me to/i,
-      /Should I/i,
-      /Would you like me to/i,
-      /Shall I/i,
-      /May I/i,
-      /Can I proceed/i,
-    ];
+    const patterns = [/Do you want me to/i, /Should I/i, /Would you like me to/i, /Shall I/i, /May I/i, /Can I proceed/i];
     return patterns.some(p => p.test(output)) || super.detectWaitingForInput(output);
   }
 }

package/src/orchestrator/managers/git-manager.js

@@ -256,6 +256,30 @@ class GitManager {
     }
   }
 
+  /**
+   * Commit only (no push) - for local-only workspaces
+   */
+  async commitOnly(message, task = null) {
+    const status = await this.stageAll();
+
+    if (!status.hasChanges) {
+      return {
+        committed: false,
+        pushed: false,
+        message: 'No changes to commit',
+      };
+    }
+
+    const commit = await this.commit(message, task);
+
+    return {
+      committed: true,
+      pushed: false,
+      commit,
+      message: `Committed locally: ${commit.shortHash}`,
+    };
+  }
+
   /**
    * Full commit and push workflow
    */