flowcollab 0.1.9 → 0.2.0

package/bin/completion.mjs

@@ -9,10 +9,10 @@
 import { positional, die } from './_client.mjs';
 
 const COMMANDS = [
-  'pull', 'claim', 'comment', 'close', 'create', 'propose', 'approve', 'reject',
-  'assign', 'decisions', 'ping', 'whoami', 'heartbeat', 'sync', 'status', 'handoff',
-  'standup', 'search', 'init', 'project', 'close-sprint', 'review', 'login',
-  'edit', 'unblock', 'log', 'completion',
+  'login', 'pull', 'claim', 'comment', 'close', 'create', 'edit', 'unblock',
+  'propose', 'approve', 'reject', 'assign', 'decisions', 'handoff', 'review',
+  'search', 'status', 'standup', 'sync', 'log', 'heartbeat', 'ping', 'pr',
+  'project', 'close-sprint', 'whoami', 'completion',
 ];
 
 const FLAGS = {
@@ -30,25 +30,13 @@ const FLAGS = {
 };
 
 function bashScript() {
-  const cmds = COMMANDS.map(c => `flow-${c}`).join(' ');
+  const hyphenated = COMMANDS.map(c => `flow-${c}`).join(' ');
+  const subcmds = COMMANDS.join(' ');
   return `# Flow CLI bash completion
 # Source this file or add to ~/.bash_completion.d/flow
 
-_flow_complete() {
-  local cur prev words
-  COMPREPLY=()
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  prev="\${COMP_WORDS[COMP_CWORD-1]}"
-
-  local commands="${cmds}"
-
-  if [[ \${COMP_CWORD} -eq 1 ]]; then
-    COMPREPLY=( \$(compgen -W "\$commands" "\$cur") )
-    return
-  fi
-
-  local cmd="\${COMP_WORDS[0]}"
-  local subcmd="\${cmd#flow-}"
+_flow_subcmd_flags() {
+  local subcmd="\$1" cur="\$2"
   case "\$subcmd" in
 ${Object.entries(FLAGS).map(([cmd, flags]) => `    ${cmd})
       COMPREPLY=( \$(compgen -W "${flags.join(' ')}" "\$cur") )
@@ -56,35 +44,85 @@ ${Object.entries(FLAGS).map(([cmd, flags]) => `    ${cmd})
   esac
 }
 
+_flow_complete() {
+  local cur prev
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  local cmd="\${COMP_WORDS[0]}"
+
+  if [[ "\$cmd" == "flow" ]]; then
+    if [[ \${COMP_CWORD} -eq 1 ]]; then
+      COMPREPLY=( \$(compgen -W "${subcmds}" "\$cur") )
+      return
+    fi
+    _flow_subcmd_flags "\${COMP_WORDS[1]}" "\$cur"
+  else
+    local subcmd="\${cmd#flow-}"
+    if [[ \${COMP_CWORD} -eq 1 ]]; then
+      COMPREPLY=( \$(compgen -W "${hyphenated}" "\$cur") )
+      return
+    fi
+    _flow_subcmd_flags "\$subcmd" "\$cur"
+  fi
+}
+
+complete -F _flow_complete flow
 ${COMMANDS.map(c => `complete -F _flow_complete flow-${c}`).join('\n')}
 `;
 }
 
 function zshScript() {
   const cmds = COMMANDS.map(c => `flow-${c}`);
-  return `#compdef ${cmds.join(' ')}
+  const subcmdList = COMMANDS.map(c => `'${c}'`).join(' ');
+  return `#compdef flow ${cmds.join(' ')}
 # Flow CLI zsh completion
 # Place in ~/.zfunc/_flow and add fpath=(~/.zfunc $fpath) to ~/.zshrc
 
-_flow_args() {
-  local cmd="\${words[1]#flow-}"
-  case "\$cmd" in
+_flow_flags() {
+  local subcmd="\$1"
+  case "\$subcmd" in
 ${Object.entries(FLAGS).map(([cmd, flags]) => `    ${cmd})
       local opts=(${flags.map(f => `'${f}'`).join(' ')})
       _arguments "\${opts[@]}"
-      ;;`).join('\n')}
-    *)
-      _arguments '*:arg:'
-      ;;
+      return ;;`).join('\n')}
   esac
+  _arguments '*:arg:'
+}
+
+_flow() {
+  local state
+  if [[ "\${words[1]}" == "flow" ]]; then
+    _arguments '1:subcommand:(${subcmdList})' '*:: :->args'
+    case "\$state" in args) _flow_flags "\${words[1]}" ;; esac
+  else
+    _flow_flags "\${words[1]#flow-}"
+  fi
 }
 
-${cmds.map(c => `compdef _flow_args ${c}`).join('\n')}
+compdef _flow flow
+${cmds.map(c => `compdef _flow ${c}`).join('\n')}
 `;
 }
 
 function fishScript() {
   const lines = [];
+  // Parent 'flow' command: subcommand completions
+  lines.push('# flow (parent command)');
+  for (const cmd of COMMANDS) {
+    lines.push(`complete -c flow -f -n '__fish_use_subcommand' -a ${cmd}`);
+  }
+  lines.push('');
+  // Per-subcommand flags for 'flow <sub>' form
+  for (const [cmd, flags] of Object.entries(FLAGS)) {
+    lines.push(`# flow ${cmd}`);
+    for (const f of flags) {
+      const name = f.replace(/^--/, '').replace(/=$/, '');
+      const hasArg = f.endsWith('=');
+      lines.push(`complete -c flow -n '__fish_seen_subcommand_from ${cmd}' -l ${name}${hasArg ? ' -r' : ''}`);
+    }
+  }
+  lines.push('');
+  // Hyphenated aliases
   for (const cmd of COMMANDS) {
     lines.push(`# flow-${cmd}`);
     const flags = FLAGS[cmd] || [];

package/bin/flow.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+/* flow — unified CLI router.
+   Usage: flow <command> [args]
+   Run 'flow --help' for the full command list.
+*/
+
+import { spawnSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+// Mirror the _client.mjs TLS re-spawn so the child sees --use-system-ca
+// and doesn't re-spawn a third time (checks process.execArgv).
+if (process.platform === 'win32' && !process.execArgv.includes('--use-system-ca')) {
+  const r = spawnSync(process.execPath, ['--use-system-ca', ...process.argv.slice(1)], {
+    stdio: 'inherit',
+    env: process.env,
+  });
+  process.exit(r.status ?? 1);
+}
+
+const __dir = dirname(fileURLToPath(import.meta.url));
+
+// ── Command registry ────────────────────────────────────────────────────────
+const CMDS = [
+  ['login',        'login.mjs',        'Authorize the CLI via browser (device flow)'],
+  ['pull',         'pull.mjs',         'Fetch board snapshot + @mentions (start of day)'],
+  ['claim',        'claim.mjs',        'Claim a task and mark it in-progress'],
+  ['comment',      'comment.mjs',      'Post a comment on a task'],
+  ['close',        'close.mjs',        'Mark a task done with a summary'],
+  ['create',       'create.mjs',       'Create a new task'],
+  ['edit',         'edit.mjs',         'Update task fields (title, priority, area, due…)'],
+  ['unblock',      'unblock.mjs',      'Clear a task\'s blocked-by dependency'],
+  ['propose',      'propose.mjs',      'Propose a sub-task for human approval'],
+  ['approve',      'approve.mjs',      'Approve a pending proposal'],
+  ['reject',       'reject.mjs',       'Reject a pending proposal with a reason'],
+  ['assign',       'assign.mjs',       'Assign a task to another actor'],
+  ['decisions',    'decisions.mjs',    'List pending proposals awaiting approval'],
+  ['handoff',      'handoff.mjs',      'Hand off a task to another agent'],
+  ['review',       'review.mjs',       'Request code review; moves task to in-review'],
+  ['search',       'search.mjs',       'Search tasks by text, status, area, or assignee'],
+  ['status',       'status.mjs',       'Quick board summary'],
+  ['standup',      'standup.mjs',      'Done/in-progress digest; --velocity for trend chart'],
+  ['sync',         'sync.mjs',         'Delta sync since N minutes (default 60)'],
+  ['log',          'log.mjs',          'Tail recent timeline events'],
+  ['heartbeat',    'heartbeat.mjs',    'Send a presence ping (~60s while active)'],
+  ['ping',         'ping.mjs',         'Health check or send a direct agent message'],
+  ['pr',           'pr.mjs',           'Record a PR link on a task timeline'],
+  ['project',      'project.mjs',      'List GitHub Projects v2 items'],
+  ['close-sprint', 'close-sprint.mjs', 'Close a sprint milestone (owner only)'],
+  ['whoami',       'whoami.mjs',       'Verify token and show current identity'],
+  ['completion',   'completion.mjs',   'Print shell completion script (bash/zsh/fish)'],
+];
+
+const CMD_MAP = new Map(CMDS.map(([name, file]) => [name, file]));
+
+// ── Help ────────────────────────────────────────────────────────────────────
+function printHelp() {
+  let version = '';
+  try {
+    const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    version = ` v${pkg.version}`;
+  } catch {}
+
+  process.stdout.write(`flow${version} — FlowCollab CLI\n\n`);
+  process.stdout.write(`Usage: flow <command> [options]\n\n`);
+  process.stdout.write(`Commands:\n`);
+  const pad = Math.max(...CMDS.map(([n]) => n.length)) + 2;
+  for (const [name, , desc] of CMDS) {
+    process.stdout.write(`  ${name.padEnd(pad)}${desc}\n`);
+  }
+  process.stdout.write(`\nRun 'flow <command> --help' for command-specific flags.\n`);
+  process.stdout.write(`Hyphenated aliases (flow-login, flow-pull, …) remain supported.\n`);
+}
+
+// ── Dispatch ────────────────────────────────────────────────────────────────
+const [, , sub, ...rest] = process.argv;
+
+if (!sub || sub === '--help' || sub === '-h') {
+  printHelp();
+  process.exit(0);
+}
+
+if (sub === '--version' || sub === '-v') {
+  try {
+    const { version } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    process.stdout.write(`${version}\n`);
+  } catch {
+    process.stdout.write('unknown\n');
+  }
+  process.exit(0);
+}
+
+const target = CMD_MAP.get(sub);
+if (!target) {
+  process.stderr.write(`flow: unknown command '${sub}'\nRun 'flow --help' for the command list.\n`);
+  process.exit(1);
+}
+
+// Splice the subcommand out of argv so target module sees clean args.
+// e.g. [node, flow.mjs, pull, --focus] → [node, flow.mjs, --focus]
+// _client.mjs's arg()/positional() use process.argv.slice(2), so they
+// read [--focus] — identical to what flow-pull sees when called directly.
+process.argv.splice(2, 1);
+
+await import(new URL(target, import.meta.url));

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "flowcollab",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Multi-Claude coordination layer — shared task board + CLI for teams running Claude Code",
   "type": "module",
   "files": [
     "bin/"
   ],
   "bin": {
+    "flow": "bin/flow.mjs",
     "flow-create": "bin/create.mjs",
     "flow-pull": "bin/pull.mjs",
     "flow-claim": "bin/claim.mjs",