vde-worktree 0.0.1 → 0.0.3

package/README.md

@@ -1,45 +1,393 @@
 # vde-worktree
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+`vde-worktree` is a safe Git worktree manager designed for both humans and coding agents.
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+It installs two command names:
+- `vde-worktree`
+- `vw` (alias)
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+Japanese documentation: [README.ja.md](./README.ja.md)
 
-## Purpose
+## Goals
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `vde-worktree`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+- Keep all worktrees in one repo-local location: `.worktree/`
+- Provide idempotent branch-to-worktree operations
+- Prevent accidental destructive actions by default
+- Expose stable JSON output for automation
+- Support hook-driven customization
 
-## What is OIDC Trusted Publishing?
+## Requirements
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+- Node.js 22+
+- pnpm 10+
+- `fzf` (required for `cd`)
+- `gh` (optional, for PR-based merge status)
 
-## Setup Instructions
+## Install / Build
 
-To properly configure OIDC trusted publishing for this package:
+Global install:
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+```bash
+npm install -g vde-worktree
+```
 
-## DO NOT USE THIS PACKAGE
+Local build:
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+```bash
+pnpm install
+pnpm run build
+```
 
-## More Information
+Validate locally:
 
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
+```bash
+pnpm run ci
+```
 
----
+## Quick Start
 
