wave-agent-sdk 1.1.4 → 1.2.0

package/dist/stdio/stdioAgent.js

@@ -0,0 +1,341 @@
+/**
+ * StdioAgent — host-side typed wrapper around a JSON-RPC client that mirrors
+ * the Agent API (shared by the VS Code extension and the desktop app).
+ *
+ * In the single-shared-process architecture, all sessions share one transport
+ * client. The NotificationRouter dispatches incoming notifications to the
+ * appropriate StdioAgent via `handleNotification()`. The agent no longer
+ * subscribes directly to the client.
+ *
+ * All session-scoped requests carry `this.sessionId` on the JSON-RPC envelope
+ * so the server can route them to the right Agent.
+ *
+ * `destroy()` only unregisters from the router and sends the destroy request;
+ * it does NOT dispose the shared client.
+ *
+ * The client dependency is the structural `RpcClient` surface (request/notify/
+ * onNotification) so both hosts keep their own transports: vscode's
+ * `StdioClient` (spawn + hostLog) and desktop's `JsonRpcClient` subclasses
+ * (StdioClient / SocketClient).
+ */
+// ── StdioAgent ───────────────────────────────────────────────────
+export class StdioAgent {
+    constructor(client, router, callbacks) {
+        this.latestTotalTokens = 0;
+        this.messages = [];
+        this.queuedMessages = [];
+        this.tasks = [];
+        this.backgroundTasks = [];
+        this.isStreaming = false;
+        this.isCommandRunning = false;
+        this.isCompacting = false;
+        this.client = client;
+        this.router = router;
+        this.callbacks = callbacks;
+    }
+    // ── Lifecycle ─────────────────────────────────────────────────
+    async initialize(params) {
+        const result = (await this.client.request("initialize", params));
+        this.sessionId = result.sessionId;
+        this.workingDirectory = result.workingDirectory;
+        this.sessionCwd = result.workingDirectory;
+        this.permissionMode = result.permissionMode;
+        this.latestTotalTokens = result.latestTotalTokens;
+        // A fresh session has no usage yet; don't let a previous session's
+        // percentage survive into this agent.
+        this.contextUsagePercent = undefined;
+        // Register with the router so subsequent notifications are routed here
+        this.router.register(this.sessionId, this);
+        return result;
+    }
+    async destroy() {
+        if (this.sessionId) {
+            this.router.unregister(this.sessionId);
+        }
+        try {
+            await this.client.request("destroy", undefined, this.sessionId);
+        }
+        catch {
+            // Process may have already exited; best-effort
+        }
+        // NOTE: do NOT dispose the shared client — other sessions may still use it
+    }
+    async restoreSession(sessionId) {
+        await this.client.request("restoreSession", { sessionId }, this.sessionId);
+    }
+    async updateConfig(params) {
+        const oldSessionId = this.sessionId;
+        const result = (await this.client.request("updateConfig", params, this.sessionId));
+        // If sessionId changed, re-register with the router
+        if (oldSessionId && result.sessionId !== oldSessionId) {
+            this.router.unregister(oldSessionId);
+            this.sessionId = result.sessionId;
+            this.router.register(this.sessionId, this);
+            // Sync the host session state: the bridge may have downgraded to a
+            // fresh session (session file missing on recreate). Without this the
+            // host keeps the destroyed sessionId and every later request fails
+            // with "Session not found".
+            this.callbacks.onSessionIdChange?.(this.sessionId);
+        }
+        return result;
+    }
+    // ── Messages ──────────────────────────────────────────────────
+    async sendMessage(text, images, force) {
+        await this.client.request("sendMessage", { text, images, force }, this.sessionId);
+    }
+    async bang(command) {
+        await this.client.request("bang", { command }, this.sessionId);
+    }
+    async abortMessage() {
+        await this.client.request("abortMessage", undefined, this.sessionId);
+    }
+    async clearMessages() {
+        await this.client.request("clearMessages", undefined, this.sessionId);
+    }
+    async compact(customInstructions) {
+        await this.client.request("compact", { customInstructions }, this.sessionId);
+    }
+    async rewindToMessage(messageId) {
+        return (await this.client.request("rewindToMessage", { messageId }, this.sessionId));
+    }
+    async askBtw(question) {
+        return (await this.client.request("askBtw", { question }, this.sessionId));
+    }
+    async removeQueuedMessage(index) {
+        await this.client.request("deleteQueuedMessage", { index }, this.sessionId);
+    }
+    async updateQueuedMessageById(id, patch) {
+        const result = (await this.client.request("updateQueuedMessage", { id, text: patch.content, images: patch.images }, this.sessionId));
+        return result?.ok ?? false;
+    }
+    async removeQueuedMessageById(id) {
+        await this.client.request("deleteQueuedMessageById", { id }, this.sessionId);
+    }
+    async getFullMessageThread() {
+        return (await this.client.request("getFullMessageThread", undefined, this.sessionId));
+    }
+    async getMessages() {
+        const result = (await this.client.request("getMessages", undefined, this.sessionId));
+        this.messages = result.messages;
+        this.contextUsagePercent = result.contextUsagePercent;
+        return result.messages;
+    }
+    async listRewindCheckpoints() {
+        return (await this.client.request("listRewindCheckpoints", undefined, this.sessionId));
+    }
+    async getConfiguredModels() {
+        return (await this.client.request("getConfiguredModels", undefined, this.sessionId));
+    }
+    async setModel(model) {
+        await this.client.request("setModel", { model }, this.sessionId);
+    }
+    // ── Permissions ───────────────────────────────────────────────
+    async setPermissionMode(mode) {
+        await this.client.request("setPermissionMode", { mode }, this.sessionId);
+    }
+    /** Returns cached permission mode (updated via notification). */
+    getPermissionMode() {
+        return this.permissionMode;
+    }
+    /**
+     * Reads the session's current plan file (path + contents). Used by the
+     * /plan command to display the plan when already in plan mode; the CLI side
+     * awaits the path if it is still being generated after setPermissionMode.
+     */
+    async getPlanFile() {
+        return (await this.client.request("getPlanFile", undefined, this.sessionId));
+    }
+    sendPermissionResponse(requestId, decision) {
+        this.client.notify("permissionResponse", { requestId, decision }, this.sessionId);
+    }
+    async getBackgroundTaskOutput(taskId) {
+        const result = (await this.client.request("getBackgroundTaskOutput", { taskId }, this.sessionId));
+        return result.output;
+    }
+    async stopBackgroundTask(taskId) {
+        const result = (await this.client.request("stopBackgroundTask", { taskId }, this.sessionId));
+        return result.success;
+    }
+    async backgroundCurrentTask() {
+        await this.client.request("backgroundCurrentTask", undefined, this.sessionId);
+    }
+    async getWorkflowRuns() {
+        const result = (await this.client.request("getWorkflowRuns", undefined, this.sessionId));
+        return result?.runs ?? [];
+    }
+    async stopWorkflowRun(runId) {
+        const result = (await this.client.request("stopWorkflowRun", { runId }, this.sessionId));
+        return result?.success ?? false;
+    }
+    // ── MCP ───────────────────────────────────────────────────────
+    async getMcpServers() {
+        const result = (await this.client.request("getMcpServers", undefined, this.sessionId));
+        return result.servers;
+    }
+    async connectMcpServer(serverName) {
+        const result = (await this.client.request("connectMcpServer", { serverName }, this.sessionId));
+        return result.success;
+    }
+    async disconnectMcpServer(serverName) {
+        const result = (await this.client.request("disconnectMcpServer", { serverName }, this.sessionId));
+        return result.success;
+    }
+    async getMcpConfigPaths() {
+        const result = (await this.client.request("getMcpConfigPaths", undefined, this.sessionId));
+        return result;
+    }
+    async removeMcpServer(scope, serverName) {
+        const result = (await this.client.request("removeMcpServer", { scope, serverName }, this.sessionId));
+        return result.success;
+    }
+    async deleteSkill(name) {
+        const result = (await this.client.request("deleteSkill", { name }, this.sessionId));
+        return result.success;
+    }
+    async deleteSubagent(name) {
+        const result = (await this.client.request("deleteSubagent", { name }, this.sessionId));
+        return result.success;
+    }
+    async getHooksByScope(scope) {
+        const result = (await this.client.request("getHooksByScope", { scope }, this.sessionId));
+        return result;
+    }
+    async deleteHook(scope, hookName) {
+        await this.client.request("deleteHook", { scope, hookName }, this.sessionId);
+    }
+    // ── Commands ──────────────────────────────────────────────────
+    async getSlashCommands() {
+        const result = (await this.client.request("getSlashCommands", undefined, this.sessionId));
+        return result.commands;
+    }
+    async getSubagentConfigurations() {
+        const result = (await this.client.request("getSubagentConfigurations", undefined, this.sessionId));
+        return result.configurations;
+    }
+    async getSkillMetadata() {
+        const result = (await this.client.request("getSkillMetadata", undefined, this.sessionId));
+        return result.skills;
+    }
+    // ── Notification dispatch (called by NotificationRouter) ──────
+    handleNotification(method, params) {
+        switch (method) {
+            case "userMessageAdded": {
+                const p = params;
+                if (p.message)
+                    this.callbacks.onUserMessageAdded?.(p.message);
+                break;
+            }
+            case "assistantMessageAdded": {
+                const p = params;
+                if (p.message)
+                    this.callbacks.onAssistantMessageAdded?.(p.message);
+                break;
+            }
+            case "assistantContentUpdated":
+                this.callbacks.onAssistantContentUpdated?.(params);
+                break;
+            case "assistantReasoningUpdated":
+                this.callbacks.onAssistantReasoningUpdated?.(params);
+                break;
+            case "toolBlockUpdated":
+                this.callbacks.onToolBlockUpdated?.(params);
+                break;
+            case "errorBlockAdded": {
+                const p = params;
+                this.callbacks.onErrorBlockAdded?.(p.error);
+                break;
+            }
+            case "compactBlockAdded": {
+                const p = params;
+                this.callbacks.onCompactBlockAdded?.(p.content);
+                break;
+            }
+            case "compactionStateChange": {
+                const p = params;
+                this.isCompacting = p.isCompacting;
+                this.callbacks.onCompactionStateChange?.(p.isCompacting);
+                break;
+            }
+            case "compactionContentUpdate": {
+                const p = params;
+                this.callbacks.onCompactionContentUpdate?.(p.content);
+                break;
+            }
+            case "loadingChange": {
+                const p = params;
+                if (p.latestTotalTokens !== undefined) {
+                    this.latestTotalTokens = p.latestTotalTokens;
+                }
+                this.isStreaming = p.loading;
+                this.callbacks.onLoadingChange?.(p.loading);
+                break;
+            }
+            case "contextUsage": {
+                const p = params;
+                this.callbacks.onContextUsage?.(p.percent);
+                break;
+            }
+            case "commandRunningChange": {
+                const p = params;
+                this.isCommandRunning = p.running;
+                this.callbacks.onCommandRunningChange?.(p.running);
+                break;
+            }
+            case "queuedMessagesChange": {
+                const p = params;
+                this.queuedMessages = p.messages;
+                this.callbacks.onQueuedMessagesChange?.(p.messages);
+                break;
+            }
+            case "tasksChange": {
+                const p = params;
+                this.tasks = p.tasks;
+                this.callbacks.onTasksChange?.(p.tasks);
+                break;
+            }
+            case "backgroundTasksChange": {
+                const p = params;
+                this.backgroundTasks = p.tasks;
+                this.callbacks.onBackgroundTasksChange?.(p.tasks);
+                break;
+            }
+            case "sessionIdChange": {
+                const p = params;
+                this.sessionId = p.sessionId;
+                this.callbacks.onSessionIdChange?.(p.sessionId);
+                break;
+            }
+            case "permissionModeChange": {
+                const p = params;
+                this.permissionMode = p.mode;
+                this.callbacks.onPermissionModeChange?.(p.mode);
+                break;
+            }
+            case "mcpServersChange": {
+                const p = params;
+                this.callbacks.onMcpServersChange?.(p.servers);
+                break;
+            }
+            case "workdirChange": {
+                const p = params;
+                this.workingDirectory = p.workdir;
+                this.callbacks.onWorkdirChange?.(p.workdir);
+                break;
+            }
+            case "notificationMessageAdded":
+                this.callbacks.onNotificationMessageAdded?.(params);
+                break;
+            case "permissionRequest": {
+                const p = params;
+                this.callbacks.onPermissionRequest?.(p.requestId, p.context);
+                break;
+            }
+            case "btwContent": {
+                const p = params;
+                if (p)
+                    this.callbacks.onBtwContent?.(p);
+                break;
+            }
+        }
+    }
+}

