switchman-dev 0.1.8 → 0.1.9

package/src/cli/commands/task.js

@@ -0,0 +1,248 @@
+export function registerTaskCommands(program, {
+  acquireNextTaskLeaseWithRetries,
+  analyzeTaskScope,
+  chalk,
+  completeTaskWithRetries,
+  createTask,
+  failTask,
+  getCurrentWorktreeName,
+  getDb,
+  getRepo,
+  listTasks,
+  printErrorWithNext,
+  pushSyncEvent,
+  releaseFileClaims,
+  retryStaleTasks,
+  retryTask,
+  startTaskLease,
+  statusBadge,
+  taskJsonWithLease,
+}) {
+  const taskCmd = program.command('task').description('Manage the task list');
+  taskCmd.addHelpText('after', `
+Examples:
+  switchman task add "Fix login bug" --priority 8
+  switchman task list --status pending
+  switchman task done task-123
+`);
+
+  taskCmd
+    .command('add <title>')
+    .description('Add a new task to the queue')
+    .option('-d, --description <desc>', 'Task description')
+    .option('-p, --priority <n>', 'Priority 1-10 (default 5)', '5')
+    .option('--id <id>', 'Custom task ID')
+    .action((title, opts) => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      const taskId = createTask(db, {
+        id: opts.id,
+        title,
+        description: opts.description,
+        priority: parseInt(opts.priority),
+      });
+      db.close();
+      const scopeWarning = analyzeTaskScope(title, opts.description || '');
+      console.log(`${chalk.green('✓')} Task created: ${chalk.cyan(taskId)}`);
+      pushSyncEvent('task_added', { task_id: taskId, title, priority: parseInt(opts.priority) }).catch(() => {});
+      console.log(`  ${chalk.dim(title)}`);
+      if (scopeWarning) {
+        console.log(chalk.yellow(`  warning: ${scopeWarning.summary}`));
+        console.log(chalk.yellow(`  next: ${scopeWarning.next_step}`));
+        console.log(chalk.cyan(`  try: ${scopeWarning.command}`));
+      }
+    });
+
+  taskCmd
+    .command('list')
+    .description('List all tasks')
+    .option('-s, --status <status>', 'Filter by status (pending|in_progress|done|failed)')
+    .action((opts) => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      const tasks = listTasks(db, opts.status);
+      db.close();
+
+      if (!tasks.length) {
+        console.log(chalk.dim('No tasks found.'));
+        return;
+      }
+
+      console.log('');
+      for (const t of tasks) {
+        const badge = statusBadge(t.status);
+        const worktree = t.worktree ? chalk.cyan(t.worktree) : chalk.dim('unassigned');
+        console.log(`${badge} ${chalk.bold(t.title)}`);
+        console.log(`  ${chalk.dim('id:')} ${t.id}  ${chalk.dim('worktree:')} ${worktree}  ${chalk.dim('priority:')} ${t.priority}`);
+        if (t.description) console.log(`  ${chalk.dim(t.description)}`);
+        console.log('');
+      }
+    });
+
+  taskCmd
+    .command('assign <taskId> <worktree>')
+    .description('Assign a task to a workspace (compatibility shim for lease acquire)')
+    .option('--agent <name>', 'Agent name (e.g. claude-code)')
+    .action((taskId, worktree, opts) => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      const lease = startTaskLease(db, taskId, worktree, opts.agent);
+      db.close();
+      if (lease) {
+        console.log(`${chalk.green('✓')} Assigned ${chalk.cyan(taskId)} → ${chalk.cyan(worktree)} (${chalk.dim(lease.id)})`);
+      } else {
+        console.log(chalk.red(`Could not assign task. It may not exist or is not in 'pending' status.`));
+      }
+    });
+
+  taskCmd
+    .command('retry <taskId>')
+    .description('Return a failed or stale completed task to pending so it can be revalidated')
+    .option('--reason <text>', 'Reason to record for the retry')
+    .option('--json', 'Output raw JSON')
+    .action((taskId, opts) => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      const task = retryTask(db, taskId, opts.reason || 'manual retry');
+      db.close();
+
+      if (!task) {
+        printErrorWithNext(`Task ${taskId} is not retryable.`, 'switchman task list --status failed');
+        process.exitCode = 1;
+        return;
+      }
+
+      if (opts.json) {
+        console.log(JSON.stringify(task, null, 2));
+        return;
+      }
+
+      console.log(`${chalk.green('✓')} Reset ${chalk.cyan(task.id)} to pending`);
+      pushSyncEvent('task_retried', { task_id: task.id, title: task.title, reason: opts.reason || 'manual retry' }).catch(() => {});
+      console.log(`  ${chalk.dim('title:')} ${task.title}`);
+      console.log(`${chalk.yellow('next:')} switchman task assign ${task.id} <workspace>`);
+    });
+
+  taskCmd
+    .command('retry-stale')
+    .description('Return all currently stale tasks to pending so they can be revalidated together')
+    .option('--pipeline <id>', 'Only retry stale tasks for one pipeline')
+    .option('--reason <text>', 'Reason to record for the retry', 'bulk stale retry')
+    .option('--json', 'Output raw JSON')
+    .action((opts) => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      const result = retryStaleTasks(db, {
+        pipelineId: opts.pipeline || null,
+        reason: opts.reason,
+      });
+      db.close();
+
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+      }
+
+      if (result.retried.length === 0) {
+        const scope = result.pipeline_id ? ` for ${result.pipeline_id}` : '';
+        console.log(chalk.dim(`No stale tasks to retry${scope}.`));
+        return;
+      }
+
+      console.log(`${chalk.green('✓')} Reset ${result.retried.length} stale task(s) to pending`);
+      pushSyncEvent('task_retried', {
+        pipeline_id: result.pipeline_id || null,
+        task_count: result.retried.length,
+        task_ids: result.retried.map((task) => task.id),
+        reason: opts.reason,
+      }).catch(() => {});
+      if (result.pipeline_id) {
+        console.log(`  ${chalk.dim('pipeline:')} ${result.pipeline_id}`);
+      }
+      console.log(`  ${chalk.dim('tasks:')} ${result.retried.map((task) => task.id).join(', ')}`);
+      console.log(`${chalk.yellow('next:')} switchman status`);
+    });
+
+  taskCmd
+    .command('done <taskId>')
+    .description('Mark a task as complete and release all file claims')
+    .action((taskId) => {
+      const repoRoot = getRepo();
+      try {
+        const result = completeTaskWithRetries(repoRoot, taskId);
+        if (result?.status === 'already_done') {
+          console.log(`${chalk.yellow('!')} Task ${chalk.cyan(taskId)} was already marked done — no new changes were recorded`);
+          return;
+        }
+        if (result?.status === 'failed') {
+          console.log(`${chalk.yellow('!')} Task ${chalk.cyan(taskId)} is currently failed — retry it before marking it done again`);
+          return;
+        }
+        if (result?.status === 'not_in_progress') {
+          console.log(`${chalk.yellow('!')} Task ${chalk.cyan(taskId)} is not currently in progress — start a lease before marking it done`);
+          return;
+        }
+        if (result?.status === 'no_active_lease') {
+          console.log(`${chalk.yellow('!')} Task ${chalk.cyan(taskId)} has no active lease — reacquire the task before marking it done`);
+          return;
+        }
+        console.log(`${chalk.green('✓')} Task ${chalk.cyan(taskId)} marked done — file claims released`);
+        pushSyncEvent('task_done', { task_id: taskId }).catch(() => {});
+      } catch (err) {
+        console.error(chalk.red(err.message));
+        process.exitCode = 1;
+      }
+    });
+
+  taskCmd
+    .command('fail <taskId> [reason]')
+    .description('Mark a task as failed')
+    .action((taskId, reason) => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      failTask(db, taskId, reason);
+      releaseFileClaims(db, taskId);
+      db.close();
+      console.log(`${chalk.red('✗')} Task ${chalk.cyan(taskId)} marked failed`);
+      pushSyncEvent('task_failed', { task_id: taskId, reason: reason || null }).catch(() => {});
+    });
+
+  taskCmd
+    .command('next')
+    .description('Get the next pending task quickly (use `lease next` for the full workflow)')
+    .option('--json', 'Output as JSON')
+    .option('--worktree <name>', 'Workspace to assign the task to (defaults to the current folder name)')
+    .option('--agent <name>', 'Agent identifier for logging (e.g. claude-code)')
+    .addHelpText('after', `
+Examples:
+  switchman task next
+  switchman task next --json
+`)
+    .action((opts) => {
+      const repoRoot = getRepo();
+      const worktreeName = getCurrentWorktreeName(opts.worktree);
+      const { task, lease, exhausted } = acquireNextTaskLeaseWithRetries(repoRoot, worktreeName, opts.agent || null);
+
+      if (!task) {
+        if (opts.json) console.log(JSON.stringify({ task: null }));
+        else if (exhausted) console.log(chalk.dim('No pending tasks.'));
+        else console.log(chalk.yellow('Tasks were claimed by other agents during assignment. Run again to get the next one.'));
+        return;
+      }
+
+      if (!lease) {
+        if (opts.json) console.log(JSON.stringify({ task: null, message: 'Task claimed by another agent — try again' }));
+        else console.log(chalk.yellow('Task was just claimed by another agent. Run again to get the next one.'));
+        return;
+      }
+
+      if (opts.json) {
+        console.log(JSON.stringify(taskJsonWithLease(task, worktreeName, lease), null, 2));
+      } else {
+        console.log(`${chalk.green('✓')} Assigned: ${chalk.bold(task.title)}`);
+        console.log(`  ${chalk.dim('id:')} ${task.id}  ${chalk.dim('worktree:')} ${chalk.cyan(worktreeName)}  ${chalk.dim('lease:')} ${chalk.dim(lease.id)}  ${chalk.dim('priority:')} ${task.priority}`);
+      }
+    });
+
+  return taskCmd;
+}

