@fnclaude/cli 1.1.0 → 2.0.0

package/src/argParser.ts

@@ -1,367 +0,0 @@
-/**
- * Bespoke argv parser for fnclaude — ported from the Go implementation at
- * src/main.go in the upstream Go repo. Hand-rolled (no commander/cac) because
- * fnclaude's magic-positional rules don't map cleanly onto generic parsers.
- *
- * Phases, in order:
- *   1. Subcommand expansion   (resume/res/continue/con/fork/fk → long flags)
- *   2. Short-flag translation (-B → --brief, -Gval → --agent val, etc.)
- *   3. Magic-word positional  (model + effort aliases consumed off the front)
- *   4. Positional consumption (path, optional worktree name)
- *   5. Pass-through           (unrecognized flags forwarded to claude)
- *
- * See src/main.go in the Go repo for the canonical spec and src/main_test.go
- * + src/subcommand_test.go + src/positional_worktree_test.go for behavior
- * the TS port preserves.
- */
-
-import { join as pathJoin } from 'node:path';
-import { brandParsed, type ParsedArgs } from './args.js';
-
-// ── Magic-word vocabularies ────────────────────────────────────────────────
-
-const MODEL_ALIASES = new Set(['opus', 'sonnet', 'haiku']);
-const EFFORT_LEVELS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
-
-// Capital short flags with no value.
-const SHORT_NO_VALUE: Record<string, string> = {
-  B: '--brief',
-  C: '--chrome',
-  D: '--dangerously-skip-permissions',
-  F: '--fork-session',
-  I: '--ide',
-  V: '--verbose',
-};
-
-// Capital short flags that REQUIRE a value (next argv token or =val).
-const SHORT_REQUIRED: Record<string, string> = {
-  G: '--agent',
-  M: '--permission-mode',
-  W: '--allowedTools',
-};
-
-// Capital short flags that optionally take a value (greedy; only consumed
-// when the next token is non-flag).
-const SHORT_OPTIONAL: Record<string, string> = {
-  P: '--from-pr',
-  R: '--remote-control',
-  T: '--tmux',
-};
-
-// Subcommand-style positionals → long-flag expansion. `fork` includes
-// --resume because --fork-session requires it on claude's side.
-const SUBCOMMAND_FLAGS: Record<string, readonly string[]> = {
-  resume: ['--resume'],
-  res: ['--resume'],
-  continue: ['--continue'],
-  con: ['--continue'],
-  fork: ['--resume', '--fork-session'],
-  fk: ['--resume', '--fork-session'],
-};
-
-// ── Helpers ────────────────────────────────────────────────────────────────
-
-/**
- * Return the default cwd for invocations with no positional path —
- * `$XDG_CONFIG_HOME/fnclaude/noop`, falling back to `$home/.config/fnclaude/noop`.
- * Matches Go's `defaultNoopDir`.
- */
-export function defaultNoopDir(home: string): string {
-  const base = process.env.XDG_CONFIG_HOME || pathJoin(home, '.config');
-  return pathJoin(base, 'fnclaude', 'noop');
-}
-
-/**
- * Look up the long form of a value-taking short flag char.
- */
-function valueShortLong(ch: string): string | undefined {
-  return SHORT_REQUIRED[ch] ?? SHORT_OPTIONAL[ch];
-}
-
-export interface ParseShortFlagResult {
-  tokens: string[];
-  consumed: number;
-}
-
-/**
- * Parse a single short-flag token like `-B`, `-BVC`, `-G=val`, `-G`, `-Gval`.
- *
- * Returns the long-form tokens to emit and the number of extra argv elements
- * consumed from `rest` (the slice starting AFTER the current token). The
- * caller is responsible for advancing its own cursor by `1 + consumed`.
- *
- * Throws on:
- *   - A required-value short flag in the middle of a collapsed group
- *   - A required-value short flag at EOF with no value
- *   - A required-value short flag followed by another flag
- */
-export function parseShortFlag(arg: string, rest: readonly string[]): ParseShortFlagResult {
-  // Strip the leading '-'.
-  const body = arg.slice(1);
-
-  // -X=val form: only valid for known value-taking single-char flags. Anything
-  // else falls through and we emit the token verbatim.
-  if (body.length >= 3 && body[1] === '=') {
-    const ch = body[0] as string;
-    const val = body.slice(2);
-    const long = valueShortLong(ch);
-    if (long === undefined) {
-      // Unknown -X=val — pass the original token verbatim. Same fallthrough
-      // as Go's parseShortFlag.
-      return { tokens: [arg], consumed: 0 };
-    }
-    return { tokens: [`${long}=${val}`], consumed: 0 };
-  }
-
-  const out: string[] = [];
-  for (let pos = 0; pos < body.length; pos++) {
-    const ch = body[pos] as string;
-    const isLast = pos === body.length - 1;
-
-    if (SHORT_NO_VALUE[ch]) {
-      out.push(SHORT_NO_VALUE[ch]!);
-      continue;
-    }
-
-    const required = SHORT_REQUIRED[ch];
-    if (required) {
-      if (!isLast) {
-        throw new Error(
-          `fnclaude: flag -${ch} cannot be in middle of collapsed group, requires a value`,
-        );
-      }
-      if (rest.length === 0 || rest[0]!.startsWith('-')) {
-        throw new Error(`fnclaude: -${ch} requires a value`);
-      }
-      return { tokens: [...out, required, rest[0]!], consumed: 1 };
-    }
-
-    const optional = SHORT_OPTIONAL[ch];
-    if (optional) {
-      if (!isLast) {
-        throw new Error(
-          `fnclaude: flag -${ch} cannot be in middle of collapsed group, requires a value`,
-        );
-      }
-      if (rest.length > 0 && !rest[0]!.startsWith('-')) {
-        return { tokens: [...out, optional, rest[0]!], consumed: 1 };
-      }
-      return { tokens: [...out, optional], consumed: 0 };
-    }
-
-    // Unknown single-char short flag — pass through verbatim. Lets claude
-    // either accept it or surface its own error.
-    out.push(`-${ch}`);
-  }
-
-  return { tokens: out, consumed: 0 };
-}
-
-// ── Main parser ────────────────────────────────────────────────────────────
-
-/**
- * parseArgs is the canonical argv parser. `home` is the user's home dir
- * (typically `os.homedir()`); it's used to derive the noop fallback path.
- *
- * Returns a `ParsedArgs` — the first stage of the immutable argv pipeline.
- * Notably absent: `worktreeMatched`. That value only becomes meaningful
- * after the intercept stage and is part of `InterceptedArgs` instead.
- *
- * Throws Error on invalid input (too many positionals, missing values,
- * collapsed-group misuse, two subcommands, etc.). The Go original returns
- * `(Args, error)`; TS uses throw for the natural shape.
- */
-export function parseArgs(argv: readonly string[], home: string): ParsedArgs {
-  let firstPath = '';
-  const extraDirs: string[] = [];
-  const passthrough: string[] = [];
-  let noTmux = false;
-  let worktreeSet = false;
-  let worktreeArg: string | undefined;
-
-  // Magic slots: filled at most once each, in strict order.
-  let magicModel = '';
-  let magicEffort = '';
-
-  // Subcommand expansion: long-flag tokens to prepend to passthrough.
-  let subcommandExpansion: readonly string[] | undefined;
-  let subcommandToken = '';
-
-  // 0 = position 1 (check model)
-  // 1 = position 2 (check effort, only if model matched)
-  // 2 = magic done
-  let magicState = 0;
-
-  let inFlags = false;
-  let firstPathSet = false;
-
-  let i = 0;
-  while (i < argv.length) {
-    const arg = argv[i] as string;
-
-    // ── Positional phase (before first flag-shaped token) ───────────────
-    if (!inFlags && !arg.startsWith('-')) {
-      // Subcommand check fires at every positional slot, independent of
-      // magic state — does NOT advance magicState, so `fnc resume opus xhigh`
-      // and `fnc opus xhigh resume` parse equivalently.
-      const subFlags = SUBCOMMAND_FLAGS[arg];
-      if (subFlags) {
-        if (subcommandExpansion !== undefined) {
-          throw new Error(
-            `fnclaude: only one subcommand allowed (got "${subcommandToken}" and "${arg}")`,
-          );
-        }
-        subcommandExpansion = subFlags;
-        subcommandToken = arg;
-        i++;
-        continue;
-      }
-
-      if (magicState === 0) {
-        if (MODEL_ALIASES.has(arg)) {
-          magicModel = arg;
-          magicState = 1; // advance to effort check at position 2
-          i++;
-          continue;
-        }
-        magicState = 2; // not a model alias → magic done; arg is cwd
-      } else if (magicState === 1) {
-        if (EFFORT_LEVELS.has(arg)) {
-          magicEffort = arg;
-          magicState = 2;
-          i++;
-          continue;
-        }
-        magicState = 2; // not an effort level → magic done; arg is cwd
-      }
-
-      if (!firstPathSet) {
-        firstPath = arg;
-        firstPathSet = true;
-      } else if (!worktreeSet) {
-        worktreeSet = true;
-        worktreeArg = arg;
-      } else {
-        throw new Error(
-          `fnclaude: too many positional arguments (got "${arg}"; max is 2 — cwd and worktree-name)`,
-        );
-      }
-      i++;
-      continue;
-    }
-
-    // ── Flag territory ──────────────────────────────────────────────────
-    inFlags = true;
-
-    if (arg === '--no-tmux') {
-      noTmux = true;
-      i++;
-      continue;
-    }
-
-    // -A / --also (space form).
-    if (arg === '-A' || arg === '--also') {
-      const next = argv[i + 1];
-      if (next === undefined || next.startsWith('-')) {
-        const which = next === undefined ? arg : `${arg} ${next}`;
-        throw new Error(`fnclaude: ${which} requires a directory argument`);
-      }
-      extraDirs.push(next);
-      i += 2;
-      continue;
-    }
-    // -A=val / --also=val.
-    if (arg.startsWith('-A=')) {
-      const val = arg.slice(3);
-      if (val === '') throw new Error('fnclaude: -A= requires a directory argument');
-      extraDirs.push(val);
-      i++;
-      continue;
-    }
-    if (arg.startsWith('--also=')) {
-      const val = arg.slice('--also='.length);
-      if (val === '') throw new Error('fnclaude: --also= requires a directory argument');
-      extraDirs.push(val);
-      i++;
-      continue;
-    }
-
-    // -w / --worktree (intercepted; NOT pushed to passthrough here).
-    if (arg === '-w' || arg === '--worktree') {
-      worktreeSet = true;
-      const next = argv[i + 1];
-      if (next !== undefined && !next.startsWith('-')) {
-        worktreeArg = next;
-        i += 2;
-      } else {
-        i++;
-      }
-      continue;
-    }
-    if (arg.startsWith('-w=')) {
-      worktreeSet = true;
-      worktreeArg = arg.slice(3);
-      i++;
-      continue;
-    }
-    if (arg.startsWith('--worktree=')) {
-      worktreeSet = true;
-      worktreeArg = arg.slice('--worktree='.length);
-      i++;
-      continue;
-    }
-
-    // Single-dash short flags (length >= 2, second char is not '-').
-    if (arg.length >= 2 && arg[0] === '-' && arg[1] !== '-') {
-      const { tokens, consumed } = parseShortFlag(arg, argv.slice(i + 1));
-      passthrough.push(...tokens);
-      i += 1 + consumed;
-      continue;
-    }
-
-    // Everything else passes through.
-    passthrough.push(arg);
-    i++;
-  }
-
-  // Build the magic prefix (--model + --effort) and the subcommand prefix.
-  const magicPrefix: string[] = [];
-  if (magicModel) magicPrefix.push('--model', magicModel);
-  if (magicEffort) magicPrefix.push('--effort', magicEffort);
-
-  let finalPassthrough: string[];
-  if (magicPrefix.length > 0) {
-    finalPassthrough = [...magicPrefix, ...passthrough];
-  } else {
-    finalPassthrough = passthrough;
-  }
-  if (subcommandExpansion && subcommandExpansion.length > 0) {
-    finalPassthrough = [...subcommandExpansion, ...finalPassthrough];
-  }
-
-  // CWD fallback.
-  const cwd = firstPathSet ? firstPath : defaultNoopDir(home);
-  const usedNoopFallback = !firstPathSet;
-
-  return brandParsed({
-    cwd,
-    extraDirs,
-    passthrough: finalPassthrough,
-    noTmux,
-    worktreeSet,
-    worktreeArg,
-    usedNoopFallback,
-  });
-}
-
-// ── Passthrough inspection helpers ─────────────────────────────────────────
-//
-// The canonical implementations live in passthrough.ts. Re-exported here
-// for back-compat with callers that grew up importing them from argParser.
-// New code should import from passthrough.ts directly.
-
-export {
-  nameInPassthrough,
-  settingSourcesInPassthrough,
-  tokenInPassthrough,
-} from './passthrough.js';