-**Maintained for OIDC setup purposes only**
+```bash
+vw init
+vw switch feature/foo
+cd "$(vw cd)"
+```
+
+`vw cd` prints the selected worktree path. It cannot change the parent shell directory by itself.
+
+## Shell Completion
+
+Generate from command:
+
+```bash
+vw completion zsh
+vw completion fish
+```
+
+Install to default locations:
+
+```bash
+vw completion zsh --install
+vw completion fish --install
+```
+
+Install to custom file path:
+
+```bash
+vw completion zsh --install --path ~/.zsh/completions/_vw
+vw completion fish --install --path ~/.config/fish/completions/vw.fish
+```
+
+For zsh, ensure completion path is loaded:
+
+```bash
+fpath=(~/.zsh/completions $fpath)
+autoload -Uz compinit && compinit
+```
+
+## Managed Directories
+
+After `vw init`, the tool manages:
+
+- `.worktree/` (worktree roots)
+- `.vde/worktree/hooks/`
+- `.vde/worktree/logs/`
+- `.vde/worktree/locks/`
+- `.vde/worktree/state/`
+
+`init` updates `.git/info/exclude` idempotently.
+
+## Global Behavior
+
+- Most write commands require prior `init`.
+- Write commands are protected by an internal repository lock.
+- `--json` prints exactly one JSON object to stdout.
+- Logs and warnings are written to stderr.
+- Non-TTY unsafe overrides require `--allow-unsafe`.
+
+## Global Options
+
+- `--json`: machine-readable single-object output
+- `--verbose`: verbose logging
+- `--no-hooks`: disable hooks for this run (requires `--allow-unsafe`)
+- `--allow-unsafe`: explicit unsafe override
+- `--hook-timeout-ms <ms>`: hook timeout override
+- `--lock-timeout-ms <ms>`: repository lock timeout override
+
+## Command Guide
+
+### `init`
+
+```bash
+vw init
+```
+
+What it does:
+- Creates `.worktree/` and `.vde/worktree/*`
+- Appends managed entries to `.git/info/exclude`
+- Creates default hook templates
+
+### `list`
+
+```bash
+vw list
+vw list --json
+```
+
+What it does:
+- Lists all worktrees from Git porcelain output
+- Includes metadata such as branch, path, dirty, lock, merged, and upstream status
+
+### `status`
+
+```bash
+vw status
+vw status feature/foo
+vw status --json
+```
+
+What it does:
+- Shows one worktree state
+- Without branch argument, resolves current worktree from current `cwd`
+
+### `path`
+
+```bash
+vw path feature/foo
+vw path feature/foo --json
+```
+
+What it does:
+- Resolves and returns the absolute worktree path for the target branch
+
+### `new`
+
+```bash
+vw new
+vw new feature/foo
+```
+
+What it does:
+- Creates a new branch + worktree under `.worktree/`
+- Without argument, generates `wip-xxxxxx`
+
+### `switch`
+
+```bash
+vw switch feature/foo
+```
+
+What it does:
+- Idempotent branch entrypoint
+- Reuses existing worktree if present, otherwise creates one
+
+### `mv`
+
+```bash
+vw mv feature/new-name
+```
+
+What it does:
+- Renames current non-primary worktree branch and moves its directory
+- Requires branch checkout (not detached HEAD)
+
+### `del`
+
+```bash
+vw del
+vw del feature/foo
+vw del feature/foo --force-unmerged --allow-unpushed --allow-unsafe
+```
+
+What it does:
+- Removes worktree and branch safely
+- By default, rejects dirty, locked, unmerged/unknown, or unpushed/unknown states
+
+Useful force flags:
+- `--force-dirty`
+- `--allow-unpushed`
+- `--force-unmerged`
+- `--force-locked`
+- `--force` (enables all force flags)
+
+### `gone`
+
+```bash
+vw gone
+vw gone --apply
+vw gone --json
+```
+
+What it does:
+- Bulk cleanup candidate finder/remover
+- Default mode is dry-run
+- `--apply` actually deletes eligible branches/worktrees
+
+### `get`
+
+```bash
+vw get origin/feature/foo
+```
+
+What it does:
+- Fetches remote branch
+- Creates tracking local branch when missing
+- Creates/reuses local worktree
+
+### `extract`
+
+```bash
+vw extract --current
+vw extract --current --stash
+```
+
+What it does:
+- Extracts current primary worktree branch into `.worktree/`
+- Switches primary worktree back to base branch
+- `--stash` allows extraction when primary is dirty
+
+Current limitation:
+- Implementation currently supports primary worktree extraction flow.
+
+### `use`
+
+```bash
+vw use feature/foo
+vw use feature/foo --allow-agent --allow-unsafe
+```
+
+What it does:
+- Checks out the target branch in the primary worktree
+- Intended for human workflows where primary context must be fixed
+
+Safety:
+- Rejects dirty primary worktree
+- In non-TTY mode, requires `--allow-agent` and `--allow-unsafe`
+
+### `exec`
+
+```bash
+vw exec feature/foo -- pnpm test
+vw exec feature/foo --json -- pnpm test
+```
+
+What it does:
+- Executes command inside the target branch worktree path
+- Does not use shell expansion
+
+Exit behavior:
+- Child success => `0`
+- Child failure => `21` (`CHILD_PROCESS_FAILED` in JSON mode)
+
+### `invoke`
+
+```bash
+vw invoke post-switch
+vw invoke pre-new -- --arg1 --arg2
+```
+
+What it does:
+- Manually invokes `pre-*` / `post-*` hook scripts
+- Useful for debugging hook behavior
+
+### `copy`
+
+```bash
+vw copy .envrc .claude/settings.local.json
+```
+
+What it does:
+- Copies repo-relative files/dirs from repo root into target worktree
+- Primarily intended for hook usage with `WT_WORKTREE_PATH`
+
+### `link`
+
+```bash
+vw link .envrc
+vw link .envrc --no-fallback
+```
+
+What it does:
+- Creates symlink in target worktree pointing to repo-root file
+- On Windows, can fallback to copy unless `--no-fallback`
+
+### `lock` / `unlock`
+
+```bash
+vw lock feature/foo --owner codex --reason "agent in progress"
+vw unlock feature/foo --owner codex
+vw unlock feature/foo --force
+```
+
+What they do:
+- `lock` writes lock metadata under `.vde/worktree/locks/`
+- `unlock` clears lock, enforcing owner match unless `--force`
+
+### `cd`
+
+```bash
+cd "$(vw cd)"
+```
+
+What it does:
+- Interactive worktree picker via `fzf`
+- Prints selected absolute path to stdout
+
+### `completion`
+
+```bash
+vw completion zsh
+vw completion fish
+vw completion zsh --install
+```
+
+What it does:
+- Prints completion script for zsh/fish
+- With `--install`, writes completion file to shell default path or `--path`
+
+## Merge Status (Local + PR)
+
+Each worktree reports:
+
+- `merged.byAncestry`: local ancestry check (`git merge-base --is-ancestor <branch> <baseBranch>`)
+- `merged.byPR`: PR-based merged check via GitHub CLI
+- `merged.overall`: final decision
+
+Overall policy:
+
+- `byPR === true` => `overall = true`
+- `byPR === false` => `overall = false`
+- `byPR === null` => fallback to `byAncestry`
+
+`byPR` becomes `null` when PR lookup is unavailable (for example: `gh` missing, auth missing, API error, or `vde-worktree.enableGh=false`).
+
+## JSON Contract
+
+With `--json`, stdout always emits exactly one JSON object.
+
+Common success fields:
+- `schemaVersion`
+- `command`
+- `status`
+- `repoRoot`
+
+Error shape:
+- `status: "error"`
+- `code`
+- `message`
+- `details`
+
+## Configuration Keys
+
+Configured via `git config`:
+
+- `vde-worktree.baseBranch`
+- `vde-worktree.baseRemote`
+- `vde-worktree.enableGh`
+- `vde-worktree.hooksEnabled`
+- `vde-worktree.hookTimeoutMs`
+- `vde-worktree.lockTimeoutMs`
+- `vde-worktree.staleLockTTLSeconds`
+
+## Current Scope
+
+- Ink-based `tui` is not implemented yet.