package/src/cli/commands/telemetry.js

@@ -0,0 +1,108 @@
+export function registerTelemetryCommands(program, {
+  chalk,
+  disableTelemetry,
+  enableTelemetry,
+  getTelemetryConfigPath,
+  getTelemetryRuntimeConfig,
+  loadTelemetryConfig,
+  printErrorWithNext,
+  sendTelemetryEvent,
+}) {
+  const telemetryCmd = program.command('telemetry').description('Control anonymous opt-in telemetry for Switchman');
+
+  telemetryCmd
+    .command('status')
+    .description('Show whether telemetry is enabled and where events would be sent')
+    .option('--home <path>', 'Override the home directory for telemetry config')
+    .option('--json', 'Output raw JSON')
+    .action((opts) => {
+      const config = loadTelemetryConfig(opts.home || undefined);
+      const runtime = getTelemetryRuntimeConfig();
+      const payload = {
+        enabled: config.telemetry_enabled === true,
+        configured: Boolean(runtime.apiKey) && !runtime.disabled,
+        install_id: config.telemetry_install_id,
+        destination: runtime.apiKey && !runtime.disabled ? runtime.host : null,
+        config_path: getTelemetryConfigPath(opts.home || undefined),
+      };
+
+      if (opts.json) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+      }
+
+      console.log(`Telemetry: ${payload.enabled ? chalk.green('enabled') : chalk.yellow('disabled')}`);
+      console.log(`Configured destination: ${payload.configured ? chalk.cyan(payload.destination) : chalk.dim('not configured')}`);
+      console.log(`Config file: ${chalk.dim(payload.config_path)}`);
+      if (payload.install_id) {
+        console.log(`Install ID: ${chalk.dim(payload.install_id)}`);
+      }
+    });
+
+  telemetryCmd
+    .command('enable')
+    .description('Enable anonymous telemetry for setup and operator workflows')
+    .option('--home <path>', 'Override the home directory for telemetry config')
+    .action((opts) => {
+      const runtime = getTelemetryRuntimeConfig();
+      if (!runtime.apiKey || runtime.disabled) {
+        printErrorWithNext('Telemetry destination is not configured. Set SWITCHMAN_TELEMETRY_API_KEY first.', 'switchman telemetry status');
+        process.exitCode = 1;
+        return;
+      }
+      const result = enableTelemetry(opts.home || undefined);
+      console.log(`${chalk.green('✓')} Telemetry enabled`);
+      console.log(`  ${chalk.dim(result.path)}`);
+    });
+
+  telemetryCmd
+    .command('disable')
+    .description('Disable anonymous telemetry')
+    .option('--home <path>', 'Override the home directory for telemetry config')
+    .action((opts) => {
+      const result = disableTelemetry(opts.home || undefined);
+      console.log(`${chalk.green('✓')} Telemetry disabled`);
+      console.log(`  ${chalk.dim(result.path)}`);
+    });
+
+  telemetryCmd
+    .command('test')
+    .description('Send one test telemetry event and report whether delivery succeeded')
+    .option('--home <path>', 'Override the home directory for telemetry config')
+    .option('--json', 'Output raw JSON')
+    .action(async (opts) => {
+      const result = await sendTelemetryEvent('telemetry_test', {
+        app_version: program.version(),
+        os: process.platform,
+        node_version: process.version,
+        source: 'switchman-cli-test',
+      }, { homeDir: opts.home || undefined });
+
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        if (!result.ok) process.exitCode = 1;
+        return;
+      }
+
+      if (result.ok) {
+        console.log(`${chalk.green('✓')} Telemetry test event delivered`);
+        console.log(`  ${chalk.dim('destination:')} ${chalk.cyan(result.destination)}`);
+        if (result.status) {
+          console.log(`  ${chalk.dim('status:')} ${result.status}`);
+        }
+        return;
+      }
+
+      printErrorWithNext(`Telemetry test failed (${result.reason || 'unknown_error'}).`, 'switchman telemetry status');
+      console.log(`  ${chalk.dim('destination:')} ${result.destination || 'unknown'}`);
+      if (result.status) {
+        console.log(`  ${chalk.dim('status:')} ${result.status}`);
+      }
+      if (result.error) {
+        console.log(`  ${chalk.dim('error:')} ${result.error}`);
+      }
+      process.exitCode = 1;
+    });
+
+  return telemetryCmd;
+}

