@wundr.io/cli 1.0.1 → 1.0.2-dev.20260530180455.e1307186

package/src/commands/computer-setup.ts

@@ -3,11 +3,14 @@
  * Integrates new-starter functionality into the unified wundr CLI
  */
 
-import { Command } from 'commander';
+import { ComputerSetupManager } from '@wundr.io/computer-setup';
 import chalk from 'chalk';
-import ora from 'ora';
+import { Command } from 'commander';
+import * as fs from 'fs/promises';
 import inquirer from 'inquirer';
-import { ComputerSetupManager } from '@wundr.io/computer-setup';
+import * as os from 'os';
+import ora from 'ora';
+import * as path from 'path';
 // import { getLogger } from '@wundr/core';
 const logger = { info: console.log, error: console.error, warn: console.warn };
 
@@ -35,8 +38,28 @@ export function createComputerSetupCommand(): Command {
     .option('--parallel', 'Install tools in parallel where possible')
     .option('--verbose', 'Show detailed output')
     .option('--report', 'Generate a detailed setup report')
-    .action(async options => {
-      await runComputerSetup(options);
+    .option(
+      '-y, --yes',
+      'Skip confirmation prompts (assume yes) — implied on non-TTY/CI runs'
+    )
+    .option(
+      '--non-interactive',
+      'Run fully unattended with no prompts (for headless / MDM provisioning)'
+    )
+    .option(
+      '--no-remote-access',
+      'Skip remote-access provisioning (Tailscale, SSH, power management, desktop sharing)'
+    )
+    .action(async (options, command) => {
+      // `--dry-run`, `--verbose` and `--interactive` are declared as GLOBAL
+      // options on the root program, so they land in the parent's opts, not the
+      // sub-command's. optsWithGlobals() merges both so flags like --dry-run
+      // actually take effect here.
+      const merged =
+        typeof command?.optsWithGlobals === 'function'
+          ? { ...command.optsWithGlobals(), ...options }
+          : options;
+      await runComputerSetup(merged);
     });
 
   // Subcommands
@@ -72,7 +95,7 @@ export function createComputerSetupCommand(): Command {
   return command;
 }
 
-async function runComputerSetup(options: any): Promise<void> {
+export async function runComputerSetup(options: any): Promise<void> {
   const spinner = ora('Initializing computer setup...').start();
 
   try {
@@ -81,6 +104,17 @@ async function runComputerSetup(options: any): Promise<void> {
 
     spinner.stop();
 
+    // A run is non-interactive when there is no console, in CI, or when the
+    // caller asked for it (--yes / --non-interactive / a non-interactive mode).
+    // In that case we never prompt — for a profile OR for confirmation — and
+    // fall back to the default profile.
+    const nonInteractive =
+      Boolean(options.yes) ||
+      Boolean(options.nonInteractive) ||
+      options.mode !== 'interactive' ||
+      !process.stdin.isTTY ||
+      Boolean(process.env.CI);
+
     // Get or create profile
     let profile;
     if (options.profile) {
@@ -92,12 +126,20 @@ async function runComputerSetup(options: any): Promise<void> {
         );
         profile = await manager.getDefaultProfile();
       }
-    } else if (options.mode === 'interactive' || options.interactive) {
+    } else if (!nonInteractive) {
       profile = await createInteractiveProfile();
     } else {
       profile = await manager.getDefaultProfile();
     }
 
+    // commander sets options.remoteAccess === false for --no-remote-access.
+    if (profile && options.remoteAccess === false) {
+      profile.remoteAccess = {
+        ...(profile.remoteAccess ?? {}),
+        enabled: false,
+      };
+    }
+
     // Detect platform
     const platform = {
       os: process.platform as 'darwin' | 'linux' | 'win32',
@@ -122,8 +164,9 @@ async function runComputerSetup(options: any): Promise<void> {
       );
     }
 
-    // Confirm before proceeding
-    if (options.mode === 'interactive' && !options.dryRun) {
+    // Confirm before proceeding (only in a real interactive session — the
+    // `nonInteractive` flag computed above already accounts for TTY/CI/--yes).
+    if (!options.dryRun && !nonInteractive) {
       const { proceed } = await inquirer.prompt([
         {
           type: 'confirm',
@@ -199,7 +242,24 @@ async function runComputerSetup(options: any): Promise<void> {
     }
 
     if (result.report) {
-      console.log(chalk.cyan(`\n📄 Setup report generated successfully`));
+      console.log(chalk.cyan('\n📄 Setup report generated successfully'));
+    }
+
+    // Set up Fleet Mode if enabled
+    if (profile.preferences?.aiTools?.fleetMode) {
+      try {
+        await setupFleetMode(profile as DeveloperProfile);
+      } catch (fleetError) {
+        console.error(
+          chalk.red('\n⚠️ Fleet Mode setup encountered issues:'),
+          fleetError
+        );
+        console.log(
+          chalk.yellow(
+            'You can retry with: wundr computer-setup --profile <your-profile>'
+          )
+        );
+      }
     }
 
     // Display next steps
@@ -308,9 +368,16 @@ async function createInteractiveProfile(): Promise<any> {
       type: 'confirm',
       name: 'aiTools',
       message:
-        'Do you want to set up AI development tools (Claude Code, Claude Flow)?',
+        'Do you want to set up AI development tools (Claude Code, Ruflo)?',
       default: true,
     },
+    {
+      type: 'confirm',
+      name: 'fleetMode',
+      message: 'Enable Fleet-Scale Autonomous Engineering mode?',
+      default: false,
+      when: (answers: any) => answers.aiTools,
+    },
     {
       type: 'confirm',
       name: 'slack',
@@ -338,10 +405,11 @@ async function createInteractiveProfile(): Promise<any> {
       },
       aiTools: {
         claudeCode: answers.aiTools,
-        claudeFlow: answers.aiTools,
+        ruflo: answers.aiTools,
         mcpTools: answers.aiTools ? ['all'] : [],
         swarmAgents: answers.aiTools ? ['default'] : [],
         memoryAllocation: '2GB',
+        fleetMode: answers.fleetMode || false,
       },
     },
     tools: {
@@ -425,6 +493,450 @@ function buildLanguageConfig(languages: string[]): any {
   return config;
 }
 
+/**
+ * Developer profile interface with fleet mode support
+ */
+interface DeveloperProfile {
+  name: string;
+  email: string;
+  role: string;
+  team?: string;
+  preferences: {
+    shell: string;
+    editor: string;
+    theme: string;
+    gitConfig: {
+      userName: string;
+      userEmail: string;
+      signCommits: boolean;
+      defaultBranch: string;
+      aliases: Record<string, string>;
+    };
+    aiTools: {
+      claudeCode: boolean;
+      ruflo: boolean;
+      mcpTools: string[];
+      swarmAgents: string[];
+      memoryAllocation: string;
+      fleetMode: boolean;
+    };
+  };
+  tools: Record<string, unknown>;
+}
+
+/**
+ * Sets up Fleet-Scale Autonomous Engineering mode
+ * Installs Orchestrator Daemon scripts, Memory Bank templates, and IPRE governance defaults
+ */
+async function setupFleetMode(profile: DeveloperProfile): Promise<void> {
+  const wundrDir = path.join(os.homedir(), '.wundr');
+  const orchestratorDaemonDir = path.join(wundrDir, 'orchestrator-daemon');
+  const governanceDir = path.join(wundrDir, 'governance');
+  const templatesDir = path.join(wundrDir, 'templates');
+
+  console.log(
+    chalk.cyan('\n🚀 Setting up Fleet-Scale Autonomous Engineering mode...\n')
+  );
+
+  // Create directory structure
+  await fs.mkdir(orchestratorDaemonDir, { recursive: true });
+  await fs.mkdir(governanceDir, { recursive: true });
+  await fs.mkdir(path.join(templatesDir, 'memory-bank'), { recursive: true });
+  await fs.mkdir(path.join(templatesDir, 'sub-agents'), { recursive: true });
+
+  // 1. Install Orchestrator Daemon configuration
+  const orchestratorConfig = {
+    version: '1.0.0',
+    identity: {
+      name: profile.name,
+      email: profile.email,
+      role: 'Orchestrator-Supervisor',
+    },
+    resourceLimits: {
+      maxSessions: 10,
+      tokenBudget: {
+        subscription: 0.8, // 80% for Orchestrator & Session Managers
+        api: 0.2, // 20% for sub-agent swarms
+      },
+    },
+    systemLimits: {
+      fileDescriptors: 65000,
+      diskSpaceBufferGB: 10,
+      maxWorktreesPerMachine: 200,
+    },
+    measurableObjectives: {
+      responseTime: '<30s to Slack mentions',
+      rateLimit: "Zero 'Rate Limit Exceeded' per week",
+      routingAccuracy: '100% correct task routing',
+    },
+    hardConstraints: [
+      'Never exhaust API quota',
+      'Always maintain audit trail',
+      'Escalate blocked requests within 5 minutes',
+    ],
+  };
+
+  await fs.writeFile(
+    path.join(orchestratorDaemonDir, 'config.yaml'),
+    generateYamlContent(orchestratorConfig),
+    'utf-8'
+  );
+  console.log(chalk.green('  ✓ Orchestrator Daemon configuration installed'));
+
+  // 2. Copy Orchestrator Charter template
+  const orchestratorCharter = `---
+name: orchestrator-supervisor
+role: Tier1-Orchestrator
+identity:
+  name: '${profile.name}'
+  email: '${profile.email}'
+  slackHandle: '@orchestrator-supervisor'
+
+responsibilities:
+  - triage_requests
+  - manage_session_lifecycle
+  - allocate_token_budget
+  - human_communication
+  - fleet_status_reporting
+
+resourceLimits:
+  maxSessions: 10
+  tokenBudget:
+    subscription: 80%
+    api: 20%
+
+measurableObjectives:
+  responseTime: '<30s to Slack mentions'
+  rateLimit: "Zero 'Rate Limit Exceeded' per week"
+  routingAccuracy: '100% correct task routing'
+
+hardConstraints:
+  - 'Never exhaust API quota'
+  - 'Always maintain audit trail'
+  - 'Escalate blocked requests within 5 minutes'
+---
+`;
+
+  await fs.writeFile(
+    path.join(orchestratorDaemonDir, 'orchestrator-charter.md'),
+    orchestratorCharter,
+    'utf-8'
+  );
+  console.log(chalk.green('  ✓ Orchestrator Charter template deployed'));
+
+  // 3. Set up token budgeting configuration
+  const tokenBudgetConfig = {
+    version: '1.0.0',
+    subscription: {
+      type: 'claude-code-max-20x',
+      promptsPerFiveHours: 800,
+      warningThreshold: 0.8,
+      criticalThreshold: 0.95,
+    },
+    api: {
+      monthlyBudget: 500,
+      haikuRatePerMillion: 0.25,
+      sonnetRatePerMillion: 3.0,
+    },
+    modelAllocation: {
+      tier1: {
+        model: 'claude-3-5-sonnet',
+        source: 'subscription',
+        priority: 'critical',
+      },
+      tier2: {
+        model: 'claude-3-5-sonnet',
+        source: 'subscription',
+        priority: 'high',
+      },
+      tier3: {
+        model: 'claude-3-5-haiku',
+        source: 'api',
+        priority: 'normal',
+      },
+    },
+    throttlingPolicy: {
+      onWarning: ['pause_non_critical_sessions', 'queue_new_requests'],
+      onCritical: ['pause_all_except_critical', 'notify_orchestrator_human'],
+    },
+  };
+
+  await fs.writeFile(
+    path.join(orchestratorDaemonDir, 'token-budget.yaml'),
+    generateYamlContent(tokenBudgetConfig),
+    'utf-8'
+  );
+  console.log(chalk.green('  ✓ Token budgeting configuration set up'));
+
+  // 4. Deploy Memory Bank templates
+  const sessionTemplate = `# Active Context - Session {{SESSION_ID}}
+
+## Current Focus
+<!-- Updated by session manager -->
+
+## Working Memory
+- Last action:
+- Next planned step:
+- Blockers:
+
+## Context Window State
+- Tokens used: X / 200,000
+- Compression needed: Yes/No
+
+## Handoff Notes
+<!-- For session resumption -->
+`;
+
+  const progressTemplate = `# Progress Tracker - Session {{SESSION_ID}}
+
+## Milestones
+| Status | Milestone | Target Date | Notes |
+|--------|-----------|-------------|-------|
+
+## Completed Tasks
+<!-- Archive of completed work -->
+
+## Blockers
+<!-- Current impediments -->
+`;
+
+  const subAgentDelegationTemplate = `# Sub-Agent Delegation Tracker
+
+## Active Sub-Agents
+| ID | Type | Task | Status | Worktree | Started |
+|----|------|------|--------|----------|---------|
+
+## Completed Tasks
+<!-- Archive of completed sub-agent work -->
+
+## Resource Usage
+- Active worktrees: X / 20
+- API calls (session): X
+`;
+
+  const ipreAlignmentTemplate = `# IPRE Alignment State
+
+## Active Policies
+<!-- Hard constraints for this session -->
+
+## Reward Weights
+\`\`\`yaml
+customer_value: 0.35
+code_quality: 0.30
+timeline: 0.20
+technical_debt: 0.15
+\`\`\`
+
+## Alignment Score
+- Current: 85/100
+- Last evaluation: {{TIMESTAMP}}
+- Trend: Improving
+
+## Escalation History
+<!-- Guardian review log -->
+`;
+
+  await fs.writeFile(
+    path.join(templatesDir, 'memory-bank', 'activeContext.md'),
+    sessionTemplate,
+    'utf-8'
+  );
+  await fs.writeFile(
+    path.join(templatesDir, 'memory-bank', 'progress.md'),
+    progressTemplate,
+    'utf-8'
+  );
+  await fs.writeFile(
+    path.join(templatesDir, 'memory-bank', 'subAgentDelegation.md'),
+    subAgentDelegationTemplate,
+    'utf-8'
+  );
+  await fs.writeFile(
+    path.join(templatesDir, 'memory-bank', 'ipre-alignment.md'),
+    ipreAlignmentTemplate,
+    'utf-8'
+  );
+  console.log(chalk.green('  ✓ Memory Bank templates deployed'));
+
+  // 5. Initialize IPRE governance defaults
+  const ipreDefaults = {
+    version: '1.0.0',
+    intent: {
+      mission: 'Deliver high-quality software that solves customer problems',
+      values: [
+        'customer_first',
+        'technical_excellence',
+        'sustainable_velocity',
+      ],
+    },
+    policies: {
+      security: [
+        'No secrets in code',
+        'No SQL injection vulnerabilities',
+        'No XSS attack vectors',
+      ],
+      compliance: [
+        'All changes require PR review',
+        'No force pushes to main/master',
+        'Test coverage minimum 80%',
+      ],
+      operational: [
+        'No deployments on Fridays after 2pm',
+        'Rollback plan required for production changes',
+      ],
+    },
+    rewards: {
+      customer_value: 0.35,
+      code_quality: 0.25,
+      delivery_speed: 0.2,
+      technical_debt_reduction: 0.15,
+      documentation: 0.05,
+    },
+    evaluators: [
+      {
+        type: 'policy_compliance',
+        frequency: 'per_commit',
+        action: 'block_on_violation',
+      },
+      {
+        type: 'reward_alignment',
+        frequency: 'hourly',
+        threshold: 0.7,
+        action: 'escalate_to_guardian',
+      },
+      {
+        type: 'drift_detection',
+        frequency: 'daily',
+        patterns: ['reward_hacking', 'escalation_suppression'],
+        action: 'alert_architect',
+      },
+    ],
+  };
+
+  await fs.writeFile(
+    path.join(governanceDir, 'ipre-defaults.yaml'),
+    generateYamlContent(ipreDefaults),
+    'utf-8'
+  );
+  console.log(chalk.green('  ✓ IPRE governance defaults initialized'));
+
+  // 6. Configure system resource limits guidance
+  const resourceGuidance = `# System Resource Configuration for Fleet Mode
+
+## File Descriptor Limits
+For optimal fleet operation with up to 200 worktrees, configure:
+
+### macOS / Linux
+\`\`\`bash
+# Add to ~/.zshrc or ~/.bashrc
+ulimit -n 65000
+\`\`\`
+
+### Persistent Configuration (macOS)
+\`\`\`bash
+# Create /Library/LaunchDaemons/limit.maxfiles.plist with:
+# soft limit: 65000
+# hard limit: 200000
+\`\`\`
+
+### Persistent Configuration (Linux)
+\`\`\`bash
+# Add to /etc/security/limits.conf
+* soft nofile 65000
+* hard nofile 200000
+\`\`\`
+
+## Disk Space Requirements
+- Minimum: 500GB SSD
+- Recommended: 4TB+ SSD (for 200 worktrees at ~2GB each)
+- Buffer: Keep 10GB free at all times
+
+## Git Worktree Best Practices
+- Session Managers sync with remote (fetch/pull)
+- Sub-Agents rarely git fetch (reduces index lock contention)
+- Use fractional worktree pattern:
+  - Read-only agents: Share Session Manager's worktree
+  - Write-access agents: Get dedicated worktrees
+
+## Monitoring Commands
+\`\`\`bash
+# Check current file descriptor limit
+ulimit -n
+
+# Check open files
+lsof | wc -l
+
+# Check disk space
+df -h
+
+# List active worktrees
+git worktree list
+\`\`\`
+`;
+
+  await fs.writeFile(
+    path.join(wundrDir, 'RESOURCE_LIMITS.md'),
+    resourceGuidance,
+    'utf-8'
+  );
+  console.log(chalk.green('  ✓ System resource limits guidance configured'));
+
+  console.log(
+    chalk.cyan('\n✅ Fleet-Scale Autonomous Engineering mode setup complete!\n')
+  );
+  console.log(chalk.white('Files created:'));
+  console.log(chalk.gray('  ~/.wundr/orchestrator-daemon/config.yaml'));
+  console.log(
+    chalk.gray('  ~/.wundr/orchestrator-daemon/orchestrator-charter.md')
+  );
+  console.log(chalk.gray('  ~/.wundr/orchestrator-daemon/token-budget.yaml'));
+  console.log(chalk.gray('  ~/.wundr/templates/memory-bank/'));
+  console.log(chalk.gray('  ~/.wundr/governance/ipre-defaults.yaml'));
+  console.log(chalk.gray('  ~/.wundr/RESOURCE_LIMITS.md'));
+  console.log(
+    chalk.yellow(
+      '\n⚠️  Review ~/.wundr/RESOURCE_LIMITS.md for system configuration recommendations.'
+    )
+  );
+}
+
+/**
+ * Simple YAML generator for configuration objects
+ */
+function generateYamlContent(obj: Record<string, unknown>, indent = 0): string {
+  let yaml = '';
+  const spaces = '  '.repeat(indent);
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === null || value === undefined) {
+      yaml += `${spaces}${key}: null\n`;
+    } else if (typeof value === 'object' && !Array.isArray(value)) {
+      yaml += `${spaces}${key}:\n`;
+      yaml += generateYamlContent(value as Record<string, unknown>, indent + 1);
+    } else if (Array.isArray(value)) {
+      yaml += `${spaces}${key}:\n`;
+      for (const item of value) {
+        if (typeof item === 'object') {
+          yaml += `${spaces}  -\n`;
+          const itemYaml = generateYamlContent(
+            item as Record<string, unknown>,
+            indent + 2
+          );
+          yaml += itemYaml;
+        } else {
+          yaml += `${spaces}  - '${item}'\n`;
+        }
+      }
+    } else if (typeof value === 'string') {
+      yaml += `${spaces}${key}: '${value}'\n`;
+    } else {
+      yaml += `${spaces}${key}: ${value}\n`;
+    }
+  }
+
+  return yaml;
+}
+
 async function manageProfiles(): Promise<void> {
   const manager = new ComputerSetupManager();
   await manager.initialize();

package/src/commands/create-command.ts

@@ -3,10 +3,10 @@
  * Scaffolds new wundr-compliant projects
  */
 
-import { Command } from 'commander';
-import chalk from 'chalk';
-import { projectTemplates } from '@wundr/project-templates';
 import { getLogger } from '@wundr/core';
+import { projectTemplates } from '@wundr/project-templates';
+import chalk from 'chalk';
+import { Command } from 'commander';
 
 const logger = getLogger('cli:create');
 

package/src/commands/create.ts

@@ -1,12 +1,15 @@
-import { Command } from 'commander';
-import inquirer from 'inquirer';
-import fs from 'fs-extra';
 import path from 'path';
+
 import chalk from 'chalk';
-import { ConfigManager } from '../utils/config-manager';
-import { PluginManager } from '../plugins/plugin-manager';
-import { logger } from '../utils/logger';
+import fs from 'fs-extra';
+import inquirer from 'inquirer';
+
 import { errorHandler } from '../utils/error-handler';
+import { logger } from '../utils/logger';
+
+import type { PluginManager } from '../plugins/plugin-manager';
+import type { ConfigManager } from '../utils/config-manager';
+import type { Command } from 'commander';
 // import { projectTemplates } from '@wundr/project-templates';
 // TODO: Fix this import - project-templates package needs to be created
 const projectTemplates = {

package/src/commands/dashboard.ts

@@ -1,12 +1,15 @@
-import { Command } from 'commander';
 import { spawn } from 'child_process';
-import fs from 'fs-extra';
 import path from 'path';
+
 import chalk from 'chalk';
-import { ConfigManager } from '../utils/config-manager';
-import { PluginManager } from '../plugins/plugin-manager';
-import { logger } from '../utils/logger';
+import fs from 'fs-extra';
+
 import { errorHandler } from '../utils/error-handler';
+import { logger } from '../utils/logger';
+
+import type { PluginManager } from '../plugins/plugin-manager';
+import type { ConfigManager } from '../utils/config-manager';
+import type { Command } from 'commander';
 
 /**
  * Dashboard commands for web interface and visualization
@@ -489,7 +492,9 @@ export class DashboardCommands {
    */
   private async isDashboardRunning(): Promise<boolean> {
     const processInfo = await this.loadDashboardProcess();
-    if (!processInfo) return false;
+    if (!processInfo) {
+      return false;
+    }
 
     try {
       process.kill(processInfo.pid, 0);