package/bin/vde-worktree

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+const isModuleNotFoundFor = (error, entryFile) => {
+  if (typeof error !== "object" || error === null) {
+    return false
+  }
+
+  const withMeta = /** @type {{ code?: string; url?: string; message?: string }} */ (error)
+  if (withMeta.code !== "ERR_MODULE_NOT_FOUND") {
+    return false
+  }
+
+  const expected = `dist/${entryFile}`
+  if (typeof withMeta.url === "string" && (withMeta.url.includes(expected) || withMeta.url.includes(`dist\\${entryFile}`))) {
+    return true
+  }
+
+  return typeof withMeta.message === "string" && withMeta.message.includes(expected)
+}
+
+try {
+  await import("../dist/index.mjs")
+} catch (error) {
+  if (!isModuleNotFoundFor(error, "index.mjs")) {
+    throw error
+  }
+
+  try {
+    await import("../dist/index.js")
+  } catch (fallbackError) {
+    if (isModuleNotFoundFor(fallbackError, "index.js")) {
+      console.error('Failed to load vde-worktree entrypoint from dist. Run "pnpm run build" and try again.')
+      process.exit(1)
+    }
+
+    throw fallbackError
+  }
+}

package/bin/vw

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+const isModuleNotFoundFor = (error, entryFile) => {
+  if (typeof error !== "object" || error === null) {
+    return false
+  }
+
+  const withMeta = /** @type {{ code?: string; url?: string; message?: string }} */ (error)
+  if (withMeta.code !== "ERR_MODULE_NOT_FOUND") {
+    return false
+  }
+
+  const expected = `dist/${entryFile}`
+  if (typeof withMeta.url === "string" && (withMeta.url.includes(expected) || withMeta.url.includes(`dist\\${entryFile}`))) {
+    return true
+  }
+
+  return typeof withMeta.message === "string" && withMeta.message.includes(expected)
+}
+
+try {
+  await import("../dist/index.mjs")
+} catch (error) {
+  if (!isModuleNotFoundFor(error, "index.mjs")) {
+    throw error
+  }
+
+  try {
+    await import("../dist/index.js")
+  } catch (fallbackError) {
+    if (isModuleNotFoundFor(fallbackError, "index.js")) {
+      console.error('Failed to load vde-worktree entrypoint from dist. Run "pnpm run build" and try again.')
+      process.exit(1)
+    }
+
+    throw fallbackError
+  }
+}