package/src/cli/commands/worktree.js

@@ -0,0 +1,85 @@
+export function registerWorktreeCommands(program, {
+  chalk,
+  evaluateRepoCompliance,
+  getDb,
+  getRepo,
+  installMcpConfig,
+  listGitWorktrees,
+  listWorktrees,
+  registerWorktree,
+  statusBadge,
+}) {
+  const wtCmd = program.command('worktree').alias('workspace').description('Manage registered workspaces (Git worktrees)');
+  wtCmd.addHelpText('after', `
+Plain English:
+  worktree = the Git feature behind each agent workspace
+
+Examples:
+  switchman worktree list
+  switchman workspace list
+  switchman worktree sync
+`);
+
+  wtCmd
+    .command('add <name> <path> <branch>')
+    .description('Register a workspace with Switchman')
+    .option('--agent <name>', 'Agent assigned to this worktree')
+    .action((name, path, branch, opts) => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      registerWorktree(db, { name, path, branch, agent: opts.agent });
+      db.close();
+      console.log(`${chalk.green('✓')} Registered worktree: ${chalk.cyan(name)}`);
+    });
+
+  wtCmd
+    .command('list')
+    .description('List all registered workspaces')
+    .action(() => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      const worktrees = listWorktrees(db);
+      const gitWorktrees = listGitWorktrees(repoRoot);
+
+      if (!worktrees.length && !gitWorktrees.length) {
+        db.close();
+        console.log(chalk.dim('No workspaces found. Run `switchman setup --agents 3` or `switchman worktree sync`.'));
+        return;
+      }
+
+      const complianceReport = evaluateRepoCompliance(db, repoRoot, gitWorktrees);
+      console.log('');
+      console.log(chalk.bold('Git Worktrees:'));
+      for (const wt of gitWorktrees) {
+        const dbInfo = worktrees.find((d) => d.path === wt.path);
+        const complianceInfo = complianceReport.worktreeCompliance.find((entry) => entry.worktree === wt.name) || null;
+        const agent = dbInfo?.agent ? chalk.cyan(dbInfo.agent) : chalk.dim('no agent');
+        const status = dbInfo?.status ? statusBadge(dbInfo.status) : chalk.dim('unregistered');
+        const compliance = complianceInfo?.compliance_state ? statusBadge(complianceInfo.compliance_state) : dbInfo?.compliance_state ? statusBadge(dbInfo.compliance_state) : chalk.dim('unknown');
+        console.log(`  ${chalk.bold(wt.name.padEnd(20))} ${status} ${compliance} branch: ${chalk.cyan(wt.branch || 'unknown')}  agent: ${agent}`);
+        console.log(`    ${chalk.dim(wt.path)}`);
+        if ((complianceInfo?.unclaimed_changed_files || []).length > 0) {
+          console.log(`    ${chalk.red('files:')} ${complianceInfo.unclaimed_changed_files.slice(0, 5).join(', ')}${complianceInfo.unclaimed_changed_files.length > 5 ? ` ${chalk.dim(`+${complianceInfo.unclaimed_changed_files.length - 5} more`)}` : ''}`);
+        }
+      }
+      console.log('');
+      db.close();
+    });
+
+  wtCmd
+    .command('sync')
+    .description('Sync Git workspaces into the Switchman database')
+    .action(() => {
+      const repoRoot = getRepo();
+      const db = getDb(repoRoot);
+      const gitWorktrees = listGitWorktrees(repoRoot);
+      for (const wt of gitWorktrees) {
+        registerWorktree(db, { name: wt.name, path: wt.path, branch: wt.branch || 'unknown' });
+      }
+      db.close();
+      installMcpConfig([...new Set([repoRoot, ...gitWorktrees.map((wt) => wt.path)])]);
+      console.log(`${chalk.green('✓')} Synced ${gitWorktrees.length} worktree(s) from git`);
+    });
+
+  return wtCmd;
+}