@grantx/fleet-cli 0.1.3 → 0.1.5

package/src/github-repos.js

@@ -0,0 +1,159 @@
+// github-repos.js — GitHub repo onboarding for fleet setup.
+// Links repos to give agents codebase context.
+
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+import { ask, askList, printHeader } from './prompt-utils.js';
+import { scanCodebase } from './generate.js';
+
+/**
+ * Run the GitHub repo onboarding wizard.
+ * @param {readline.Interface} rl
+ * @param {string} projectRoot
+ * @returns {Promise<Array>} Array of repo definitions for fleet.config.json
+ */
+export async function runGitHubRepos(rl, projectRoot) {
+  printHeader('GitHub Repositories');
+  console.log('  Link the repos your team works on (gives agents codebase context).\n');
+
+  // Collect repo slugs
+  const repoSlugs = [];
+  while (true) {
+    const input = await ask(rl, 'Repo (owner/name or URL, blank to finish)');
+    if (!input) break;
+
+    const slug = normalizeRepoInput(input);
+    if (!slug) {
+      console.log('    Could not parse repo. Use format: owner/name or full GitHub URL');
+      continue;
+    }
+
+    // Validate with gh CLI if available
+    const info = await validateRepo(slug);
+    if (info) {
+      const langs = info.languages?.length > 0 ? info.languages.join(', ') : 'unknown';
+      console.log(`    ✓ ${info.name || slug} (${langs})`);
+      repoSlugs.push({ slug, info });
+    } else {
+      console.log(`    ⚠ Could not validate (gh CLI may not be installed). Added anyway.`);
+      repoSlugs.push({ slug, info: null });
+    }
+  }
+
+  if (repoSlugs.length === 0) {
+    console.log('  No repositories linked.\n');
+    return [];
+  }
+
+  // Ask how to access repos
+  const mode = await askList(rl, 'How should fleet access these repos?', [
+    { label: 'Local path', description: 'Point to existing local checkouts', value: 'local' },
+    { label: 'Clone', description: 'Fleet clones into .fleet/repos/ (shallow)', value: 'clone' },
+    { label: 'URL only', description: 'Just store the slug, agents use gh CLI on demand', value: 'url' },
+  ]);
+
+  const repos = [];
+  for (const { slug, info } of repoSlugs) {
+    const repo = { slug, mode };
+
+    if (info) {
+      repo.languages = info.languages || [];
+      repo.frameworks = info.frameworks || [];
+    }
+
+    if (mode === 'local') {
+      const repoName = slug.split('/').pop();
+      const defaultPath = path.join(path.dirname(projectRoot), repoName);
+      const localPath = await ask(rl, `  Local path for ${slug}`, defaultPath);
+
+      if (fs.existsSync(localPath)) {
+        repo.path = localPath;
+        // Scan for frameworks
+        try {
+          const scan = scanCodebase(localPath);
+          repo.languages = scan.languages || [];
+          repo.frameworks = scan.frameworks || [];
+          const fwStr = repo.frameworks.length > 0 ? `, ${repo.frameworks.join(', ')}` : '';
+          console.log(`    ✓ Scanned: ${repo.languages.join(', ')}${fwStr}`);
+        } catch { /* scan failed, continue */ }
+      } else {
+        console.log(`    ⚠ Path not found, storing slug only`);
+        repo.mode = 'url';
+      }
+    } else if (mode === 'clone') {
+      const reposDir = path.join(projectRoot, '.fleet', 'repos');
+      const repoName = slug.split('/').pop();
+      const clonePath = path.join(reposDir, repoName);
+
+      try {
+        fs.mkdirSync(reposDir, { recursive: true });
+        if (!fs.existsSync(clonePath)) {
+          console.log(`    Cloning ${slug}...`);
+          execSync(`git clone --depth=1 https://github.com/${slug}.git "${clonePath}"`, {
+            stdio: 'pipe',
+            timeout: 60000,
+          });
+        }
+        repo.path = clonePath;
+
+        // Scan cloned repo
+        try {
+          const scan = scanCodebase(clonePath);
+          repo.languages = scan.languages || [];
+          repo.frameworks = scan.frameworks || [];
+        } catch { /* scan failed */ }
+
+        console.log(`    ✓ Cloned to .fleet/repos/${repoName}`);
+      } catch (err) {
+        console.log(`    ⚠ Clone failed: ${err.message}. Storing slug only.`);
+        repo.mode = 'url';
+      }
+    }
+    // mode === 'url': nothing extra to do
+
+    repos.push(repo);
+  }
+
+  console.log(`\n  Linked ${repos.length} repository(s).\n`);
+  return repos;
+}
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+/**
+ * Normalize various repo input formats to owner/name.
+ */
+function normalizeRepoInput(input) {
+  // Full URL: https://github.com/owner/name or https://github.com/owner/name.git
+  const urlMatch = input.match(/github\.com\/([^/]+\/[^/.\s]+)/);
+  if (urlMatch) return urlMatch[1];
+
+  // owner/name format
+  if (/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(input)) {
+    return input;
+  }
+
+  return null;
+}
+
+/**
+ * Validate a repo exists using gh CLI.
+ * Returns repo info or null if gh is unavailable.
+ */
+async function validateRepo(slug) {
+  try {
+    const output = execSync(
+      `gh repo view ${slug} --json name,description,languages`,
+      { stdio: 'pipe', timeout: 10000 }
+    ).toString();
+    const data = JSON.parse(output);
+    return {
+      name: data.name,
+      description: data.description,
+      languages: data.languages?.map(l => l.node?.name || l.name || l) || [],
+    };
+  } catch {
+    return null;
+  }
+}

