@bobby_z/openspec 0.0.1

package/dist/core/global-config.js

@@ -0,0 +1,115 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+// Constants
+export const GLOBAL_CONFIG_DIR_NAME = 'openspec';
+export const GLOBAL_CONFIG_FILE_NAME = 'config.json';
+export const GLOBAL_DATA_DIR_NAME = 'openspec';
+const DEFAULT_CONFIG = {
+    featureFlags: {}
+};
+/**
+ * Gets the global configuration directory path following XDG Base Directory Specification.
+ *
+ * - All platforms: $XDG_CONFIG_HOME/openspec/ if XDG_CONFIG_HOME is set
+ * - Unix/macOS fallback: ~/.config/openspec/
+ * - Windows fallback: %APPDATA%/openspec/
+ */
+export function getGlobalConfigDir() {
+    // XDG_CONFIG_HOME takes precedence on all platforms when explicitly set
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+    if (xdgConfigHome) {
+        return path.join(xdgConfigHome, GLOBAL_CONFIG_DIR_NAME);
+    }
+    const platform = os.platform();
+    if (platform === 'win32') {
+        // Windows: use %APPDATA%
+        const appData = process.env.APPDATA;
+        if (appData) {
+            return path.join(appData, GLOBAL_CONFIG_DIR_NAME);
+        }
+        // Fallback for Windows if APPDATA is not set
+        return path.join(os.homedir(), 'AppData', 'Roaming', GLOBAL_CONFIG_DIR_NAME);
+    }
+    // Unix/macOS fallback: ~/.config
+    return path.join(os.homedir(), '.config', GLOBAL_CONFIG_DIR_NAME);
+}
+/**
+ * Gets the global data directory path following XDG Base Directory Specification.
+ * Used for user data like schema overrides.
+ *
+ * - All platforms: $XDG_DATA_HOME/openspec/ if XDG_DATA_HOME is set
+ * - Unix/macOS fallback: ~/.local/share/openspec/
+ * - Windows fallback: %LOCALAPPDATA%/openspec/
+ */
+export function getGlobalDataDir() {
+    // XDG_DATA_HOME takes precedence on all platforms when explicitly set
+    const xdgDataHome = process.env.XDG_DATA_HOME;
+    if (xdgDataHome) {
+        return path.join(xdgDataHome, GLOBAL_DATA_DIR_NAME);
+    }
+    const platform = os.platform();
+    if (platform === 'win32') {
+        // Windows: use %LOCALAPPDATA%
+        const localAppData = process.env.LOCALAPPDATA;
+        if (localAppData) {
+            return path.join(localAppData, GLOBAL_DATA_DIR_NAME);
+        }
+        // Fallback for Windows if LOCALAPPDATA is not set
+        return path.join(os.homedir(), 'AppData', 'Local', GLOBAL_DATA_DIR_NAME);
+    }
+    // Unix/macOS fallback: ~/.local/share
+    return path.join(os.homedir(), '.local', 'share', GLOBAL_DATA_DIR_NAME);
+}
+/**
+ * Gets the path to the global config file.
+ */
+export function getGlobalConfigPath() {
+    return path.join(getGlobalConfigDir(), GLOBAL_CONFIG_FILE_NAME);
+}
+/**
+ * Loads the global configuration from disk.
+ * Returns default configuration if file doesn't exist or is invalid.
+ * Merges loaded config with defaults to ensure new fields are available.
+ */
+export function getGlobalConfig() {
+    const configPath = getGlobalConfigPath();
+    try {
+        if (!fs.existsSync(configPath)) {
+            return { ...DEFAULT_CONFIG };
+        }
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // Merge with defaults (loaded values take precedence)
+        return {
+            ...DEFAULT_CONFIG,
+            ...parsed,
+            // Deep merge featureFlags
+            featureFlags: {
+                ...DEFAULT_CONFIG.featureFlags,
+                ...(parsed.featureFlags || {})
+            }
+        };
+    }
+    catch (error) {
+        // Log warning for parse errors, but not for missing files
+        if (error instanceof SyntaxError) {
+            console.error(`Warning: Invalid JSON in ${configPath}, using defaults`);
+        }
+        return { ...DEFAULT_CONFIG };
+    }
+}
+/**
+ * Saves the global configuration to disk.
+ * Creates the config directory if it doesn't exist.
+ */
+export function saveGlobalConfig(config) {
+    const configDir = getGlobalConfigDir();
+    const configPath = getGlobalConfigPath();
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+//# sourceMappingURL=global-config.js.map

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, type GlobalConfig, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -0,0 +1,3 @@
+// Core OpenSpec logic will be implemented here
+export { GLOBAL_CONFIG_DIR_NAME, GLOBAL_CONFIG_FILE_NAME, GLOBAL_DATA_DIR_NAME, getGlobalConfigDir, getGlobalConfigPath, getGlobalConfig, saveGlobalConfig, getGlobalDataDir } from './global-config.js';
+//# sourceMappingURL=index.js.map

package/dist/core/init.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Init Command
+ *
+ * Sets up OpenSpec with Agent Skills and /opsx:* slash commands.
+ * This is the unified setup command that replaces both the old init and experimental commands.
+ */
+type InitCommandOptions = {
+    tools?: string;
+    force?: boolean;
+    interactive?: boolean;
+};
+export declare class InitCommand {
+    private readonly toolsArg?;
+    private readonly force;
+    private readonly interactiveOption?;
+    constructor(options?: InitCommandOptions);
+    execute(targetPath: string): Promise<void>;
+    private validate;
+    private canPromptInteractively;
+    private handleLegacyCleanup;
+    private performLegacyCleanup;
+    private getSelectedTools;
+    private resolveToolsArg;
+    private validateTools;
+    private createDirectoryStructure;
+    private generateSkillsAndCommands;
+    private createConfig;
+    private displaySuccessMessage;
+    private startSpinner;
+}
+export {};
+//# sourceMappingURL=init.d.ts.map

package/dist/core/init.js

@@ -0,0 +1,447 @@
+/**
+ * Init Command
+ *
+ * Sets up OpenSpec with Agent Skills and /opsx:* slash commands.
+ * This is the unified setup command that replaces both the old init and experimental commands.
+ */
+import path from "path";
+import chalk from "chalk";
+import ora from "ora";
+import * as fs from "fs";
+import { createRequire } from "module";
+import { FileSystemUtils } from "../utils/file-system.js";
+import { transformToHyphenCommands } from "../utils/command-references.js";
+import { AI_TOOLS, OPENSPEC_DIR_NAME } from "./config.js";
+import { PALETTE } from "./styles/palette.js";
+import { isInteractive } from "../utils/interactive.js";
+import { serializeConfig } from "./config-prompts.js";
+import { generateCommands, CommandAdapterRegistry, } from "./command-generation/index.js";
+import { detectLegacyArtifacts, cleanupLegacyArtifacts, formatCleanupSummary, formatDetectionSummary, } from "./legacy-cleanup.js";
+import { getToolsWithSkillsDir, getToolStates, getSkillTemplates, getCommandContents, generateSkillContent, } from "./shared/index.js";
+const require = createRequire(import.meta.url);
+const { version: OPENSPEC_VERSION } = require("../../package.json");
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+const DEFAULT_SCHEMA = "spec-driven";
+const PROGRESS_SPINNER = {
+    interval: 80,
+    frames: ["░░░", "▒░░", "▒▒░", "▒▒▒", "▓▒▒", "▓▓▒", "▓▓▓", "▒▓▓", "░▒▓"],
+};
+// -----------------------------------------------------------------------------
+// Init Command Class
+// -----------------------------------------------------------------------------
+export class InitCommand {
+    toolsArg;
+    force;
+    interactiveOption;
+    constructor(options = {}) {
+        this.toolsArg = options.tools;
+        this.force = options.force ?? false;
+        this.interactiveOption = options.interactive;
+    }
+    async execute(targetPath) {
+        const projectPath = path.resolve(targetPath);
+        const openspecDir = OPENSPEC_DIR_NAME;
+        const openspecPath = path.join(projectPath, openspecDir);
+        // Validation happens silently in the background
+        const extendMode = await this.validate(projectPath, openspecPath);
+        // Check for legacy artifacts and handle cleanup
+        await this.handleLegacyCleanup(projectPath, extendMode);
+        // Show animated welcome screen (interactive mode only)
+        const canPrompt = this.canPromptInteractively();
+        if (canPrompt) {
+            const { showWelcomeScreen } = await import("../ui/welcome-screen.js");
+            await showWelcomeScreen();
+        }
+        // Get tool states before processing
+        const toolStates = getToolStates(projectPath);
+        // Get tool selection
+        const selectedToolIds = await this.getSelectedTools(toolStates, extendMode);
+        // Validate selected tools
+        const validatedTools = this.validateTools(selectedToolIds, toolStates);
+        // Create directory structure and config
+        await this.createDirectoryStructure(openspecPath, extendMode);
+        // Generate skills and commands for each tool
+        const results = await this.generateSkillsAndCommands(projectPath, validatedTools);
+        // Create config.yaml if needed
+        const configStatus = await this.createConfig(openspecPath, extendMode);
+        // Display success message
+        this.displaySuccessMessage(projectPath, validatedTools, results, configStatus);
+    }
+    // ═══════════════════════════════════════════════════════════
+    // VALIDATION & SETUP
+    // ═══════════════════════════════════════════════════════════
+    async validate(projectPath, openspecPath) {
+        const extendMode = await FileSystemUtils.directoryExists(openspecPath);
+        // Check write permissions
+        if (!(await FileSystemUtils.ensureWritePermissions(projectPath))) {
+            throw new Error(`对 ${projectPath} 无写入权限`);
+        }
+        return extendMode;
+    }
+    canPromptInteractively() {
+        if (this.interactiveOption === false)
+            return false;
+        if (this.toolsArg !== undefined)
+            return false;
+        return isInteractive({ interactive: this.interactiveOption });
+    }
+    // ═══════════════════════════════════════════════════════════
+    // LEGACY CLEANUP
+    // ═══════════════════════════════════════════════════════════
+    async handleLegacyCleanup(projectPath, extendMode) {
+        // Detect legacy artifacts
+        const detection = await detectLegacyArtifacts(projectPath);
+        if (!detection.hasLegacyArtifacts) {
+            return; // No legacy artifacts found
+        }
+        // Show what was detected
+        console.log();
+        console.log(formatDetectionSummary(detection));
+        console.log();
+        const canPrompt = this.canPromptInteractively();
+        if (this.force) {
+            // --force flag: proceed with cleanup automatically
+            await this.performLegacyCleanup(projectPath, detection);
+            return;
+        }
+        if (!canPrompt) {
+            // Non-interactive mode without --force: abort
+            console.log(chalk.red("非交互模式下检测到旧版文件。"));
+            console.log(chalk.dim("请以交互方式运行以升级，或使用 --force 自动清理。"));
+            process.exit(1);
+        }
+        // Interactive mode: prompt for confirmation
+        const { confirm } = await import("@inquirer/prompts");
+        const shouldCleanup = await confirm({
+            message: "是否升级并清理旧版文件？",
+            default: true,
+        });
+        if (!shouldCleanup) {
+            console.log(chalk.dim("已取消初始化。"));
+            console.log(chalk.dim("使用 --force 可跳过此提示，或手动删除旧版文件。"));
+            process.exit(0);
+        }
+        await this.performLegacyCleanup(projectPath, detection);
+    }
+    async performLegacyCleanup(projectPath, detection) {
+        const spinner = ora("正在清理旧版文件...").start();
+        const result = await cleanupLegacyArtifacts(projectPath, detection);
+        spinner.succeed("旧版文件已清理");
+        const summary = formatCleanupSummary(result);
+        if (summary) {
+            console.log();
+            console.log(summary);
+        }
+        console.log();
+    }
+    // ═══════════════════════════════════════════════════════════
+    // TOOL SELECTION
+    // ═══════════════════════════════════════════════════════════
+    async getSelectedTools(toolStates, extendMode) {
+        // Check for --tools flag first
+        const nonInteractiveSelection = this.resolveToolsArg();
+        if (nonInteractiveSelection !== null) {
+            return nonInteractiveSelection;
+        }
+        const validTools = getToolsWithSkillsDir();
+        const canPrompt = this.canPromptInteractively();
+        if (!canPrompt || validTools.length === 0) {
+            throw new Error(`Missing required option --tools. Valid tools:\n  ${validTools.join("\n  ")}\n\nUse --tools all, --tools none, or --tools claude,cursor,...`);
+        }
+        // Interactive mode: show searchable multi-select
+        const { searchableMultiSelect } = await import("../prompts/searchable-multi-select.js");
+        // Build choices with configured status and sort configured tools first
+        const sortedChoices = validTools
+            .map((toolId) => {
+            const tool = AI_TOOLS.find((t) => t.value === toolId);
+            const status = toolStates.get(toolId);
+            const configured = status?.configured ?? false;
+            return {
+                name: tool?.name || toolId,
+                value: toolId,
+                configured,
+                preSelected: configured, // Pre-select configured tools for easy refresh
+            };
+        })
+            .sort((a, b) => {
+            // Configured tools first
+            if (a.configured && !b.configured)
+                return -1;
+            if (!a.configured && b.configured)
+                return 1;
+            return 0;
+        });
+        const selectedTools = await searchableMultiSelect({
+            message: `Select tools to set up (${validTools.length} available)`,
+            pageSize: 15,
+            choices: sortedChoices,
+            validate: (selected) => selected.length > 0 || "请至少选择一种工具",
+        });
+        if (selectedTools.length === 0) {
+            throw new Error("必须至少选择一种工具");
+        }
+        return selectedTools;
+    }
+    resolveToolsArg() {
+        if (typeof this.toolsArg === "undefined") {
+            return null;
+        }
+        const raw = this.toolsArg.trim();
+        if (raw.length === 0) {
+            throw new Error('--tools 需要取值。可使用 "all"、"none" 或逗号分隔的工具 ID 列表。');
+        }
+        const availableTools = getToolsWithSkillsDir();
+        const availableSet = new Set(availableTools);
+        const availableList = ["all", "none", ...availableTools].join(", ");
+        const lowerRaw = raw.toLowerCase();
+        if (lowerRaw === "all") {
+            return availableTools;
+        }
+        if (lowerRaw === "none") {
+            return [];
+        }
+        const tokens = raw
+            .split(",")
+            .map((token) => token.trim())
+            .filter((token) => token.length > 0);
+        if (tokens.length === 0) {
+            throw new Error('未使用 "all" 或 "none" 时，--tools 至少需要一个工具 ID。');
+        }
+        const normalizedTokens = tokens.map((token) => token.toLowerCase());
+        if (normalizedTokens.some((token) => token === "all" || token === "none")) {
+            throw new Error('不能将保留值 "all" 或 "none" 与具体工具 ID 混用。');
+        }
+        const invalidTokens = tokens.filter((_token, index) => !availableSet.has(normalizedTokens[index]));
+        if (invalidTokens.length > 0) {
+            throw new Error(`无效工具：${invalidTokens.join(", ")}。可用值：${availableList}`);
+        }
+        // Deduplicate while preserving order
+        const deduped = [];
+        for (const token of normalizedTokens) {
+            if (!deduped.includes(token)) {
+                deduped.push(token);
+            }
+        }
+        return deduped;
+    }
+    validateTools(toolIds, toolStates) {
+        const validatedTools = [];
+        for (const toolId of toolIds) {
+            const tool = AI_TOOLS.find((t) => t.value === toolId);
+            if (!tool) {
+                const validToolIds = getToolsWithSkillsDir();
+                throw new Error(`未知工具 "${toolId}"。有效工具：\n  ${validToolIds.join("\n  ")}`);
+            }
+            if (!tool.skillsDir) {
+                const validToolsWithSkills = getToolsWithSkillsDir();
+                throw new Error(`工具 "${toolId}" 不支持技能生成。支持技能生成的工具：\n  ${validToolsWithSkills.join("\n  ")}`);
+            }
+            const preState = toolStates.get(tool.value);
+            validatedTools.push({
+                value: tool.value,
+                name: tool.name,
+                skillsDir: tool.skillsDir,
+                wasConfigured: preState?.configured ?? false,
+            });
+        }
+        return validatedTools;
+    }
+    // ═══════════════════════════════════════════════════════════
+    // DIRECTORY STRUCTURE
+    // ═══════════════════════════════════════════════════════════
+    async createDirectoryStructure(openspecPath, extendMode) {
+        if (extendMode) {
+            // In extend mode, just ensure directories exist without spinner
+            const directories = [
+                openspecPath,
+                path.join(openspecPath, "specs"),
+                path.join(openspecPath, "changes"),
+                path.join(openspecPath, "changes", "archive"),
+            ];
+            for (const dir of directories) {
+                await FileSystemUtils.createDirectory(dir);
+            }
+            return;
+        }
+        const spinner = this.startSpinner("Creating OpenSpec structure...");
+        const directories = [
+            openspecPath,
+            path.join(openspecPath, "specs"),
+            path.join(openspecPath, "changes"),
+            path.join(openspecPath, "changes", "archive"),
+        ];
+        for (const dir of directories) {
+            await FileSystemUtils.createDirectory(dir);
+        }
+        spinner.stopAndPersist({
+            symbol: PALETTE.white("▌"),
+            text: PALETTE.white("OpenSpec structure created"),
+        });
+    }
+    // ═══════════════════════════════════════════════════════════
+    // SKILL & COMMAND GENERATION
+    // ═══════════════════════════════════════════════════════════
+    async generateSkillsAndCommands(projectPath, tools) {
+        const createdTools = [];
+        const refreshedTools = [];
+        const failedTools = [];
+        const commandsSkipped = [];
+        // Get skill and command templates once (shared across all tools)
+        const skillTemplates = getSkillTemplates();
+        const commandContents = getCommandContents();
+        // Process each tool
+        for (const tool of tools) {
+            const spinner = ora(`正在配置 ${tool.name}...`).start();
+            try {
+                // Use tool-specific skillsDir
+                const skillsDir = path.join(projectPath, tool.skillsDir, "skills");
+                // Create skill directories and SKILL.md files
+                for (const { template, dirName } of skillTemplates) {
+                    const skillDir = path.join(skillsDir, dirName);
+                    const skillFile = path.join(skillDir, "SKILL.md");
+                    // Generate SKILL.md content with YAML frontmatter including generatedBy
+                    // Use hyphen-based command references for OpenCode
+                    const transformer = tool.value === "opencode" ? transformToHyphenCommands : undefined;
+                    const skillContent = generateSkillContent(template, OPENSPEC_VERSION, transformer);
+                    // Write the skill file
+                    await FileSystemUtils.writeFile(skillFile, skillContent);
+                }
+                // Generate commands using the adapter system
+                const adapter = CommandAdapterRegistry.get(tool.value);
+                if (adapter) {
+                    const generatedCommands = generateCommands(commandContents, adapter);
+                    for (const cmd of generatedCommands) {
+                        const commandFile = path.isAbsolute(cmd.path)
+                            ? cmd.path
+                            : path.join(projectPath, cmd.path);
+                        await FileSystemUtils.writeFile(commandFile, cmd.fileContent);
+                    }
+                }
+                else {
+                    commandsSkipped.push(tool.value);
+                }
+                spinner.succeed(`${tool.name} 配置完成`);
+                if (tool.wasConfigured) {
+                    refreshedTools.push(tool);
+                }
+                else {
+                    createdTools.push(tool);
+                }
+            }
+            catch (error) {
+                spinner.fail(`${tool.name} 配置失败`);
+                failedTools.push({ name: tool.name, error: error });
+            }
+        }
+        return { createdTools, refreshedTools, failedTools, commandsSkipped };
+    }
+    // ═══════════════════════════════════════════════════════════
+    // CONFIG FILE
+    // ═══════════════════════════════════════════════════════════
+    async createConfig(openspecPath, extendMode) {
+        const configPath = path.join(openspecPath, "config.yaml");
+        const configYmlPath = path.join(openspecPath, "config.yml");
+        const configYamlExists = fs.existsSync(configPath);
+        const configYmlExists = fs.existsSync(configYmlPath);
+        if (configYamlExists || configYmlExists) {
+            return "exists";
+        }
+        // In non-interactive mode without --force, skip config creation
+        if (!this.canPromptInteractively() && !this.force) {
+            return "skipped";
+        }
+        try {
+            const yamlContent = serializeConfig({ schema: DEFAULT_SCHEMA });
+            await FileSystemUtils.writeFile(configPath, yamlContent);
+            return "created";
+        }
+        catch {
+            return "skipped";
+        }
+    }
+    // ═══════════════════════════════════════════════════════════
+    // UI & OUTPUT
+    // ═══════════════════════════════════════════════════════════
+    displaySuccessMessage(projectPath, tools, results, configStatus) {
+        console.log();
+        console.log(chalk.bold("OpenSpec 配置完成"));
+        console.log();
+        // Show created vs refreshed tools
+        if (results.createdTools.length > 0) {
+            console.log(`已创建：${results.createdTools.map((t) => t.name).join(", ")}`);
+        }
+        if (results.refreshedTools.length > 0) {
+            console.log(`已刷新：${results.refreshedTools.map((t) => t.name).join(", ")}`);
+        }
+        // Show counts
+        const successfulTools = [
+            ...results.createdTools,
+            ...results.refreshedTools,
+        ];
+        if (successfulTools.length > 0) {
+            const toolDirs = [
+                ...new Set(successfulTools.map((t) => t.skillsDir)),
+            ].join(", ");
+            const hasCommands = results.commandsSkipped.length < successfulTools.length;
+            if (hasCommands) {
+                console.log(`${getSkillTemplates().length} 个技能与 ${getCommandContents().length} 个命令已写入 ${toolDirs}/`);
+            }
+            else {
+                console.log(`${getSkillTemplates().length} 个技能已写入 ${toolDirs}/`);
+            }
+        }
+        // Show failures
+        if (results.failedTools.length > 0) {
+            console.log(chalk.red(`失败：${results.failedTools.map((f) => `${f.name} (${f.error.message})`).join(", ")}`));
+        }
+        // Show skipped commands
+        if (results.commandsSkipped.length > 0) {
+            console.log(chalk.dim(`未生成命令：${results.commandsSkipped.join(", ")}（无适配器）`));
+        }
+        // Config status
+        if (configStatus === "created") {
+            console.log(`配置：openspec/config.yaml (schema: ${DEFAULT_SCHEMA})`);
+        }
+        else if (configStatus === "exists") {
+            // Show actual filename (config.yaml or config.yml)
+            const configYaml = path.join(projectPath, OPENSPEC_DIR_NAME, "config.yaml");
+            const configYml = path.join(projectPath, OPENSPEC_DIR_NAME, "config.yml");
+            const configName = fs.existsSync(configYaml)
+                ? "config.yaml"
+                : fs.existsSync(configYml)
+                    ? "config.yml"
+                    : "config.yaml";
+            console.log(`配置：openspec/${configName}（已存在）`);
+        }
+        else {
+            console.log(chalk.dim(`配置：已跳过（非交互模式）`));
+        }
+        // Getting started
+        console.log();
+        console.log(chalk.bold("快速开始："));
+        console.log("  /opsx:new       新建变更");
+        console.log("  /opsx:continue  创建下一个制品");
+        console.log("  /opsx:apply     实施任务");
+        // Links
+        console.log();
+        console.log(`了解更多：${chalk.cyan("https://github.com/Fission-AI/OpenSpec")}`);
+        console.log(`反馈：    ${chalk.cyan("https://github.com/Fission-AI/OpenSpec/issues")}`);
+        // Restart instruction if any tools were configured
+        if (results.createdTools.length > 0 || results.refreshedTools.length > 0) {
+            console.log();
+            console.log(chalk.white("请重启 IDE 以使斜杠命令生效。"));
+        }
+        console.log();
+    }
+    startSpinner(text) {
+        return ora({
+            text,
+            stream: process.stdout,
+            color: "gray",
+            spinner: PROGRESS_SPINNER,
+        }).start();
+    }
+}
+//# sourceMappingURL=init.js.map