package/dist/tools/bashTool.js

@@ -413,6 +413,7 @@ The working directory persists between commands. Try to maintain your current wo
                                 ? `${processedOutput}\n\n${reason}`
                                 : reason,
                         error: reason,
+                        metadata: { exitCode: 130 },
                     });
                 }
             };
@@ -554,6 +555,7 @@ The working directory persists between commands. Try to maintain your current wo
                     error: exitCode !== 0
                         ? `Command failed with exit code: ${exitCode}`
                         : undefined,
+                    metadata: { exitCode },
                 });
             };
             child.on("exit", (code) => {

package/dist/tools/exitPlanMode.js

@@ -2,6 +2,11 @@ import { readFile } from "fs/promises";
 import { logger } from "../utils/globalLogger.js";
 import { EXIT_PLAN_MODE_TOOL_NAME } from "../constants/tools.js";
 import { OPERATION_CANCELLED_BY_USER } from "../types/permissions.js";
+// Rejection feedback format aligned with Claude Code (messages.ts):
+// the model reads the fixed prefix + the user's verbatim feedback, without
+// any additional prompt injection.
+const REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+const REJECT_MESSAGE_WITH_REASON_PREFIX = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). To tell you how to proceed, the user said:\n";
 /**
  * Exit Plan Mode Tool Plugin
  */
@@ -90,10 +95,13 @@ Ensure your plan is complete and unambiguous:
                         content: OPERATION_CANCELLED_BY_USER,
                     };
                 }
