@wingman-ai/gateway 0.1.0

package/dist/cli/commands/init.cjs

@@ -0,0 +1,681 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
+}();
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    executeInitCommand: ()=>executeInitCommand
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_url_namespaceObject = require("node:url");
+const external_chalk_namespaceObject = require("chalk");
+var external_chalk_default = /*#__PURE__*/ __webpack_require__.n(external_chalk_namespaceObject);
+const prompts_namespaceObject = require("@clack/prompts");
+const outputManager_cjs_namespaceObject = require("../core/outputManager.cjs");
+const schema_cjs_namespaceObject = require("../config/schema.cjs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
+const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs");
+const modelFactory_cjs_namespaceObject = require("../../agent/config/modelFactory.cjs");
+const DEFAULT_AGENT_ID = "wingman";
+const DEFAULT_AGENT_DESCRIPTION = "General-purpose coding assistant for this workspace.";
+const DEFAULT_AGENT_PROMPT = "You are Wingman, a coding assistant for this repository.\nBe direct and concise. Ask clarifying questions when requirements are unclear.\nPrefer minimal diffs and safe changes. Avoid destructive actions unless asked.\nUse tools to inspect the codebase before editing.";
+const DEFAULT_TOOLS = [
+    "code_search",
+    "git_status",
+    "command_execute",
+    "internet_search",
+    "think"
+];
+const DEFAULT_FS_ROOT = ".";
+const DEFAULT_MODELS = {
+    anthropic: "anthropic:claude-sonnet-4-5",
+    openai: "openai:gpt-4o",
+    openrouter: "openrouter:openai/gpt-4o",
+    copilot: "copilot:gpt-4o",
+    xai: "xai:grok-beta"
+};
+async function executeInitCommand(args, options = {}) {
+    const outputManager = new outputManager_cjs_namespaceObject.OutputManager(args.outputMode);
+    const logger = (0, external_logger_cjs_namespaceObject.createLogger)(args.verbosity);
+    const workspace = options.workspace || process.cwd();
+    const configDir = options.configDir || ".wingman";
+    const configRoot = (0, external_node_path_namespaceObject.join)(workspace, configDir);
+    const configPath = (0, external_node_path_namespaceObject.join)(configRoot, "wingman.config.json");
+    try {
+        if (isHelpCommand(args.subcommand)) return void showInitHelp(outputManager, args.outputMode);
+        const optionMap = args.options || {};
+        const nonInteractive = "interactive" !== outputManager.getMode() || getBooleanOption(optionMap, [
+            "yes",
+            "non-interactive"
+        ], false);
+        const skipConfig = getBooleanOption(optionMap, [
+            "skip-config"
+        ], false);
+        const skipAgent = getBooleanOption(optionMap, [
+            "skip-agent"
+        ], false);
+        const skipProvider = getBooleanOption(optionMap, [
+            "skip-provider"
+        ], false);
+        const force = getBooleanOption(optionMap, [
+            "force"
+        ], false);
+        const merge = getBooleanOption(optionMap, [
+            "merge"
+        ], false);
+        const fsRoot = getStringOption(optionMap, [
+            "fs-root"
+        ]) || DEFAULT_FS_ROOT;
+        const useClack = shouldUseClack(outputManager, nonInteractive);
+        renderInitBanner(outputManager, nonInteractive);
+        const bundledAgentsPath = resolveBundledAgentsPath();
+        const bundledAgents = bundledAgentsPath ? listBundledAgents(bundledAgentsPath) : [];
+        const explicitAgent = Boolean(args.agent?.trim()) || Boolean(args.subcommand) && !isHelpCommand(args.subcommand) && !args.subcommand.startsWith("-");
+        const agentPlan = await resolveAgentPlan({
+            explicitAgent,
+            defaultAgentId: resolveAgentId(args),
+            bundledAgents,
+            nonInteractive,
+            optionMap,
+            outputManager
+        });
+        const providerName = await resolveProviderSelection({
+            nonInteractive,
+            skipProvider,
+            optionMap,
+            outputManager
+        });
+        const model = await resolveModelSelection({
+            nonInteractive,
+            optionMap,
+            providerName,
+            outputManager
+        });
+        if (skipConfig) writeLine(outputManager, "Skipping config setup (--skip-config).");
+        else await runStep(useClack, "Writing workspace config", async ()=>handleConfigSetup({
+                configPath,
+                configRoot,
+                agentId: agentPlan.defaultAgentId,
+                fsRoot,
+                force,
+                merge,
+                nonInteractive,
+                outputManager
+            }));
+        if (skipAgent) writeLine(outputManager, "Skipping starter agent (--skip-agent).");
+        else await runStep(useClack, "Installing bundled agents", async ()=>handleAgentSetup({
+                configRoot,
+                agentId: agentPlan.defaultAgentId,
+                model,
+                force,
+                nonInteractive,
+                outputManager,
+                bundledAgentsPath,
+                copyAgents: agentPlan.copyAgents
+            }));
+        if (skipProvider) writeLine(outputManager, "Skipping provider setup (--skip-provider).");
+        else await runStep(useClack, "Connecting providers", async ()=>handleProviderSetup({
+                providerName,
+                optionMap,
+                nonInteractive,
+                outputManager
+            }));
+        if (useClack) (0, prompts_namespaceObject.outro)(external_chalk_default().green("Wingman init complete."));
+        else {
+            writeLine(outputManager, "");
+            writeLine(outputManager, "Wingman init complete.");
+        }
+        writeLine(outputManager, `Workspace: ${workspace}`);
+        writeLine(outputManager, `Config: ${configPath}`);
+        writeLine(outputManager, `Agent: ${skipAgent ? "skipped" : agentPlan.defaultAgentId}`);
+        if (!model) writeLine(outputManager, "Note: No model set yet. Update your agent config with a model string.");
+        writeLine(outputManager, "");
+        writeLine(outputManager, "Next steps:");
+        writeLine(outputManager, `  1) wingman agent --local --agent ${agentPlan.defaultAgentId} "hello"`);
+        writeLine(outputManager, "  2) wingman gateway start");
+    } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+        logger.error("Init command failed", {
+            error: errorMsg
+        });
+        if ("interactive" === outputManager.getMode()) {
+            console.error(`\nError: ${errorMsg}`);
+            console.error(`Logs: ${logFile}`);
+            process.exit(1);
+        } else {
+            outputManager.emitAgentError(error);
+            process.exit(1);
+        }
+    }
+}
+function renderInitBanner(outputManager, nonInteractive) {
+    if ("interactive" !== outputManager.getMode() || nonInteractive) return;
+    const title = "__        ___ _   _  ____ __  __    _    _   _\n\\ \\      / / | \\ | |/ ___|  \\/  |  / \\  | \\ | |\n \\ \\ /\\ / /| |  \\| | |  _| |\\/| | / _ \\ |  \\| |\n  \\ V  V / | | |\\  | |_| | |  | |/ ___ \\| |\\  |\n   \\_/\\_/  |_|_| \\_|\\____|_|  |_/_/   \\_\\_| \\_|";
+    const accent = process.stdout.isTTY ? external_chalk_default().cyanBright : (text)=>text;
+    const muted = process.stdout.isTTY ? external_chalk_default().gray : (text)=>text;
+    const emphasis = process.stdout.isTTY ? external_chalk_default().whiteBright : (text)=>text;
+    (0, prompts_namespaceObject.intro)(accent(title));
+    (0, prompts_namespaceObject.note)(muted("We will set up config, install bundled agents, and connect providers."), emphasis("Wingman Init Wizard"));
+    (0, prompts_namespaceObject.note)(muted("Press Enter to accept defaults."), emphasis("Tip"));
+}
+function isHelpCommand(subcommand) {
+    return [
+        "help",
+        "--help",
+        "-h"
+    ].includes(subcommand);
+}
+function resolveAgentId(args) {
+    if (args.agent && args.agent.trim()) return args.agent.trim();
+    if (args.subcommand && !isHelpCommand(args.subcommand) && !args.subcommand.startsWith("-")) return args.subcommand.trim();
+    return DEFAULT_AGENT_ID;
+}
+async function resolveAgentPlan(input) {
+    const { explicitAgent, defaultAgentId, bundledAgents, nonInteractive, optionMap, outputManager } = input;
+    let nextDefaultAgent = sanitizeAgentId(defaultAgentId);
+    const availableAgents = bundledAgents.slice();
+    if (!explicitAgent && !nonInteractive && availableAgents.length > 0) nextDefaultAgent = await promptForDefaultAgent(availableAgents, nextDefaultAgent);
+    const rawAgentsList = getStringOption(optionMap, [
+        "agents"
+    ]);
+    if (rawAgentsList) {
+        const selected = parseAgentList(rawAgentsList, availableAgents);
+        const unique = ensureIncludesDefault(selected, nextDefaultAgent, availableAgents);
+        return {
+            defaultAgentId: nextDefaultAgent,
+            copyAgents: unique
+        };
+    }
+    if (nonInteractive || 0 === availableAgents.length) return {
+        defaultAgentId: nextDefaultAgent
+    };
+    const copyAll = await promptConfirm("Copy all bundled agents?", true);
+    if (copyAll) return {
+        defaultAgentId: nextDefaultAgent
+    };
+    const selectedAgents = await promptForAgentSelection(availableAgents, nextDefaultAgent);
+    const finalAgents = ensureIncludesDefault(selectedAgents, nextDefaultAgent, availableAgents);
+    if (0 === finalAgents.length) {
+        writeLine(outputManager, "No bundled agents selected.");
+        return {
+            defaultAgentId: nextDefaultAgent,
+            copyAgents: []
+        };
+    }
+    return {
+        defaultAgentId: nextDefaultAgent,
+        copyAgents: finalAgents
+    };
+}
+function sanitizeAgentId(value) {
+    const trimmed = value.trim();
+    if (!trimmed) throw new Error("Agent name is required.");
+    if (trimmed.includes("/") || trimmed.includes("\\")) throw new Error("Agent name cannot include path separators.");
+    if (trimmed.includes("..")) throw new Error("Agent name cannot include '..'.");
+    return trimmed;
+}
+async function handleConfigSetup(input) {
+    const { configPath, configRoot, agentId, fsRoot, force, merge, nonInteractive, outputManager } = input;
+    const configExists = (0, external_node_fs_namespaceObject.existsSync)(configPath);
+    if (configExists && !force && !merge) {
+        if (nonInteractive) return void writeLine(outputManager, "Config already exists. Use --merge or --force to update it.");
+        const shouldMerge = await promptConfirm("Config exists. Update with recommended settings? (y/N): ", false);
+        if (!shouldMerge) return void writeLine(outputManager, "Leaving existing config unchanged.");
+    }
+    const nextConfig = configExists && !force ? mergeConfigFile(configPath, agentId, fsRoot) : buildDefaultConfig(agentId, fsRoot);
+    if (!nextConfig) return void writeLine(outputManager, "Config already has recommended settings.");
+    (0, external_node_fs_namespaceObject.mkdirSync)(configRoot, {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(configPath, JSON.stringify(nextConfig, null, 2));
+    writeLine(outputManager, `Saved config to ${configPath}`);
+}
+function mergeConfigFile(configPath, agentId, fsRoot) {
+    const raw = (0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    } catch  {
+        throw new Error("Existing wingman.config.json is invalid JSON. Use --force to overwrite.");
+    }
+    if (!parsed || "object" != typeof parsed || Array.isArray(parsed)) throw new Error("Existing wingman.config.json is not a JSON object. Use --force to overwrite.");
+    const { config, changed } = mergeConfigValues(parsed, agentId, fsRoot);
+    return changed ? config : null;
+}
+function mergeConfigValues(config, agentId, fsRoot) {
+    let changed = false;
+    const nextConfig = {
+        ...config
+    };
+    if (!nextConfig.defaultAgent) {
+        nextConfig.defaultAgent = agentId;
+        changed = true;
+    }
+    const gatewayRaw = nextConfig.gateway;
+    const gateway = gatewayRaw && "object" == typeof gatewayRaw && !Array.isArray(gatewayRaw) ? {
+        ...gatewayRaw
+    } : {};
+    const fsRootsRaw = gateway.fsRoots;
+    const fsRoots = Array.isArray(fsRootsRaw) ? [
+        ...fsRootsRaw
+    ] : [];
+    if (fsRoot && !fsRoots.includes(fsRoot)) {
+        fsRoots.push(fsRoot);
+        changed = true;
+    }
+    if (changed) nextConfig.gateway = {
+        ...gateway,
+        fsRoots
+    };
+    return {
+        config: nextConfig,
+        changed
+    };
+}
+function buildDefaultConfig(agentId, fsRoot) {
+    const config = schema_cjs_namespaceObject.WingmanConfigSchema.parse({});
+    config.defaultAgent = agentId;
+    config.gateway = {
+        ...config.gateway,
+        fsRoots: [
+            fsRoot
+        ]
+    };
+    return config;
+}
+async function handleAgentSetup(input) {
+    const { configRoot, agentId, model, force, nonInteractive, outputManager, bundledAgentsPath, copyAgents } = input;
+    const copiedAgents = bundledAgentsPath ? copyBundledAgents({
+        bundledAgentsPath,
+        configRoot,
+        force,
+        outputManager,
+        agentNames: copyAgents
+    }) : new Set();
+    if (copiedAgents.size > 0) writeLine(outputManager, `Copied ${copiedAgents.size} bundled agent(s) to ${(0, external_node_path_namespaceObject.join)(configRoot, "agents")}`);
+    const expectedAgentDir = (0, external_node_path_namespaceObject.join)(configRoot, "agents", agentId);
+    const expectedAgentPath = (0, external_node_path_namespaceObject.join)(expectedAgentDir, "agent.json");
+    const expectedAgentExists = (0, external_node_fs_namespaceObject.existsSync)(expectedAgentPath);
+    if (!expectedAgentExists) return void await createFallbackAgent({
+        configRoot,
+        agentId,
+        model,
+        force,
+        nonInteractive,
+        outputManager
+    });
+    if (model) applyModelToAgent(expectedAgentPath, model, outputManager);
+}
+function resolveBundledAgentsPath() {
+    const candidates = [
+        new URL("../../../../.wingman/agents", __rslib_import_meta_url__),
+        new URL("../../../.wingman/agents", __rslib_import_meta_url__)
+    ];
+    for (const candidate of candidates){
+        const resolved = (0, external_node_url_namespaceObject.fileURLToPath)(candidate);
+        if ((0, external_node_fs_namespaceObject.existsSync)(resolved) && (0, external_node_fs_namespaceObject.statSync)(resolved).isDirectory()) return resolved;
+    }
+    const cwdFallback = (0, external_node_path_namespaceObject.join)(process.cwd(), ".wingman", "agents");
+    if ((0, external_node_fs_namespaceObject.existsSync)(cwdFallback) && (0, external_node_fs_namespaceObject.statSync)(cwdFallback).isDirectory()) return cwdFallback;
+    return null;
+}
+function listBundledAgents(bundledAgentsPath) {
+    return (0, external_node_fs_namespaceObject.readdirSync)(bundledAgentsPath, {
+        withFileTypes: true
+    }).filter((dirent)=>dirent.isDirectory()).map((dirent)=>dirent.name).sort((a, b)=>a.localeCompare(b));
+}
+function copyBundledAgents(input) {
+    const { bundledAgentsPath, configRoot, force, outputManager, agentNames } = input;
+    const available = listBundledAgents(bundledAgentsPath);
+    const entries = agentNames ? agentNames : available;
+    const copied = new Set();
+    const targetRoot = (0, external_node_path_namespaceObject.join)(configRoot, "agents");
+    for (const entry of entries){
+        const sourceDir = (0, external_node_path_namespaceObject.join)(bundledAgentsPath, entry);
+        const targetDir = (0, external_node_path_namespaceObject.join)(targetRoot, entry);
+        if ((0, external_node_fs_namespaceObject.existsSync)(targetDir) && !force) {
+            writeLine(outputManager, `Agent "${entry}" already exists. Skipping (use --force to overwrite).`);
+            continue;
+        }
+        if ((0, external_node_fs_namespaceObject.existsSync)(targetDir) && force) (0, external_node_fs_namespaceObject.rmSync)(targetDir, {
+            recursive: true,
+            force: true
+        });
+        copyDirectory(sourceDir, targetDir);
+        copied.add(entry);
+    }
+    return copied;
+}
+function copyDirectory(source, target) {
+    (0, external_node_fs_namespaceObject.mkdirSync)(target, {
+        recursive: true
+    });
+    const entries = (0, external_node_fs_namespaceObject.readdirSync)(source, {
+        withFileTypes: true
+    });
+    for (const entry of entries){
+        const sourcePath = (0, external_node_path_namespaceObject.join)(source, entry.name);
+        const targetPath = (0, external_node_path_namespaceObject.join)(target, entry.name);
+        if (entry.isDirectory()) copyDirectory(sourcePath, targetPath);
+        else (0, external_node_fs_namespaceObject.copyFileSync)(sourcePath, targetPath);
+    }
+}
+async function createFallbackAgent(input) {
+    const { configRoot, agentId, model, force, nonInteractive, outputManager } = input;
+    const agentDir = (0, external_node_path_namespaceObject.join)(configRoot, "agents", agentId);
+    const agentPath = (0, external_node_path_namespaceObject.join)(agentDir, "agent.json");
+    const agentExists = (0, external_node_fs_namespaceObject.existsSync)(agentPath);
+    if (agentExists && !force) {
+        if (nonInteractive) return void writeLine(outputManager, `Agent "${agentId}" already exists. Use --force to overwrite.`);
+        const shouldOverwrite = await promptConfirm(`Agent "${agentId}" exists. Overwrite? (y/N): `, false);
+        if (!shouldOverwrite) return void writeLine(outputManager, `Keeping existing agent "${agentId}".`);
+    }
+    (0, external_node_fs_namespaceObject.mkdirSync)(agentDir, {
+        recursive: true
+    });
+    const agentConfig = {
+        name: agentId,
+        description: DEFAULT_AGENT_DESCRIPTION,
+        systemPrompt: DEFAULT_AGENT_PROMPT,
+        tools: DEFAULT_TOOLS
+    };
+    if (model) agentConfig.model = model;
+    (0, external_node_fs_namespaceObject.writeFileSync)(agentPath, JSON.stringify(agentConfig, null, 2));
+    writeLine(outputManager, `Created starter agent at ${agentPath}`);
+}
+function applyModelToAgent(agentPath, model, outputManager) {
+    try {
+        const raw = (0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        parsed.model = model;
+        (0, external_node_fs_namespaceObject.writeFileSync)(agentPath, JSON.stringify(parsed, null, 2));
+        writeLine(outputManager, `Updated ${agentPath} with model ${model}`);
+    } catch  {
+        writeLine(outputManager, `Unable to update model for ${agentPath}. Update manually.`);
+    }
+}
+async function resolveProviderSelection(input) {
+    const { nonInteractive, skipProvider, optionMap, outputManager } = input;
+    if (skipProvider) return;
+    const providerOption = getStringOption(optionMap, [
+        "provider"
+    ]);
+    if (providerOption) {
+        const normalized = (0, registry_cjs_namespaceObject.normalizeProviderName)(providerOption);
+        if (!normalized) throw new Error(`Unknown provider: ${providerOption}`);
+        return normalized;
+    }
+    if (nonInteractive) return;
+    const providers = (0, registry_cjs_namespaceObject.listProviderSpecs)("model");
+    const options = [
+        {
+            value: "__skip__",
+            label: "Skip for now"
+        },
+        ...providers.map((provider)=>({
+                value: provider.name,
+                label: provider.label,
+                hint: provider.name
+            }))
+    ];
+    const selection = await (0, prompts_namespaceObject.select)({
+        message: "Choose a provider to configure",
+        options
+    });
+    if ((0, prompts_namespaceObject.isCancel)(selection)) abortSetup();
+    if ("__skip__" === selection) return void writeLine(outputManager, "Skipping provider configuration.");
+    const normalized = (0, registry_cjs_namespaceObject.normalizeProviderName)(String(selection));
+    if (!normalized) throw new Error(`Unknown provider: ${String(selection)}`);
+    return normalized;
+}
+async function resolveModelSelection(input) {
+    const { nonInteractive, optionMap, providerName, outputManager } = input;
+    const explicitModel = getStringOption(optionMap, [
+        "model"
+    ]);
+    if (explicitModel) {
+        validateModel(explicitModel);
+        return explicitModel;
+    }
+    const providers = (0, registry_cjs_namespaceObject.listProviderSpecs)("model");
+    const configuredProvider = providers.find((provider)=>"missing" !== (0, credentials_cjs_namespaceObject.resolveProviderToken)(provider.name).source);
+    const suggestedProvider = providerName || configuredProvider?.name;
+    const suggestedModel = suggestedProvider ? DEFAULT_MODELS[suggestedProvider] : void 0;
+    if (nonInteractive) {
+        if (suggestedModel) return suggestedModel;
+        return;
+    }
+    const inputValue = await (0, prompts_namespaceObject.text)({
+        message: "Model string (provider:model)",
+        placeholder: suggestedModel ? void 0 : "anthropic:claude-sonnet-4-5",
+        defaultValue: suggestedModel
+    });
+    if ((0, prompts_namespaceObject.isCancel)(inputValue)) abortSetup();
+    const trimmed = String(inputValue ?? "").trim();
+    if (!trimmed && suggestedModel) return suggestedModel;
+    if (!trimmed) return void writeLine(outputManager, "Skipping model selection.");
+    validateModel(trimmed);
+    return trimmed;
+}
+function validateModel(model) {
+    const result = modelFactory_cjs_namespaceObject.ModelFactory.validateModelString(model);
+    if (!result.valid) throw new Error(result.error || "Invalid model string.");
+}
+async function handleProviderSetup(input) {
+    const { providerName, optionMap, nonInteractive, outputManager } = input;
+    if (!providerName) return void writeLine(outputManager, "No provider selected.");
+    const status = (0, credentials_cjs_namespaceObject.resolveProviderToken)(providerName);
+    if ("missing" !== status.source) return void writeLine(outputManager, `Provider "${providerName}" already configured (${status.source}).`);
+    const tokenOption = getTokenOption(optionMap);
+    if (tokenOption) {
+        (0, credentials_cjs_namespaceObject.saveProviderToken)(providerName, tokenOption);
+        writeLine(outputManager, `Saved ${providerName} credentials to ${(0, credentials_cjs_namespaceObject.getCredentialsPath)()}`);
+        return;
+    }
+    if (nonInteractive) return void writeLine(outputManager, `Missing credentials for "${providerName}". Run "wingman provider login ${providerName}" to add them.`);
+    const tokenInput = await (0, prompts_namespaceObject.text)({
+        message: `Enter ${providerName} API key`,
+        placeholder: "sk-..."
+    });
+    if ((0, prompts_namespaceObject.isCancel)(tokenInput)) abortSetup();
+    const token = String(tokenInput ?? "").trim();
+    if (!token) throw new Error("API key is required.");
+    (0, credentials_cjs_namespaceObject.saveProviderToken)(providerName, token);
+    writeLine(outputManager, `Saved ${providerName} credentials to ${(0, credentials_cjs_namespaceObject.getCredentialsPath)()}`);
+}
+function getTokenOption(options) {
+    const raw = getStringOption(options, [
+        "token"
+    ]) ?? getStringOption(options, [
+        "api-key"
+    ]) ?? getStringOption(options, [
+        "apiKey"
+    ]);
+    if ("string" == typeof raw && raw.trim()) return raw.trim();
+}
+function getStringOption(options, keys) {
+    for (const key of keys){
+        const raw = options[key];
+        if ("string" == typeof raw && raw.trim()) return raw.trim();
+    }
+}
+function parseAgentList(raw, bundledAgents) {
+    const normalized = raw.split(/[,\s]+/).map((value)=>value.trim()).filter(Boolean);
+    if (0 === normalized.length) return [];
+    const unknown = normalized.filter((value)=>!bundledAgents.includes(value));
+    if (unknown.length > 0) throw new Error(`Unknown bundled agents: ${unknown.join(", ")}.`);
+    return Array.from(new Set(normalized));
+}
+function ensureIncludesDefault(agents, defaultAgent, bundledAgents) {
+    if (!bundledAgents.includes(defaultAgent)) return agents;
+    if (agents.includes(defaultAgent)) return agents;
+    return [
+        ...agents,
+        defaultAgent
+    ];
+}
+async function promptForDefaultAgent(agents, currentDefault) {
+    const choices = agents.length > 0 ? agents : [
+        currentDefault
+    ];
+    const defaultValue = choices.includes(currentDefault) ? currentDefault : choices[0];
+    const selection = await (0, prompts_namespaceObject.select)({
+        message: "Pick a default agent",
+        options: [
+            ...choices.map((agent)=>({
+                    value: agent,
+                    label: agent
+                })),
+            {
+                value: "__custom__",
+                label: "Custom agent name"
+            }
+        ],
+        initialValue: defaultValue
+    });
+    if ((0, prompts_namespaceObject.isCancel)(selection)) abortSetup();
+    if ("__custom__" === selection) {
+        const input = await (0, prompts_namespaceObject.text)({
+            message: "Default agent name",
+            placeholder: defaultValue
+        });
+        if ((0, prompts_namespaceObject.isCancel)(input)) abortSetup();
+        const trimmed = String(input ?? "").trim();
+        if (!trimmed) return defaultValue;
+        return sanitizeAgentId(trimmed);
+    }
+    return sanitizeAgentId(String(selection));
+}
+async function promptForAgentSelection(agents, defaultAgent) {
+    const selection = await (0, prompts_namespaceObject.multiselect)({
+        message: "Choose bundled agents to copy",
+        options: agents.map((agent)=>({
+                value: agent,
+                label: agent
+            })),
+        required: false,
+        initialValues: agents.includes(defaultAgent) ? [
+            defaultAgent
+        ] : []
+    });
+    if ((0, prompts_namespaceObject.isCancel)(selection)) abortSetup();
+    const values = Array.isArray(selection) ? selection.map((value)=>String(value)) : [];
+    return Array.from(new Set(values));
+}
+function getBooleanOption(options, keys, defaultValue) {
+    for (const key of keys){
+        const raw = options[key];
+        if ("boolean" == typeof raw) return raw;
+        if ("string" == typeof raw) {
+            if ("true" === raw.toLowerCase()) return true;
+            if ("false" === raw.toLowerCase()) return false;
+        }
+    }
+    return defaultValue;
+}
+function shouldUseClack(outputManager, nonInteractive) {
+    return "interactive" === outputManager.getMode() && !nonInteractive;
+}
+function abortSetup() {
+    (0, prompts_namespaceObject.cancel)("Setup cancelled.");
+    process.exit(0);
+}
+async function runStep(useClack, label, handler) {
+    if (!useClack) return handler();
+    const active = (0, prompts_namespaceObject.spinner)();
+    active.start(label);
+    try {
+        const result = await handler();
+        active.stop(external_chalk_default().green("done"));
+        return result;
+    } catch (error) {
+        active.stop(external_chalk_default().red("failed"));
+        throw error;
+    }
+}
+async function promptConfirm(message, defaultValue) {
+    const response = await (0, prompts_namespaceObject.confirm)({
+        message,
+        initialValue: defaultValue
+    });
+    if ((0, prompts_namespaceObject.isCancel)(response)) abortSetup();
+    return Boolean(response);
+}
+function showInitHelp(outputManager, outputMode) {
+    if ("interactive" === outputMode) console.log(`
+Wingman Init - Quickstart onboarding
+
+Usage:
+  wingman init [options]
+  wingman init <agent-name>
+
+Options:
+  --agent <name>         Agent name (default: wingman)
+  --agents <list>        Copy only these bundled agents (comma-separated)
+  --model <provider:model>
+                         Set model for the starter agent
+  --provider <name>      Provider to configure (anthropic|openai|openrouter|copilot|xai)
+  --token <token>        Save provider token (non-interactive)
+  --api-key <key>        Alias for --token
+  --fs-root <path>       Add fs root (default: ".")
+  --skip-config          Skip wingman.config.json setup
+  --skip-agent           Skip starter agent creation
+  --skip-provider        Skip provider credential setup
+  --merge                Merge recommended settings into existing config
+  --force                Overwrite existing config or agent files
+  --yes                  Accept defaults without prompts
+
+Examples:
+  wingman init
+  wingman init coder --model openai:gpt-4o
+  wingman init --provider anthropic
+  wingman init --provider openai --api-key="sk-..."
+`);
+    else outputManager.emitLog("info", "Init help requested");
+}
+function writeLine(outputManager, message) {
+    if ("interactive" === outputManager.getMode()) console.log(message);
+    else outputManager.emitLog("info", message);
+}
+exports.executeInitCommand = __webpack_exports__.executeInitCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "executeInitCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,10 @@
+import type { InitCommandArgs } from "../types/init.js";
+export interface InitCommandOptions {
+    workspace?: string;
+    configDir?: string;
+}
+/**
+ * Execute the init command
+ * This is the handler for: wingman init [options]
+ */
+export declare function executeInitCommand(args: InitCommandArgs, options?: InitCommandOptions): Promise<void>;