package/src/init.js

@@ -1,15 +1,34 @@
-// init.js — First-use wizard: scan codebase, generate agents, create workspace.
+// init.js — Fleet setup wizard: team selection, repo onboarding, agent building,
+// conductor soul, and Slack integration. Produces Clawcob-quality agents.
 
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import readline from 'node:readline';
 import { scanCodebase, generateRoster } from './generate.js';
 import { setupAgentWorkspaces } from './setup-agents.js';
+import { createReadline, ask, askRequired, askList, isInteractive, printHeader, printStep } from './prompt-utils.js';
+import { runAgentWizard } from './agent-wizard.js';
+import { generateRichAgentClaudeMd, generateConductorClaudeMd } from './agent-templates.js';
+import { runGitHubRepos } from './github-repos.js';
+import { runSlackSetup } from './slack-setup.js';
+
+const TEAM_OPTIONS = [
+  { label: 'ML', description: 'Machine learning, ranking, model training', value: 'grantx-ml' },
+  { label: 'Data', description: 'Data engineering, pipelines, infrastructure', value: 'grantx-data' },
+  { label: 'Fullstack', description: 'Frontend, backend, API, UI', value: 'grantx-fullstack' },
+  { label: 'Skunkworks', description: 'Research, experiments, bleeding edge', value: 'grantx-skunkworks' },
+];
+
+const TEAM_TYPE_MAP = {
+  'grantx-ml': 'ml',
+  'grantx-data': 'data',
+  'grantx-fullstack': 'fullstack',
+  'grantx-skunkworks': 'skunkworks',
+};
 
 export default async function init(args) {
   const projectRoot = process.cwd();
-  console.log('\nFleet Setup');
+  console.log('\n  Fleet Setup');
   console.log(`  Project: ${projectRoot}\n`);
 
   // Check if already initialized
@@ -20,176 +39,247 @@ export default async function init(args) {
     console.log('  Re-running will update config without destroying sessions.\n');
   }
 
-  // 1. Scan codebase
-  console.log('  Scanning codebase...');
-  const scan = scanCodebase(projectRoot);
+  // Non-interactive fallback: if all env vars set and no TTY
+  const envUrl = process.env.FLEET_SUPABASE_URL || '';
+  const envKey = process.env.FLEET_SUPABASE_KEY || '';
+  const envTeam = process.env.FLEET_TEAM_ID || '';
 
-  if (scan.languages.length > 0) {
-    console.log(`    Languages: ${scan.languages.join(', ')}`);
-  }
-  if (scan.frameworks.length > 0) {
-    console.log(`    Frameworks: ${scan.frameworks.join(', ')}`);
-  }
-  if (scan.infra.length > 0) {
-    console.log(`    Infrastructure: ${scan.infra.join(', ')}`);
-  }
-  if (scan.cloud.length > 0) {
-    console.log(`    Cloud: ${scan.cloud.join(', ')}`);
+  if (!isInteractive() && envUrl && envKey && envTeam) {
+    return initNonInteractive(projectRoot, configPath, envUrl, envKey, envTeam);
   }
 
-  const totalFiles = Object.values(scan.fileStats).reduce((a, b) => a + b, 0);
-  const topExts = Object.entries(scan.fileStats)
-    .sort((a, b) => b[1] - a[1])
-    .slice(0, 5)
-    .map(([ext, count]) => `${ext}: ${count}`)
-    .join(', ');
-  console.log(`    Files: ${totalFiles} (${topExts})`);
-  if (scan.testFiles > 0) {
-    console.log(`    Test files: ${scan.testFiles}`);
-  }
-  console.log('');
+  // Interactive wizard
+  const rl = createReadline();
 
-  // 2. Generate roster
-  const roster = generateRoster(scan);
-  console.log(`  Recommended agents (${roster.length}):`);
-  for (const agent of roster) {
-    const type = agent.isConductor ? '(conductor)' : '';
-    console.log(`    ${agent.name.padEnd(12)} -- ${agent.role} ${type}`);
-  }
-  console.log('');
+  try {
+    // ── Phase 1: Team Selection ─────────────────────────────────
+    printHeader('Team Selection');
 
-  // 3. Get Supabase config
-  let supabaseUrl = process.env.FLEET_SUPABASE_URL || '';
-  let supabaseKey = process.env.FLEET_SUPABASE_KEY || '';
-  let teamId = process.env.FLEET_TEAM_ID || '';
-
-  // Auto-suggest team ID
-  const username = os.userInfo().username || 'user';
-  const dirname = path.basename(projectRoot);
-  const suggestedTeamId = `${username}-${dirname}`.toLowerCase().replace(/[^a-z0-9-]/g, '-');
-
-  // Non-interactive mode: all env vars set
-  const nonInteractive = supabaseUrl && supabaseKey;
-
-  if (nonInteractive) {
-    if (!teamId) teamId = suggestedTeamId;
-    console.log(`  Supabase URL: ${supabaseUrl} [from env]`);
-    console.log(`  Supabase key: ****${supabaseKey.slice(-4)} [from env]`);
-    console.log(`  Team ID: ${teamId}${process.env.FLEET_TEAM_ID ? ' [from env]' : ' [auto]'}`);
-  } else {
-    // Interactive prompts
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const ask = (q, dflt) => new Promise(resolve => {
-      const prompt = dflt ? `${q} [${dflt}]: ` : `${q}: `;
-      rl.question(`  ${prompt}`, answer => resolve(answer.trim() || dflt || ''));
-    });
+    let teamId;
+    if (envTeam && TEAM_TYPE_MAP[envTeam]) {
+      teamId = envTeam;
+      console.log(`  Team: ${teamId} [from env]\n`);
+    } else {
+      teamId = await askList(rl, 'Select your team:', TEAM_OPTIONS);
+    }
+    const teamType = TEAM_TYPE_MAP[teamId];
+
+    // ── Phase 2: Supabase Credentials ───────────────────────────
+    printHeader('Supabase Credentials');
+
+    let supabaseUrl = envUrl;
+    let supabaseKey = envKey;
 
     if (!supabaseUrl) {
-      supabaseUrl = await ask('Supabase URL', 'https://svfqcnfxcbwjwbugiiyv.supabase.co');
+      supabaseUrl = await ask(rl, 'Supabase URL', 'https://svfqcnfxcbwjwbugiiyv.supabase.co');
     } else {
       console.log(`  Supabase URL: ${supabaseUrl} [from env]`);
     }
 
     if (!supabaseKey) {
-      supabaseKey = await ask('Supabase key (anon)', '');
-      if (!supabaseKey) {
-        console.error('\n  Error: Supabase key is required. Set FLEET_SUPABASE_KEY or provide it here.');
-        rl.close();
-        process.exit(1);
-      }
+      supabaseKey = await askRequired(rl, 'Supabase API key (sb_secret_... or eyJ...)');
     } else {
       console.log(`  Supabase key: ****${supabaseKey.slice(-4)} [from env]`);
     }
+    console.log('');
+
+    // ── Phase 3: GitHub Repositories ────────────────────────────
+    const repos = await runGitHubRepos(rl, projectRoot);
 
-    if (!teamId) {
-      teamId = await ask('Team ID', suggestedTeamId);
+    // ── Phase 4: Agent Builder ──────────────────────────────────
+    const { workers, conductorInput } = await runAgentWizard(rl, projectRoot, teamType, repos);
+
+    // Build conductor agent definition
+    const conductor = {
+      name: 'conductor',
+      role: 'Orchestration, planning, task decomposition, sprint management',
+      isConductor: true,
+      keywords: [],
+      filePatterns: [],
+    };
+
+    const allAgents = [conductor, ...workers];
+
+    // ── Phase 5: Slack Integration ──────────────────────────────
+    const slackConfig = await runSlackSetup(rl, teamId);
+
+    rl.close();
+
+    // ── Phase 6: Write Everything ───────────────────────────────
+    printHeader('Writing Configuration');
+
+    // Build fleet.config.json
+    const config = {
+      version: 2,
+      teamId,
+      teamType,
+      supabase: {
+        url: supabaseUrl,
+        key: supabaseKey,
+      },
+      repos: repos.length > 0 ? repos : undefined,
+      slack: slackConfig || undefined,
+      execution: {
+        mode: 'on-demand',
+        maxConcurrent: Math.min(workers.length + 1, 5),
+        timeouts: {
+          task: 1800000,
+          review: 300000,
+          watch: 180000,
+        },
+      },
+      agents: allAgents,
+      daemon: {
+        loopIntervalMs: 5000,
+        cron: {
+          healthCheckMinutes: 10,
+          synthesisHours: 2,
+          credCheckMinutes: 30,
+        },
+      },
+    };
+
+    // Write config
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log('  ✓ fleet.config.json');
+
+    // Setup agent workspaces with rich CLAUDE.md files
+    setupAgentWorkspaces(projectRoot, allAgents);
+
+    // Write rich CLAUDE.md files (overwrite the basic ones from setup-agents)
+    for (const agent of workers) {
+      const claudeMdPath = path.join(projectRoot, '.fleet', 'agents', agent.name, 'CLAUDE.md');
+      const content = generateRichAgentClaudeMd(agent, config);
+      fs.writeFileSync(claudeMdPath, content);
     }
 
+    // Write conductor soul
+    const conductorClaudeMdPath = path.join(projectRoot, '.fleet', 'agents', 'conductor', 'CLAUDE.md');
+    const conductorContent = generateConductorClaudeMd(conductorInput, allAgents, config);
+    fs.writeFileSync(conductorClaudeMdPath, conductorContent);
+
+    const agentNames = allAgents.map(a => a.name).join(', ');
+    console.log(`  ✓ .fleet/agents/ (${allAgents.length} agents: ${agentNames})`);
+    console.log('  ✓ .fleet/sessions.json');
+
+    // Count CLAUDE.md lines for display
+    const conductorLines = conductorContent.split('\n').length;
+    console.log(`  ✓ Conductor soul (${conductorLines} lines)`);
+
+    // Write .mcp.json
+    writeMcpJson(projectRoot);
+    console.log('  ✓ .mcp.json (Claude Code MCP registration)');
+
+    // Write slash command
+    writeFleetCommand(projectRoot);
+
+    // Update .gitignore
+    updateGitignore(projectRoot);
+
+    // Summary
+    console.log('');
+    printStep(1, 6, 'Team Selection', teamId);
+    printStep(2, 6, 'Supabase Credentials', `****${supabaseKey.slice(-4)}`);
+    printStep(3, 6, 'GitHub Repositories', repos.length > 0 ? `${repos.length} linked` : 'none');
+    printStep(4, 6, 'Agent Builder', `${workers.length} workers built`);
+    printStep(5, 6, 'Conductor Soul', `${conductorLines} lines`);
+    printStep(6, 6, 'Slack Integration', slackConfig ? 'connected' : 'skipped');
+
+    console.log('\n  Done. Run `fleet start` to begin, or open Claude Code and try /fleet status.\n');
+
+  } catch (err) {
     rl.close();
+    throw err;
   }
-  console.log('');
+}
 
-  // 4. Create workspace
-  console.log('  Creating workspace...');
+/**
+ * Non-interactive fallback: uses env vars and auto-generates agents (v1 behavior).
+ */
+function initNonInteractive(projectRoot, configPath, supabaseUrl, supabaseKey, teamId) {
+  console.log('  Non-interactive mode (all env vars set).');
+  console.log('  ⚠ Interactive mode produces richer agent definitions.\n');
 
-  // Write fleet.config.json
+  console.log(`  Supabase URL: ${supabaseUrl} [from env]`);
+  console.log(`  Supabase key: ****${supabaseKey.slice(-4)} [from env]`);
+  console.log(`  Team ID: ${teamId} [from env]\n`);
+
+  // Scan and auto-generate
+  console.log('  Scanning codebase...');
+  const scan = scanCodebase(projectRoot);
+  const roster = generateRoster(scan);
+
+  console.log(`  Generated ${roster.length} agents:`);
+  for (const agent of roster) {
+    const type = agent.isConductor ? '(conductor)' : '';
+    console.log(`    ${agent.name.padEnd(12)} -- ${agent.role} ${type}`);
+  }
+  console.log('');
+
+  const teamType = TEAM_TYPE_MAP[teamId] || teamId;
   const config = {
     version: 1,
     teamId,
-    supabase: {
-      url: supabaseUrl,
-      key: supabaseKey,
-    },
+    teamType,
+    supabase: { url: supabaseUrl, key: supabaseKey },
     execution: {
       mode: 'on-demand',
       maxConcurrent: 3,
-      timeouts: {
-        task: 1800000,
-        review: 300000,
-        watch: 180000,
-      },
+      timeouts: { task: 1800000, review: 300000, watch: 180000 },
     },
     agents: roster,
     daemon: {
       loopIntervalMs: 5000,
-      cron: {
-        healthCheckMinutes: 10,
-        synthesisHours: 2,
-      },
+      cron: { healthCheckMinutes: 10, synthesisHours: 2, credCheckMinutes: 30 },
     },
   };
 
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-  console.log('    fleet.config.json');
+  console.log('  ✓ fleet.config.json');
 
-  // Setup agent workspaces
   setupAgentWorkspaces(projectRoot, roster);
-  const agentNames = roster.map(a => a.name).join(', ');
-  console.log(`    .fleet/agents/{${agentNames}}/`);
-  console.log('    .fleet/sessions.json');
+  console.log(`  ✓ .fleet/agents/`);
+  console.log('  ✓ .fleet/sessions.json');
+
+  writeMcpJson(projectRoot);
+  console.log('  ✓ .mcp.json');
+
+  writeFleetCommand(projectRoot);
+  updateGitignore(projectRoot);
 
-  // Write .mcp.json
+  console.log('\n  Done. Run `fleet start` to begin.\n');
+}
+
+// ── Shared helpers ────────────────────────────────────────────────
+
+function writeMcpJson(projectRoot) {
   const mcpJsonPath = path.join(projectRoot, '.mcp.json');
-  const mcpConfig = {
-    mcpServers: {
-      fleet: {
-        type: 'stdio',
-        command: 'npx',
-        args: ['-y', '@grantx/fleet-mcp', '--config', './fleet.config.json'],
-      },
-    },
+  const mcpEntry = {
+    type: 'stdio',
+    command: 'npx',
+    args: ['-y', '@grantx/fleet-mcp', '--config', './fleet.config.json'],
   };
 
-  // Merge with existing .mcp.json if present
   if (fs.existsSync(mcpJsonPath)) {
     try {
       const existing = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'));
       existing.mcpServers = existing.mcpServers || {};
-      existing.mcpServers.fleet = mcpConfig.mcpServers.fleet;
+      existing.mcpServers.fleet = mcpEntry;
       fs.writeFileSync(mcpJsonPath, JSON.stringify(existing, null, 2));
-    } catch {
-      fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
-    }
-  } else {
-    fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+      return;
+    } catch { /* parse failed, overwrite */ }
   }
-  console.log('    .mcp.json (Claude Code MCP registration)');
+  fs.writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: { fleet: mcpEntry } }, null, 2));
+}
 
-  // Create .claude/commands/fleet.md slash command
+function writeFleetCommand(projectRoot) {
   const commandsDir = path.join(projectRoot, '.claude', 'commands');
   fs.mkdirSync(commandsDir, { recursive: true });
   const fleetCommandPath = path.join(commandsDir, 'fleet.md');
   if (!fs.existsSync(fleetCommandPath)) {
     fs.writeFileSync(fleetCommandPath, FLEET_COMMAND_TEMPLATE);
-    console.log('    .claude/commands/fleet.md');
+    console.log('  ✓ .claude/commands/fleet.md');
   }
-
-  // Update .gitignore
-  updateGitignore(projectRoot);
-
-  console.log('');
-  console.log('  Done. Open Claude Code and try: /fleet status');
-  console.log('');
 }
 
 function updateGitignore(projectRoot) {
@@ -209,7 +299,7 @@ function updateGitignore(projectRoot) {
 
   if (modified) {
     fs.writeFileSync(gitignorePath, content.trimEnd() + '\n');
-    console.log('    .gitignore (updated)');
+    console.log('  ✓ .gitignore (updated)');
   }
 }