package/src/args/preserve.ts

@@ -1,338 +0,0 @@
-/**
- * preserveArgs + applyOverrides — flag-merging helpers for fnclaude
- * relaunches (restart / transfer). Ported from src/preserve_args.go.
- *
- * preserveArgs picks the subset of os.Args[1:] to carry across a relaunch:
- *   - keeps leading magic words (model alias / effort level) at the front
- *   - strips contiguous non-flag positional tokens (cwd + worktree-name slots)
- *   - keeps everything from the first flag onward, minus any flag in deny
- *     (with its value token if the flag takes a value)
- *
- * applyOverrides folds MCP-supplied Request override fields into the
- * preserved slice — strip-then-append for strings, three-state nil/true/
- * false semantics for booleans.
- *
- * The Go test suite (src/preserve_args_test.go) is the contract; the TS
- * port mirrors every case 1:1.
- */
-
-import type { RequestOverrides } from '../mcp/protocol.js';
-
-// ── Magic-word vocabularies (must match argParser.ts) ──────────────────────
-
-const MODEL_ALIASES: ReadonlySet<string> = new Set(['opus', 'sonnet', 'haiku']);
-const EFFORT_LEVELS: ReadonlySet<string> = new Set([
-  'low',
-  'medium',
-  'high',
-  'xhigh',
-  'max',
-]);
-
-/** True when tok is a model alias or effort level. */
-export function isMagicWord(tok: string): boolean {
-  return MODEL_ALIASES.has(tok) || EFFORT_LEVELS.has(tok);
-}
-
-/** True when tok looks flag-shaped (starts with "-"). */
-export function isFlag(tok: string): boolean {
-  return tok.length > 0 && tok.charCodeAt(0) === 0x2d /* '-' */;
-}
-
-/**
- * Divide args into [leading-magic-words] and [the rest]. The split stops
- * at the first non-magic token. Used by socket-listener handlers to
- * reposition the magic prefix around the launch cwd / destination.
- */
-export function splitLeadingMagic(args: readonly string[]): {
-  magic: string[];
-  rest: string[];
-} {
-  let i = 0;
-  while (i < args.length && isMagicWord(args[i] as string)) i++;
-  return { magic: args.slice(0, i), rest: args.slice(i) };
-}
-
-/** True when args contains flag as a standalone token or `flag=value`. */
-export function flagPresent(args: readonly string[], flag: string): boolean {
-  const prefix = `${flag}=`;
-  for (const t of args) {
-    if (t === flag || t.startsWith(prefix)) return true;
-  }
-  return false;
-}
-
-// ── preserveArgs ───────────────────────────────────────────────────────────
-
-/**
- * Return the subset of origArgs to carry across an fnclaude relaunch.
- *
- * `deny` is a set of flag tokens (long or short form) to strip. Pass null
- * to preserve all flags. For each denied flag, the flag token AND the
- * immediately-following value token are stripped — UNLESS the flag is in
- * `bareOK`, in which case the bare (no-value) form is allowed and only
- * the flag token is consumed when the following token is itself a flag.
- * The `--flag=value` form is always handled as a single token.
- *
- * Returns a fresh array. Mirrors Go's `preserveArgs(origArgs, deny, bareOK)`.
- */
-export function preserveArgs(
-  origArgs: readonly string[],
-  deny: ReadonlySet<string> | null,
-  bareOK: ReadonlySet<string> | null,
-): string[] {
-  const out: string[] = [];
-  let i = 0;
-
-  // Phase 1: collect leading magic words.
-  while (i < origArgs.length) {
-    const tok = origArgs[i] as string;
-    if (isMagicWord(tok)) {
-      out.push(tok);
-      i++;
-      continue;
-    }
-    break;
-  }
-
-  // Phase 2: skip contiguous positional path tokens (non-flag, non-magic).
-  while (i < origArgs.length) {
-    const tok = origArgs[i] as string;
-    if (isFlag(tok)) break; // reached flags — stop skipping paths
-    i++;
-  }
-
-  // Phase 3: keep flag region, minus any denylisted flag (+ its value).
-  while (i < origArgs.length) {
-    const tok = origArgs[i] as string;
-
-    // `--` separates flags from the original session's initial prompt
-    // (everything after is the prompt body). Carrying it across a
-    // relaunch shadows the transfer's @summary file or re-prompts after
-    // --resume on restart — drop the separator and the entire tail.
-    if (tok === '--') break;
-
-    // Equals-form (--flag=value): match by the flag-prefix-before-= part.
-    if (deny !== null) {
-      const eq = tok.indexOf('=');
-      if (eq > 0) {
-        const flagPart = tok.slice(0, eq);
-        if (deny.has(flagPart)) {
-          i++;
-          continue;
-        }
-      }
-    }
-
-    // Bare-token deny check.
-    if (deny !== null && deny.has(tok)) {
-      // Skip the flag token. Also try to consume the following value
-      // token unless bareOK says the bare form is acceptable AND the
-      // next token is itself a flag.
-      i++;
-      if (i < origArgs.length) {
-        const next = origArgs[i] as string;
-        if (bareOK !== null && bareOK.has(tok)) {
-          // bareOK: consume the next token only if it's a value
-          // (non-flag, doesn't start with '-'). If it's a flag, leave
-          // it alone — the bare form is allowed here.
-          if (!isFlag(next)) i++;
-        } else {
-          // Not bareOK: always consume the next token as the value.
-          i++;
-        }
-      }
-      continue;
-    }
-
-    out.push(tok);
-    i++;
-  }
-
-  return out;
-}
-
-// ── Transfer denylist ──────────────────────────────────────────────────────
-
-/**
- * Flag tokens that must be stripped when preserving args across a project
- * transfer (fnc_switch_project). These are destination-bound or
- * session-state-bound: carrying them into the new session would either be
- * wrong (--add-dir is the OLD project's dir; -A the OLD extras;
- * --mcp-config the OLD config; --settings the OLD settings) or actively
- * bogus (--resume / --continue / --fork-session / --from-pr reference the
- * OLD session id or PR; -w/--worktree is the OLD worktree name; --name is
- * the OLD session name and the transfer supplies a new one).
- *
- * Source of truth: src/preserve_args.go's `transferDenyFlags`.
- */
-export const transferDenyFlags: ReadonlySet<string> = new Set([
-  '-A',
-  '--also',
-  '--add-dir',
-  '--mcp-config',
-  '--settings',
-  '-w',
-  '--worktree',
-  '-P',
-  '--from-pr',
-  '-r',
-  '--resume',
-  '-c',
-  '--continue',
-  '-F',
-  '--fork-session',
-  '-n',
-  '--name',
-]);
-
-/**
- * Subset of transferDenyFlags that can appear in bare (no-value) form.
- * For these, preserveArgs only consumes the following token when it
- * doesn't look like another flag.
- *
- * Source of truth: src/preserve_args.go's `transferDenyBareOK`.
- */
-export const transferDenyBareOK: ReadonlySet<string> = new Set([
-  '-w',
-  '--worktree',
-  '-r',
-  '--resume',
-  '-c',
-  '--continue',
-  '-F',
-  '--fork-session',
-  '-P',
-  '--from-pr',
-]);
-
-// ── applyOverrides ─────────────────────────────────────────────────────────
-
-/**
- * Fold req's override fields into the preserved arg slice.
- *
- * Three-state semantics:
- *   - string field set (non-empty): strip any existing occurrence of the
- *     corresponding flag (including bare-magic-word form for --model and
- *     --effort), then append "--flag <value>" at the end.
- *   - null/undefined boolean: preserve any existing occurrence.
- *   - true boolean: strip existing, append the bare "--flag".
- *   - false boolean: strip existing, do NOT append.
- *
- * Overrides always emit FLAG form (--model sonnet), never magic-positional
- * form, to avoid the awkward case of mixing magic preservation with
- * overrides.
- */
-export function applyOverrides(
-  preserved: readonly string[],
-  req: RequestOverrides,
-): string[] {
-  let out = preserved.slice();
-
-  // String overrides.
-  if (req.model !== undefined && req.model !== '') {
-    out = stripFlag(out, '--model');
-    out = stripBareMagic(out, MODEL_ALIASES);
-    out.push('--model', req.model);
-  }
-  if (req.effort !== undefined && req.effort !== '') {
-    out = stripFlag(out, '--effort');
-    out = stripBareMagic(out, EFFORT_LEVELS);
-    out.push('--effort', req.effort);
-  }
-  if (req.permission_mode !== undefined && req.permission_mode !== '') {
-    out = stripFlag(out, '--permission-mode');
-    out.push('--permission-mode', req.permission_mode);
-  }
-  if (req.allowed_tools !== undefined && req.allowed_tools !== '') {
-    out = stripFlag(out, '--allowedTools');
-    out.push('--allowedTools', req.allowed_tools);
-  }
-  if (req.agent !== undefined && req.agent !== '') {
-    out = stripFlag(out, '--agent');
-    out.push('--agent', req.agent);
-  }
-
-  // Boolean overrides.
-  out = applyBoolOverride(out, '--brief', req.brief);
-  out = applyBoolOverride(out, '--chrome', req.chrome);
-  out = applyBoolOverride(out, '--ide', req.ide);
-  out = applyBoolOverride(out, '--verbose', req.verbose);
-
-  return out;
-}
-
-/**
- * Remove every occurrence of flag (and its value if present in space-
- * separated form) and every "flag=value" token in args.
- */
-export function stripFlag(args: readonly string[], flag: string): string[] {
-  const result: string[] = [];
-  let i = 0;
-  while (i < args.length) {
-    const tok = args[i] as string;
-    if (tok === flag) {
-      // Space form: consume value if present and not another flag.
-      i++;
-      if (i < args.length && !isFlag(args[i] as string)) {
-        i++;
-      }
-      continue;
-    }
-    if (tok.startsWith(`${flag}=`)) {
-      i++;
-      continue;
-    }
-    result.push(tok);
-    i++;
-  }
-  return result;
-}
-
-/** Remove every occurrence of flag as a bare token. */
-export function stripFlagBare(args: readonly string[], flag: string): string[] {
-  const result: string[] = [];
-  for (const tok of args) {
-    if (tok === flag) continue;
-    result.push(tok);
-  }
-  return result;
-}
-
-/**
- * Remove any token that's a member of the given magic-word set. Used so a
- * Model/Effort override strips the bare positional form (e.g. "opus" or
- * "max") and the resulting argv carries only the explicit --model /
- * --effort flag pair appended later.
- */
-export function stripBareMagic(
-  args: readonly string[],
-  magic: ReadonlySet<string>,
-): string[] {
-  const result: string[] = [];
-  for (const tok of args) {
-    if (magic.has(tok)) continue;
-    result.push(tok);
-  }
-  return result;
-}
-
-/**
- * Apply a tri-state boolean override for a bare flag.
- *
- * - undefined/null → preserve existing.
- * - true           → strip existing dupes + append once.
- * - false          → strip existing.
- */
-export function applyBoolOverride(
-  args: readonly string[],
-  flag: string,
-  b: boolean | null | undefined,
-): string[] {
-  if (b === null || b === undefined) {
-    return args.slice();
-  }
-  const out = stripFlagBare(args, flag);
-  if (b) out.push(flag);
-  return out;
-}