+                const feedback = permissionResult.message?.trim();
                 return {
                     success: false,
-                    content: `Please update your proposal based on the following user feedback: ${permissionResult.message || "Plan rejected by user"}`,
-                    error: permissionResult.message ? undefined : "Plan rejected by user",
+                    content: feedback
+                        ? `${REJECT_MESSAGE_WITH_REASON_PREFIX}${feedback}`
+                        : REJECT_MESSAGE,
+                    error: feedback ? undefined : "Plan rejected by user",
                 };
             }
             context.permissionManager.setHasExitedPlanMode(true);

package/dist/types/agent.d.ts

@@ -31,6 +31,14 @@ export interface AgentOptions {
     maxTokens?: number;
     /** Preferred language for agent communication */
     language?: string;
+    /**
+     * Per-session override for auto-memory extraction (settings-page toggle
+     * value, carried by hosts over stdio). Takes precedence over settings.json
+     * merged config and WAVE_DISABLE_AUTO_MEMORY env; undefined defers to them.
+     */
+    autoMemoryEnabled?: boolean;
+    /** Per-session override for auto-memory extraction frequency (turns). */
+    autoMemoryFrequency?: number;
     callbacks?: AgentCallbacks;
     restoreSessionId?: string;
     continueLastSession?: boolean;

package/dist/types/commands.d.ts

@@ -2,10 +2,17 @@
  * Slash command and custom command types
  * Dependencies: None
  */
+/** UI-facing source of a skill-derived slash command. "user" covers personal
+ *  (~/.wave、~/.claude、~/.agents) skills; plugin skills carry pluginName. */
+export type SkillSource = "builtin" | "user" | "project" | "plugin";
 export interface SlashCommand {
     id: string;
     name: string;
     description: string;
+    /** Set only on commands registered from skills — GUI slash-command popup
+     * renders a source tag (内置/用户/项目/插件) from it. Plain/custom/plugin
+     * commands leave it undefined. */
+    skillSource?: SkillSource;
     handler: (args?: string, signal?: AbortSignal) => Promise<void> | void;
     /** Whether this command should bypass the message queue when AI is busy.
      * - `true`: always immediate

package/dist/types/configuration.d.ts

@@ -25,7 +25,12 @@ export interface WaveConfiguration {
     permissions?: {
         allow?: string[];
         deny?: string[];
-        permissionMode?: PermissionMode;
+        /**
+         * Default permission mode for restricted tools. Settings key aligns with
+         * Claude Code's `permissions.defaultMode`; the runtime permission context
+         * and CLI `--permission-mode` keep the "permission mode" naming.
+         */
+        defaultMode?: PermissionMode;
         /**
          * List of directories that are considered part of the Safe Zone.
          * File operations within these directories can be auto-accepted.

package/dist/types/hooks.d.ts

@@ -6,6 +6,7 @@
  */
 export type { WaveConfiguration, HookConfiguration, PartialHookConfiguration, HookConfigurationRecord, } from "./configuration.js";
 export type HookEvent = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "SubagentStop" | "PermissionRequest" | "WorktreeCreate" | "WorktreeRemove" | "CwdChanged" | "SessionStart" | "SessionEnd" | "PreCompact" | "PostCompact";
+export declare const HOOK_EVENT_SUMMARIES: Record<HookEvent, string>;
 export interface HookCommand {
     type: "command";
     command: string;

package/dist/types/hooks.js

@@ -4,6 +4,25 @@
  * Provides comprehensive TypeScript types for the Wave Code hooks system,
  * enabling automated actions at specific workflow points.
  */
+// One-line summary per hook event, aligned with Claude Code's
+// HookEventMetadata.summary (hooksConfigManager.ts). Shared by the CLI
+// /hooks detail view and the webview settings hooks page; unknown/plugin
+// events fall back to displaying the event name itself.
+export const HOOK_EVENT_SUMMARIES = {
+    PreToolUse: "Before tool execution",
+    PostToolUse: "After tool execution",
+    UserPromptSubmit: "When the user submits a prompt",
+    Stop: "Right before Claude concludes its response",
+    SubagentStop: "Right before a subagent (Agent tool call) concludes its response",
+    PermissionRequest: "When a permission dialog is displayed",
+    WorktreeCreate: "Create an isolated worktree for VCS-agnostic isolation",
+    WorktreeRemove: "Remove a previously created worktree",
+    CwdChanged: "After the working directory changes",
+    SessionStart: "When a new session is started",
+    SessionEnd: "When a session is ending",
+    PreCompact: "Before conversation compaction",
+    PostCompact: "After conversation compaction",
+};
 // Hook execution errors (non-blocking)
 export class HookExecutionError extends Error {
     constructor(hookCommand, originalError, context) {

package/dist/types/mcp.d.ts

@@ -25,6 +25,9 @@ export interface McpServerStatus {
     config: McpServerConfig;
     /** Pre-resolution URL with template variables preserved for safe display */
     originalUrl?: string;
+    /** Config source: user (~/.wave/mcp.json), project (<workdir>/.mcp.json),
+     *  or plugin (registered from a plugin manifest) */
+    scope?: "user" | "project" | "plugin";
     status: "disconnected" | "connected" | "connecting" | "reconnecting" | "error";
     tools?: McpTool[];
     toolCount?: number;

package/dist/types/messaging.d.ts

@@ -16,7 +16,7 @@ export interface Message {
     additionalFields?: Record<string, unknown>;
     isMeta?: boolean;
 }
-export type MessageBlock = TextBlock | ErrorBlock | ToolBlock | ImageBlock | BangBlock | CompactBlock | ReasoningBlock | FileHistoryBlock | TaskNotificationBlock;
+export type MessageBlock = TextBlock | ErrorBlock | ToolBlock | ImageBlock | CompactBlock | ReasoningBlock | FileHistoryBlock | TaskNotificationBlock;
 export interface TextBlock {
     type: "text";
     content: string;
@@ -62,13 +62,6 @@ export interface ImageBlock {
     type: "image";
     imageUrls?: string[];
 }
-export interface BangBlock {
-    type: "bang";
-    command: string;
-    output: string;
-    stage: "running" | "end";
-    exitCode: number | null;
-}
 export interface CompactBlock {
     type: "compact";
     content: string;

package/dist/types/skills.d.ts

@@ -6,6 +6,17 @@ export interface SkillMetadata {
     name: string;
     description: string;
     type: "personal" | "project" | "builtin";
+    /**
+     * Path to the skill **directory** (the folder containing SKILL.md), never
+     * to SKILL.md itself. Directory-level contract — all consumers rely on it:
+     * - `SkillManager.prepareSkillContent` injects this value for
+     *   `${WAVE_SKILL_DIR}` / `${CLAUDE_SKILL_DIR}` substitutions and reports it
+     *   as the "Base directory for this skill";
+     * - `SkillManager.deleteSkill` removes this path with `rm(recursive)`.
+     * Callers that need the file itself must `join(skillPath, "SKILL.md")`
+     * (misreading this as the file path broke the desktop "Edit" action,
+     * bug 3466438649392128).
+     */
     skillPath: string;
     allowedTools?: string[];
     context?: "fork";

package/dist/utils/bashParser.d.ts

@@ -37,6 +37,23 @@ export declare const DANGEROUS_COMMANDS: string[];
  * FR-019.2 through FR-019.7 in tool-permission-system.md.
  */
 export declare const READ_ONLY_COMMANDS: string[];
+/**
+ * Subset of READ_ONLY_COMMANDS whose arguments are file paths (as opposed to
+ * strings, names, or flags, e.g. echo, pwd, which, basename). These commands
+ * must stay within the Safe Zone: a read-only command accessing a path outside
+ * the working directory / additional directories requires confirmation.
+ * Aligned with Claude Code's PathCommand list.
+ */
+export declare const PATH_COMMANDS: string[];
+/**
+ * Extract file path arguments from a command's argument string.
+ * Tokens starting with "-" are treated as flags and skipped; everything after
+ * a "--" separator counts as a path. Quoted path arguments are unquoted.
+ * Non-path tokens (e.g. a grep pattern) are harmless: they resolve against the
+ * working directory and typically do not exist, so isPathInside falls back to
+ * the nearest existing parent (the workdir itself) and stays inside.
+ */
+export declare function extractPathArgs(args: string): string[];
 /**
  * Registry of commands and their expected subcommand depth for smart prefix extraction.
  * For example, 'git: 2' means 'git commit' is a valid prefix, but 'git' alone is not.

package/dist/utils/bashParser.js

@@ -500,6 +500,78 @@ export const READ_ONLY_COMMANDS = [
     "bc",
     "sleep",
 ];
+/**
+ * Subset of READ_ONLY_COMMANDS whose arguments are file paths (as opposed to
+ * strings, names, or flags, e.g. echo, pwd, which, basename). These commands
+ * must stay within the Safe Zone: a read-only command accessing a path outside
+ * the working directory / additional directories requires confirmation.
+ * Aligned with Claude Code's PathCommand list.
+ */
+export const PATH_COMMANDS = [
+    "ls",
+    "find",
+    "cat",
+    "head",
+    "tail",
+    "wc",
+    "sort",
+    "uniq",
+    "grep",
+    "egrep",
+    "fgrep",
+    "rg",
+    "file",
+    "stat",
+    "du",
+    "df",
+    "tree",
+    "diff",
+    "cmp",
+    "md5sum",
+    "sha256sum",
+    "sha1sum",
+    "xxd",
+    "od",
+    "hexdump",
+    "strings",
+    "readlink",
+    "realpath",
+    "jq",
+    "yq",
+    "cut",
+    "paste",
+    "column",
+    "tr",
+    "awk",
+    "sed",
+];
+/**
+ * Extract file path arguments from a command's argument string.
+ * Tokens starting with "-" are treated as flags and skipped; everything after
+ * a "--" separator counts as a path. Quoted path arguments are unquoted.
+ * Non-path tokens (e.g. a grep pattern) are harmless: they resolve against the
+ * working directory and typically do not exist, so isPathInside falls back to
+ * the nearest existing parent (the workdir itself) and stays inside.
+ */
+export function extractPathArgs(args) {
+    const tokens = args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || [];
+    const pathArgs = [];
+    let afterDoubleDash = false;
+    for (const token of tokens) {
+        if (afterDoubleDash) {
+            pathArgs.push(token);
+            continue;
+        }
+        if (token === "--") {
+            afterDoubleDash = true;
+            continue;
+        }
+        if (!token.startsWith("-")) {
+            pathArgs.push(token);
+        }
+    }
+    return pathArgs.map((p) => p.replace(/^['"](.*)['"]$/, "$1"));
+}
 /**
  * Global scope flags for git that only change the target repository or
  * configuration, not the subcommand being run. Shared by TOOL_RULES (smart