package/completions/fish/vw.fish

@@ -0,0 +1,170 @@
+function __vw_worktree_branches
+  command git rev-parse --is-inside-work-tree >/dev/null 2>/dev/null; or return 0
+  command git worktree list --porcelain 2>/dev/null \
+    | string match -r '^branch refs/heads/.+$' \
+    | string replace 'branch refs/heads/' '' \
+    | sort -u
+end
+
+function __vw_current_bin
+  set -l tokens (commandline -opc)
+  if test (count $tokens) -ge 1
+    set -l candidate $tokens[1]
+    if command -sq $candidate
+      echo $candidate
+      return
+    end
+  end
+
+  if command -sq vw
+    echo vw
+    return
+  end
+  if command -sq vde-worktree
+    echo vde-worktree
+    return
+  end
+end
+
+function __vw_worktree_candidates_with_meta
+  command git rev-parse --is-inside-work-tree >/dev/null 2>/dev/null; or return 0
+  set -l vw_bin (__vw_current_bin)
+  test -n "$vw_bin"; or return 0
+
+  command $vw_bin list --json 2>/dev/null | command node -e '
+const fs = require("fs")
+const home = process.env.HOME || ""
+const toDisplayPath = (path) => {
+  if (typeof path !== "string" || path.length === 0) return ""
+  if (home.length === 0) return path
+  if (path === home) return "~"
+  if (path.startsWith(`${home}/`)) return `~${path.slice(home.length)}`
+  return path
+}
+const toFlag = (value) => {
+  if (value === true) return "yes"
+  if (value === false) return "no"
+  return "unknown"
+}
+let payload
+try {
+  payload = JSON.parse(fs.readFileSync(0, "utf8"))
+} catch {
+  process.exit(0)
+}
+const worktrees = Array.isArray(payload.worktrees) ? payload.worktrees : []
+for (const worktree of worktrees) {
+  if (typeof worktree?.branch !== "string" || worktree.branch.length === 0) continue
+  const merged = toFlag(worktree?.merged?.overall)
+  const dirty = worktree?.dirty === true ? "yes" : "no"
+  const locked = worktree?.locked?.value === true ? "yes" : "no"
+  const path = toDisplayPath(worktree?.path)
+  const summary = `merged=${merged} dirty=${dirty} locked=${locked}${path ? ` path=${path}` : ""}`
+  const sanitized = summary.replace(/[\t\r\n]+/g, " ").trim()
+  process.stdout.write(`${worktree.branch}\t${sanitized}\n`)
+}
+' 2>/dev/null
+end
+
+function __vw_local_branches
+  command git rev-parse --is-inside-work-tree >/dev/null 2>/dev/null; or return 0
+  command git for-each-ref --format='%(refname:short)' refs/heads 2>/dev/null | sort -u
+end
+
+function __vw_switch_branches
+  __vw_worktree_branches
+  __vw_local_branches
+end
+
+function __vw_remote_branches
+  command git rev-parse --is-inside-work-tree >/dev/null 2>/dev/null; or return 0
+  command git for-each-ref --format='%(refname:short)' refs/remotes 2>/dev/null \
+    | string match -rv '.*/HEAD$' \
+    | sort -u
+end
+
+function __vw_hook_names
+  command git rev-parse --is-inside-work-tree >/dev/null 2>/dev/null; or return 0
+  set -l repo_root (command git rev-parse --show-toplevel 2>/dev/null); or return 0
+  if test -d "$repo_root/.vde/worktree/hooks"
+    command ls -1 "$repo_root/.vde/worktree/hooks" 2>/dev/null | string match -r '^(pre|post)-' | sort -u
+  end
+end
+
+set -l __vw_commands init list status path new switch mv del gone get extract use exec invoke copy link lock unlock cd completion help
+
+for __vw_bin in vw vde-worktree
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a init -d "Initialize directories, hooks, and managed exclude entries"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a list -d "List worktrees with status metadata"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a status -d "Show a single worktree status"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a path -d "Print absolute worktree path for branch"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a new -d "Create branch + worktree under .worktree"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a switch -d "Idempotent branch entrypoint"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a mv -d "Rename current non-primary worktree branch"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a del -d "Delete worktree + branch with safety checks"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a gone -d "Bulk cleanup by safety-filtered candidate selection"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a get -d "Fetch remote branch and attach worktree"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a extract -d "Extract current primary branch into .worktree"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a use -d "Checkout target branch in primary worktree"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a exec -d "Run command in target branch worktree"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a invoke -d "Manually run hook script"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a copy -d "Copy repo-root files/dirs to target worktree"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a link -d "Create symlink from target worktree to repo-root file"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a lock -d "Create or update lock metadata"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a unlock -d "Remove lock metadata"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a cd -d "Interactive fzf picker"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a completion -d "Print or install shell completion scripts"
+  complete -c $__vw_bin -f -n "not __fish_seen_subcommand_from $__vw_commands" -a help -d "Show help"
+
+  complete -c $__vw_bin -l json -d "Output machine-readable JSON"
+  complete -c $__vw_bin -l verbose -d "Enable verbose logs"
+  complete -c $__vw_bin -l no-hooks -d "Disable hooks for this run (requires --allow-unsafe)"
+  complete -c $__vw_bin -l allow-unsafe -d "Explicit unsafe override in non-TTY mode"
+  complete -c $__vw_bin -l strict-post-hooks -d "Fail when post hooks fail"
+  complete -c $__vw_bin -l hook-timeout-ms -r -d "Override hook timeout"
+  complete -c $__vw_bin -l lock-timeout-ms -r -d "Override lock timeout"
+  complete -c $__vw_bin -s h -l help -d "Show help"
+  complete -c $__vw_bin -s v -l version -d "Show version"
+
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from status" -a "(__vw_worktree_candidates_with_meta)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from path" -a "(__vw_worktree_candidates_with_meta)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from switch" -a "(__vw_switch_branches)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from mv" -a "(__vw_local_branches)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from del" -a "(__vw_worktree_candidates_with_meta)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from get" -a "(__vw_remote_branches)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from use" -a "(__vw_switch_branches)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from exec" -a "(__vw_worktree_candidates_with_meta)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from invoke" -a "(__vw_hook_names)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from lock" -a "(__vw_worktree_candidates_with_meta)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from unlock" -a "(__vw_worktree_candidates_with_meta)"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from help" -a "$__vw_commands"
+
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from del" -l force-dirty -d "Allow dirty worktree for del"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from del" -l allow-unpushed -d "Allow unpushed commits for del"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from del" -l force-unmerged -d "Allow unmerged worktree for del"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from del" -l force-locked -d "Allow deleting locked worktree"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from del" -l force -d "Enable all del force flags"
+
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from gone" -l apply -d "Apply deletion"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from gone" -l dry-run -d "Dry-run mode"
+
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from extract" -l current -d "Extract current worktree branch"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from extract" -l from -r -d "Path used by extract --from"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from extract" -l stash -d "Allow stash when dirty"
+
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from use" -l allow-agent -d "Allow non-TTY execution for use"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from use" -l allow-unsafe -d "Allow unsafe behavior in non-TTY mode"
+
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from link" -l no-fallback -d "Disable copy fallback when symlink fails"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from lock" -l owner -r -d "Lock owner"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from lock" -l reason -r -d "Lock reason"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from unlock" -l owner -r -d "Unlock owner"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from unlock" -l force -d "Force unlock"
+
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from cd" -l prompt -r -d "Custom fzf prompt"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from cd" -l fzf-arg -r -d "Extra argument passed to fzf"
+
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from completion" -a "zsh fish" -d "Shell name"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from completion" -l install -d "Install completion file"
+  complete -c $__vw_bin -n "__fish_seen_subcommand_from completion" -l path -r -d "Install destination file path"
+end