@openflowjs/cli 0.2.0

package/dist/commands/init.js

@@ -0,0 +1,1082 @@
+import { existsSync } from "node:fs";
+import { copyFile, mkdir, readFile, rm } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { clearScreenDown, cursorTo, emitKeypressEvents, moveCursor } from "node:readline";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { isRecord, writeJsonAtomic, collectFiles, sha256File, readJsonObjectIfExists } from "../shared/fs.js";
+import { printLogo, printPanel, printFileStatus, formatTitle, colorText, printStep, printSeparator, printKeyValue } from "../shared/terminal.js";
+import { setLocale, t } from "../shared/i18n.js";
+const execFileAsync = promisify(execFile);
+const INIT_LANGUAGE_CHOICES = ["en-US", "zh-CN"];
+const INSTALL_MANIFEST_PATH = ".openflow/install.json";
+const CLAUDE_PROJECT_MCP_SERVER_NAME = "openflow-studio";
+const CLAUDE_BIN_ENV = "OPENFLOW_CLAUDE_BIN";
+const CLAUDE_BIN_ARGS_ENV = "OPENFLOW_CLAUDE_BIN_ARGS";
+export async function runInitCommand(args) {
+    printLogo();
+    const options = await resolveInitOptions(args);
+    const result = options.format === "plugin"
+        ? await installPlugin(options)
+        : await installAdapter(options);
+    printInstallResult(result);
+    printCompletionMessage();
+}
+function printCompletionMessage() {
+    console.log();
+    printSeparator();
+    console.log();
+    console.log(`  ${colorText("bold", colorText("green", t("init.ready")))}`);
+    console.log(`  ${t("init.nextStep")}`);
+    console.log();
+}
+export async function runUpdateCommand(args) {
+    const options = parseUpdateArgs(args);
+    const result = await updateAdapter(options);
+    printUpdateResult(result);
+}
+async function resolveInitOptions(args) {
+    const state = parseInitArgs(args);
+    if (state.scope === "global" && state.targetProvided) {
+        throw new Error(t("init.errorCombineGlobalTarget"));
+    }
+    let step = 0;
+    const maxSteps = 4;
+    // Step 1: Prompt language first (before any other interaction)
+    if (state.language === undefined && process.stdin.isTTY) {
+        step += 1;
+        printStep(step, maxSteps, t("init.stepLanguage"));
+        state.language = await promptLanguage();
+        setLocale(state.language);
+    }
+    else if (state.language) {
+        setLocale(state.language);
+    }
+    // Step 1.5: Prompt module selection
+    if (!state.modulesProvided && process.stdin.isTTY) {
+        step += 1;
+        printStep(step, maxSteps, t("init.stepModules"));
+        state.modules = await promptModules();
+    }
+    // Step 2: Determine adapter type (interactive)
+    if (!state.adapterProvided && !state.formatProvided && process.stdin.isTTY) {
+        step += 1;
+        printStep(step, maxSteps, t("init.stepAdapter"));
+        const type = await promptAdapterType();
+        if (type === "opencode") {
+            throw new Error(t("init.errorOpencode"));
+        }
+        if (type === "plugin") {
+            state.format = "plugin";
+        }
+        else {
+            state.format = "copy";
+        }
+    }
+    const adapter = state.adapter ?? "claude-code";
+    if (adapter === "opencode") {
+        throw new Error(t("init.errorOpencode"));
+    }
+    const format = state.format ?? "copy";
+    // Step 3: Prompt scope (skip for plugin — always global)
+    if (format !== "plugin" && !state.scopeProvided && !state.targetProvided && process.stdin.isTTY) {
+        step += 1;
+        printStep(step, maxSteps, t("init.stepLocation"));
+        state.scope = await promptScope();
+    }
+    return {
+        adapter,
+        targetPath: state.targetPath,
+        force: state.force,
+        scope: format === "plugin" ? "global" : (state.scope ?? "project"),
+        format,
+        language: state.language,
+        modules: state.modules
+    };
+}
+function parseInitArgs(args) {
+    const state = {
+        adapterProvided: false,
+        targetPath: ".",
+        targetProvided: false,
+        force: false,
+        scopeProvided: false,
+        formatProvided: false,
+        modulesProvided: false
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--adapter") {
+            const value = args[index + 1];
+            if (value !== "claude-code" && value !== "opencode") {
+                throw new Error(t("init.errorAdapterValue"));
+            }
+            state.adapter = value;
+            state.adapterProvided = true;
+            index += 1;
+            continue;
+        }
+        if (arg === "--target") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error(t("init.errorTargetPath"));
+            }
+            state.targetPath = value;
+            state.targetProvided = true;
+            index += 1;
+            continue;
+        }
+        if (arg === "--global") {
+            state.scope = "global";
+            state.scopeProvided = true;
+            continue;
+        }
+        if (arg === "--scope") {
+            const value = args[index + 1];
+            if (value !== "project" && value !== "global") {
+                throw new Error(t("init.errorScopeValue"));
+            }
+            state.scope = value;
+            state.scopeProvided = true;
+            index += 1;
+            continue;
+        }
+        if (arg === "--force") {
+            state.force = true;
+            continue;
+        }
+        if (arg === "--format") {
+            const value = args[index + 1];
+            if (value !== "copy" && value !== "plugin") {
+                throw new Error(t("init.errorFormatValue"));
+            }
+            state.format = value;
+            state.formatProvided = true;
+            index += 1;
+            continue;
+        }
+        if (arg === "--language") {
+            const value = args[index + 1];
+            const language = normalizeInitLanguage(value);
+            if (!language) {
+                throw new Error(t("init.errorLanguageValue"));
+            }
+            state.language = language;
+            index += 1;
+            continue;
+        }
+        if (arg === "--module") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error("--module requires a value");
+            }
+            if (!state.modules) {
+                state.modules = [];
+            }
+            state.modules.push(value);
+            state.modulesProvided = true;
+            index += 1;
+            continue;
+        }
+        throw new Error(t("init.errorUnknownOption", { option: arg }));
+    }
+    return state;
+}
+function parseUpdateArgs(args) {
+    const options = {
+        adapter: "claude-code",
+        targetPath: ".",
+        force: false,
+        dryRun: false
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--adapter") {
+            const value = args[index + 1];
+            if (value !== "claude-code") {
+                throw new Error(t("update.errorAdapterValue"));
+            }
+            options.adapter = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--target") {
+            const value = args[index + 1];
+            if (!value) {
+                throw new Error(t("update.errorTargetPath"));
+            }
+            options.targetPath = value;
+            index += 1;
+            continue;
+        }
+        if (arg === "--force") {
+            options.force = true;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            options.dryRun = true;
+            continue;
+        }
+        throw new Error(t("update.errorUnknownOption"));
+    }
+    return options;
+}
+async function installAdapter(options) {
+    const coreDistRoot = getCoreDistRoot();
+    const openflowPkgRoot = join(coreDistRoot, "openflow");
+    const templateRoot = join(coreDistRoot, "templates");
+    const targetRoot = options.scope === "global" ? getClaudeCodeUserRoot() : options.targetPath;
+    const files = [];
+    const adapterMappings = [
+        ["commands", "commands"],
+        ["skills", "skills"],
+        ["agents", "agents"],
+    ];
+    // Read modules.json and compute allowed file names
+    const modulesJsonPath = join(coreDistRoot, "modules.json");
+    const allowedFiles = await computeAllowedFiles(modulesJsonPath, options.modules);
+    const adapterTargetRoot = options.scope === "global" ? targetRoot : join(targetRoot, ".claude");
+    for (const [sourceDir, targetDir] of adapterMappings) {
+        const sourceRoot = join(openflowPkgRoot, sourceDir);
+        files.push(...(await copyMappedFiles(sourceRoot, join(adapterTargetRoot, targetDir), targetRoot, options.force, allowedFiles.get(sourceDir))));
+    }
+    if (options.scope === "project") {
+        files.push(...(await copyMappedFiles(templateRoot, join(targetRoot, ".openflow"), targetRoot, options.force)));
+        // Merge .mcp.json from the plugin package into the project root
+        files.push(await mergePluginMcpConfig(openflowPkgRoot, targetRoot, options.force));
+        if (options.language) {
+            const { updateProjectLanguage } = await import("./config.js");
+            await updateProjectLanguage(targetRoot, options.language);
+        }
+        if (options.modules && options.modules.length > 0) {
+            const configPath = join(targetRoot, ".openflow", "config.json");
+            if (existsSync(configPath)) {
+                const config = JSON.parse(await readFile(configPath, "utf8"));
+                config.modules = options.modules;
+                await writeJsonAtomic(configPath, config);
+            }
+        }
+        await writeInstallManifest(targetRoot, options.adapter);
+    }
+    return {
+        format: "copy",
+        adapter: options.adapter,
+        targetPath: targetRoot,
+        files,
+        modules: options.modules
+    };
+}
+function toLocalMarketplacePath(absPath) {
+    // Claude CLI requires ./relative format; convert absolute path from process.cwd()
+    const rel = relative(process.cwd(), absPath).replace(/\\/g, "/");
+    if (rel.startsWith("./") || rel.startsWith("../"))
+        return rel;
+    // isAbsolute check: cross-drive on Windows makes relative() return absolute
+    if (/^[a-zA-Z]:/.test(rel) || rel.startsWith("/"))
+        return `./${absPath.replace(/\\/g, "/")}`;
+    return `./${rel}`;
+}
+async function assembleMarketplaceDir(coreDistRoot) {
+    const marketplaceDir = join(getClaudeCodeUserRoot(), "plugins", "marketplaces", "openflow");
+    if (existsSync(marketplaceDir)) {
+        await rm(marketplaceDir, { recursive: true, force: true });
+    }
+    await mkdir(marketplaceDir, { recursive: true });
+    // .claude-plugin/marketplace.json at marketplace root
+    const mktClaudeDir = join(marketplaceDir, ".claude-plugin");
+    await mkdir(mktClaudeDir, { recursive: true });
+    await copyFile(join(coreDistRoot, "marketplace.json"), join(mktClaudeDir, "marketplace.json"));
+    // openflow/ plugin package
+    const openflowSrc = join(coreDistRoot, "openflow");
+    const openflowDest = join(marketplaceDir, "openflow");
+    const allFiles = await collectFiles(openflowSrc);
+    for (const srcFile of allFiles) {
+        const relPath = relative(openflowSrc, srcFile);
+        const targetFile = join(openflowDest, relPath);
+        await mkdir(dirname(targetFile), { recursive: true });
+        await copyFile(srcFile, targetFile);
+    }
+    return marketplaceDir;
+}
+async function createFilteredPluginDir(coreDistRoot, selectedModules) {
+    const marketplaceDir = join(getClaudeCodeUserRoot(), "plugins", "marketplaces", "openflow");
+    if (existsSync(marketplaceDir)) {
+        await rm(marketplaceDir, { recursive: true, force: true });
+    }
+    await mkdir(marketplaceDir, { recursive: true });
+    // .claude-plugin/marketplace.json at marketplace root
+    const mktClaudeDir = join(marketplaceDir, ".claude-plugin");
+    await mkdir(mktClaudeDir, { recursive: true });
+    await copyFile(join(coreDistRoot, "marketplace.json"), join(mktClaudeDir, "marketplace.json"));
+    // Filter and copy openflow/ plugin package
+    const openflowSrc = join(coreDistRoot, "openflow");
+    const openflowDest = join(marketplaceDir, "openflow");
+    await mkdir(openflowDest, { recursive: true });
+    const modulesJsonPath = join(coreDistRoot, "modules.json");
+    const allowedFilesMap = await computeAllowedFiles(modulesJsonPath, selectedModules);
+    const filteredDirs = new Set(["skills", "agents", "commands"]);
+    const allSourceFiles = await collectFiles(openflowSrc);
+    for (const srcFile of allSourceFiles) {
+        const relPath = relative(openflowSrc, srcFile);
+        const parts = relPath.split(/[/\\]/);
+        const topDir = parts[0];
+        if (filteredDirs.has(topDir)) {
+            const allowed = allowedFilesMap.get(topDir);
+            if (allowed !== undefined) {
+                const itemName = parts[1]?.replace(/\.(md|cjs|mjs|js|ts)$/, "");
+                if (!itemName || !allowed.has(itemName)) {
+                    continue;
+                }
+            }
+        }
+        const targetFile = join(openflowDest, relPath);
+        await mkdir(dirname(targetFile), { recursive: true });
+        await copyFile(srcFile, targetFile);
+    }
+    return marketplaceDir;
+}
+async function installPlugin(options) {
+    const coreDistRoot = getCoreDistRoot();
+    // Build a filtered plugin dir if specific modules were selected, otherwise use dist/ directly
+    let marketplaceDir;
+    if (options.modules && options.modules.length > 0) {
+        marketplaceDir = await createFilteredPluginDir(coreDistRoot, options.modules);
+    }
+    else {
+        // Use dist/ directly as marketplace: it has .claude-plugin/marketplace.json (via symlink/copy)
+        // We need to assemble a proper marketplace dir with .claude-plugin/marketplace.json + openflow/
+        marketplaceDir = await assembleMarketplaceDir(coreDistRoot);
+    }
+    // Step 1: Register local marketplace — Claude CLI requires ./relative path format
+    const marketplaceArg = toLocalMarketplacePath(marketplaceDir);
+    console.log(`  ${colorText("muted", t("init.stepMarketplace") + "...")}`);
+    try {
+        await execClaudeAsync(["plugin", "marketplace", "add", marketplaceArg]);
+    }
+    catch (err) {
+        // Only treat ENOENT as "claude not installed"; other errors come from the marketplace command itself
+        if (isRecord(err) && err.code === "ENOENT") {
+            throw new Error(t("init.errorClaudeCliMissing"));
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(t("init.errorMarketplaceAdd", { message }));
+    }
+    // Step 2: Install plugin from marketplace
+    console.log(`  ${colorText("muted", t("init.stepPluginInstall") + "...")}`);
+    try {
+        await execClaudeAsync(["plugin", "install", "openflow@openflow", "--scope", "user"]);
+    }
+    catch (err) {
+        if (isMissingExecutableError(err)) {
+            throw new Error(t("init.errorClaudeCliMissing"));
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(t("init.errorPluginInstall", { message }));
+    }
+    // Step 3: Verify installation
+    console.log(`  ${colorText("muted", t("init.stepVerify") + "...")}`);
+    await verifyPluginInstall();
+    printPanel(t("init.panelPlugin"), [
+        ["plugin", "openflow"],
+        ["marketplace", marketplaceDir],
+        ["scope", "user"]
+    ]);
+    return {
+        format: "plugin",
+        adapter: options.adapter,
+        targetPath: options.targetPath,
+        files: [],
+        marketplacePath: marketplaceDir,
+        pluginId: "openflow@openflow",
+        scope: "user"
+    };
+}
+async function verifyPluginInstall() {
+    const errors = [];
+    try {
+        const { stdout } = await execClaudeAsync(["plugin", "list", "--json"], { captureOutput: true });
+        const trimmed = stdout.trim();
+        // Detect non-JSON output early (e.g. AI chat response from claude CLI)
+        if (trimmed.length > 0 && !trimmed.startsWith("[") && !trimmed.startsWith("{")) {
+            throw new Error(t("init.errorPluginOutput"));
+        }
+        const plugins = parseJsonFromClaudeOutput(trimmed);
+        if (Array.isArray(plugins) && plugins.some((plugin) => isRecord(plugin) && plugin.id === "openflow@openflow" && plugin.enabled !== false)) {
+            return;
+        }
+    }
+    catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+    }
+    try {
+        const userSettings = await readJsonObjectIfExists(join(getClaudeCodeUserRoot(), "settings.json"));
+        if (userSettings.exists &&
+            userSettings.valid &&
+            isRecord(userSettings.value.enabledPlugins) &&
+            userSettings.value.enabledPlugins["openflow@openflow"] === true) {
+            return;
+        }
+    }
+    catch (err) {
+        errors.push(err instanceof Error ? err.message : String(err));
+    }
+    const message = errors.length > 0
+        ? errors.join("; ")
+        : "openflow@openflow was not listed after installation.";
+    throw new Error(t("init.errorPluginVerify", { message }));
+}
+function parseJsonFromClaudeOutput(output) {
+    const trimmed = output.trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch (err) {
+        const start = trimmed.search(/[\[{]/);
+        if (start >= 0) {
+            const candidate = trimmed.slice(start);
+            try {
+                return JSON.parse(candidate);
+            }
+            catch {
+                // Report the original parse error below; the prefix was not the only issue.
+            }
+        }
+        throw err;
+    }
+}
+async function execClaudeAsync(args, options = {}) {
+    const commandFromEnv = process.env[CLAUDE_BIN_ENV];
+    const command = commandFromEnv ?? "claude";
+    const prefixArgs = parseClaudeBinArgs();
+    const commandArgs = [...prefixArgs, ...args];
+    const execOptions = { timeout: 60_000 };
+    if (process.platform === "win32" && (!commandFromEnv || /\.(cmd|bat)$/i.test(command))) {
+        const commandLine = [quoteCmdCommand(command), ...commandArgs.map(quoteCmdArg)].join(" ");
+        const result = await execFileAsync(process.env.ComSpec ?? "cmd.exe", ["/d", "/c", commandLine], execOptions);
+        return options.captureOutput ? result : undefined;
+    }
+    const result = await execFileAsync(command, commandArgs, execOptions);
+    return options.captureOutput ? result : undefined;
+}
+function isMissingExecutableError(error) {
+    if (isRecord(error) && error.code === "ENOENT") {
+        return true;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /not recognized as an internal or external command|not found|system cannot find|找不到|不是内部或外部命令|系统找不到/.test(message);
+}
+function quoteCmdArg(value) {
+    // Only quote arguments that contain spaces or special shell characters.
+    // Over-quoting simple args like "plugin" "list" "--json" causes cmd.exe /c
+    // to pass them to claude as a prompt string instead of subcommand args.
+    if (/^[A-Za-z0-9_.@:/\\-]+$/.test(value)) {
+        return value;
+    }
+    return `"${value.replaceAll("%", "%%").replaceAll('"', '\\"')}"`;
+}
+function quoteCmdCommand(value) {
+    return /^[A-Za-z0-9_.-]+$/.test(value) ? value : quoteCmdArg(value);
+}
+function parseClaudeBinArgs() {
+    const raw = process.env[CLAUDE_BIN_ARGS_ENV];
+    if (!raw) {
+        return [];
+    }
+    const value = JSON.parse(raw);
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new Error(`${CLAUDE_BIN_ARGS_ENV} must be a JSON array of strings.`);
+    }
+    return value;
+}
+async function updateAdapter(options) {
+    const targetRoot = options.targetPath;
+    const manifest = await readInstallManifest(targetRoot);
+    const files = await updateManagedAdapterFiles(targetRoot, manifest, options);
+    files.push(await updateClaudeProjectMcpConfig(targetRoot, options));
+    const configStatus = await mergeProjectConfigDefaults(targetRoot, options.dryRun);
+    const hasConflicts = files.some((file) => file.status === "conflict" || file.status === "would-conflict");
+    if (!options.dryRun && !hasConflicts) {
+        await writeInstallManifest(targetRoot, options.adapter);
+    }
+    return {
+        adapter: options.adapter,
+        targetPath: targetRoot,
+        files,
+        configStatus,
+        manifestStatus: !options.dryRun && !hasConflicts ? "written" : "skipped"
+    };
+}
+/**
+ * Resolves the path to platform-specific artifacts bundled inside this package.
+ * Core dist is copied into cli/dist/core during build.
+ */
+function getCoreDistRoot() {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    return join(thisDir, "..", "core-artifacts");
+}
+async function computeAllowedFiles(modulesJsonPath, selectedModules) {
+    if (!selectedModules || selectedModules.length === 0) {
+        // No filter — return empty map, allowedFiles.get() returns undefined = allow all
+        return new Map();
+    }
+    const result = new Map();
+    result.set("skills", new Set());
+    result.set("agents", new Set());
+    result.set("commands", new Set());
+    result.set("hooks", new Set());
+    if (!existsSync(modulesJsonPath)) {
+        return result;
+    }
+    const modulesJson = JSON.parse(await readFile(modulesJsonPath, "utf8"));
+    for (const modId of selectedModules) {
+        const mod = modulesJson.modules[modId];
+        if (!mod)
+            continue;
+        for (const category of ["skills", "agents", "commands", "hooks"]) {
+            const items = mod[category] ?? [];
+            const set = result.get(category);
+            if (set) {
+                for (const item of items) {
+                    set.add(item);
+                }
+            }
+        }
+    }
+    return result;
+}
+function getCliTemplateRoot() {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    return join(thisDir, "..", "core-artifacts", "templates");
+}
+function getClaudeCodeUserRoot() {
+    return process.env.OPENFLOW_CLAUDE_HOME ?? join(homedir(), ".claude");
+}
+async function copyMappedFiles(sourceRoot, targetRoot, displayRoot, force, allowedFiles) {
+    const files = [];
+    const sourceFiles = await collectFiles(sourceRoot);
+    for (const sourceFile of sourceFiles) {
+        const relativeSource = relative(sourceRoot, sourceFile);
+        // Filter by allowed files if specified
+        if (allowedFiles) {
+            // Extract the base directory name (e.g., "brainstorm" from "brainstorm/SKILL.md")
+            const parts = relativeSource.split(/[/\\]/);
+            const baseName = parts[0].replace(/\.(md|cjs|mjs|js|ts)$/, "");
+            if (!allowedFiles.has(baseName)) {
+                continue;
+            }
+        }
+        const targetFile = join(targetRoot, relativeSource);
+        const existed = existsSync(targetFile);
+        if (existed && !force) {
+            files.push({
+                source: relativeSource,
+                target: relative(displayRoot, targetFile),
+                status: "skipped"
+            });
+            continue;
+        }
+        await mkdir(dirname(targetFile), { recursive: true });
+        await copyFile(sourceFile, targetFile);
+        files.push({
+            source: relativeSource,
+            target: relative(displayRoot, targetFile),
+            status: existed ? "overwritten" : "created"
+        });
+    }
+    return files;
+}
+async function mergePluginMcpConfig(openflowPkgRoot, targetRoot, force) {
+    const mcpPath = join(targetRoot, ".mcp.json");
+    const target = relative(targetRoot, mcpPath);
+    const pluginMcpPath = join(openflowPkgRoot, ".mcp.json");
+    // Read plugin's .mcp.json to get the servers to merge
+    const pluginMcp = existsSync(pluginMcpPath)
+        ? JSON.parse(await readFile(pluginMcpPath, "utf8"))
+        : null;
+    if (!pluginMcp || !isRecord(pluginMcp.mcpServers)) {
+        // Fallback: use hardcoded studio server
+        const mcpPath = join(targetRoot, ".mcp.json");
+        const target = relative(targetRoot, mcpPath);
+        const current = await readJsonObjectIfExists(mcpPath);
+        if (!current.exists) {
+            await writeJsonAtomic(mcpPath, createClaudeProjectMcpConfig());
+            return { source: "openflow/.mcp.json", target, status: "created" };
+        }
+        return { source: "openflow/.mcp.json", target, status: "skipped" };
+    }
+    // Transform plugin MCP servers: replace ${CLAUDE_PLUGIN_ROOT} with npx invocation
+    const servers = {};
+    for (const [name, serverDef] of Object.entries(pluginMcp.mcpServers)) {
+        if (!isRecord(serverDef))
+            continue;
+        // For copy mode, use npx-based invocation instead of plugin-relative paths
+        servers[name] = createClaudeProjectMcpServer();
+    }
+    const current = await readJsonObjectIfExists(mcpPath);
+    if (!current.exists) {
+        await writeJsonAtomic(mcpPath, { mcpServers: servers });
+        return { source: "openflow/.mcp.json", target, status: "created" };
+    }
+    if (!current.valid) {
+        return { source: "openflow/.mcp.json", target, status: "skipped" };
+    }
+    const existingServers = isRecord(current.value.mcpServers) ? current.value.mcpServers : {};
+    const hasAllServers = Object.keys(servers).every((k) => mcpServerEquals(existingServers[k], servers[k]));
+    if (hasAllServers) {
+        return { source: "openflow/.mcp.json", target, status: "skipped" };
+    }
+    if (!force && Object.keys(servers).some((k) => existingServers[k] !== undefined)) {
+        return { source: "openflow/.mcp.json", target, status: "skipped" };
+    }
+    await writeJsonAtomic(mcpPath, {
+        ...current.value,
+        mcpServers: { ...existingServers, ...servers }
+    });
+    return { source: "openflow/.mcp.json", target, status: "overwritten" };
+}
+async function updateClaudeProjectMcpConfig(targetRoot, options) {
+    const mcpPath = join(targetRoot, ".mcp.json");
+    const target = relative(targetRoot, mcpPath);
+    const current = await readJsonObjectIfExists(mcpPath);
+    if (!current.exists) {
+        if (!options.dryRun) {
+            await writeJsonAtomic(mcpPath, createClaudeProjectMcpConfig());
+        }
+        return { source: "claude-code-mcp", target, status: options.dryRun ? "would-create" : "created" };
+    }
+    if (!current.valid) {
+        return { source: "claude-code-mcp", target, status: options.dryRun ? "would-conflict" : "conflict" };
+    }
+    const existingServer = readMcpServer(current.value, CLAUDE_PROJECT_MCP_SERVER_NAME);
+    const server = createClaudeProjectMcpServer();
+    if (mcpServerEquals(existingServer, server)) {
+        return { source: "claude-code-mcp", target, status: "unchanged" };
+    }
+    if (existingServer !== undefined && !options.force) {
+        return { source: "claude-code-mcp", target, status: options.dryRun ? "would-conflict" : "conflict" };
+    }
+    if (!options.dryRun) {
+        await writeJsonAtomic(mcpPath, mergeClaudeProjectMcpConfig(current.value));
+    }
+    return { source: "claude-code-mcp", target, status: options.dryRun ? "would-update" : "updated" };
+}
+function createClaudeProjectMcpConfig() {
+    return {
+        mcpServers: {
+            [CLAUDE_PROJECT_MCP_SERVER_NAME]: createClaudeProjectMcpServer()
+        }
+    };
+}
+function mergeClaudeProjectMcpConfig(current) {
+    const mcpServers = isRecord(current.mcpServers) ? current.mcpServers : {};
+    return {
+        ...current,
+        mcpServers: {
+            ...mcpServers,
+            [CLAUDE_PROJECT_MCP_SERVER_NAME]: createClaudeProjectMcpServer()
+        }
+    };
+}
+function createClaudeProjectMcpServer() {
+    if (process.platform === "win32") {
+        return {
+            type: "stdio",
+            command: "cmd",
+            args: ["/c", "npx", "-y", "@openflowjs/cli", "mcp", "review"]
+        };
+    }
+    return {
+        type: "stdio",
+        command: "npx",
+        args: ["-y", "@openflowjs/cli", "mcp", "review"]
+    };
+}
+function readMcpServer(config, name) {
+    return isRecord(config.mcpServers) ? config.mcpServers[name] : undefined;
+}
+function mcpServerEquals(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+async function updateManagedAdapterFiles(targetRoot, manifest, options) {
+    const entries = await collectManagedAdapterEntries(targetRoot);
+    const files = [];
+    for (const entry of entries) {
+        const existed = existsSync(entry.targetFile);
+        const target = relative(targetRoot, entry.targetFile);
+        if (!existed) {
+            files.push({
+                source: entry.source,
+                target,
+                status: options.dryRun ? "would-create" : "created"
+            });
+            if (!options.dryRun) {
+                await mkdir(dirname(entry.targetFile), { recursive: true });
+                await copyFile(entry.sourceFile, entry.targetFile);
+            }
+            continue;
+        }
+        const sourceSha = await sha256File(entry.sourceFile);
+        const targetSha = await sha256File(entry.targetFile);
+        if (sourceSha === targetSha) {
+            files.push({ source: entry.source, target, status: "unchanged" });
+            continue;
+        }
+        const knownSha = manifest?.files[target]?.sha256;
+        const canOverwrite = options.force || knownSha === targetSha;
+        if (!canOverwrite) {
+            files.push({
+                source: entry.source,
+                target,
+                status: options.dryRun ? "would-conflict" : "conflict"
+            });
+            continue;
+        }
+        files.push({
+            source: entry.source,
+            target,
+            status: options.dryRun ? "would-update" : "updated"
+        });
+        if (!options.dryRun) {
+            await copyFile(entry.sourceFile, entry.targetFile);
+        }
+    }
+    return files;
+}
+async function collectManagedAdapterEntries(targetRoot) {
+    const openflowPkgRoot = join(getCoreDistRoot(), "openflow");
+    const adapterMappings = [
+        ["commands", "commands"],
+        ["skills", "skills"],
+        ["agents", "agents"],
+    ];
+    const entries = [];
+    for (const [sourceDir, targetDir] of adapterMappings) {
+        const sourceRoot = join(openflowPkgRoot, sourceDir);
+        const sourceFiles = await collectFiles(sourceRoot);
+        for (const sourceFile of sourceFiles) {
+            const relativeSource = relative(sourceRoot, sourceFile);
+            entries.push({
+                source: `${sourceDir}/${relativeSource.replace(/\\/g, "/")}`,
+                sourceFile,
+                targetFile: join(targetRoot, ".claude", targetDir, relativeSource)
+            });
+        }
+    }
+    return entries;
+}
+async function readInstallManifest(targetRoot) {
+    const manifestPath = join(targetRoot, INSTALL_MANIFEST_PATH);
+    if (!existsSync(manifestPath)) {
+        return undefined;
+    }
+    const value = JSON.parse(await readFile(manifestPath, "utf8"));
+    if (!isRecord(value) || value.version !== 1 || value.adapter !== "claude-code" || !isRecord(value.files)) {
+        return undefined;
+    }
+    const files = {};
+    for (const [path, entry] of Object.entries(value.files)) {
+        if (isRecord(entry) && typeof entry.sha256 === "string") {
+            files[path] = { sha256: entry.sha256 };
+        }
+    }
+    return {
+        version: 1,
+        adapter: "claude-code",
+        installedAt: typeof value.installedAt === "string" ? value.installedAt : "",
+        files
+    };
+}
+async function writeInstallManifest(targetRoot, adapter) {
+    const entries = await collectManagedAdapterEntries(targetRoot);
+    const files = {};
+    for (const entry of entries) {
+        if (!existsSync(entry.targetFile)) {
+            continue;
+        }
+        files[relative(targetRoot, entry.targetFile)] = {
+            sha256: await sha256File(entry.targetFile)
+        };
+    }
+    await writeJsonAtomic(join(targetRoot, INSTALL_MANIFEST_PATH), {
+        version: 1,
+        adapter,
+        installedAt: new Date().toISOString(),
+        files
+    });
+}
+async function mergeProjectConfigDefaults(targetPath, dryRun) {
+    const configPath = join(targetPath, ".openflow", "config.json");
+    const template = JSON.parse(await readFile(join(getCliTemplateRoot(), "config.json"), "utf8"));
+    if (!existsSync(configPath)) {
+        if (!dryRun) {
+            await writeJsonAtomic(configPath, template);
+        }
+        return dryRun ? "would-create" : "created";
+    }
+    const { readProjectConfig } = await import("./config.js");
+    const current = await readProjectConfig(targetPath);
+    const merged = mergeMissingConfigDefaults(current, template);
+    if (JSON.stringify(current) === JSON.stringify(merged)) {
+        return "unchanged";
+    }
+    if (!dryRun) {
+        await writeJsonAtomic(configPath, merged);
+    }
+    return dryRun ? "would-merge" : "merged";
+}
+function mergeMissingConfigDefaults(current, defaults) {
+    const merged = { ...current };
+    for (const [key, value] of Object.entries(defaults)) {
+        if (!(key in merged)) {
+            merged[key] = value;
+            continue;
+        }
+        if (isRecord(merged[key]) && isRecord(value)) {
+            merged[key] = mergeMissingConfigDefaults(merged[key], value);
+        }
+    }
+    return merged;
+}
+async function promptAdapterType() {
+    const answer = await promptChoice(t("init.adapterType"), [t("init.adapterCopy"), t("init.adapterPlugin"), t("init.adapterOpencode")], "1");
+    if (answer === "2")
+        return "plugin";
+    if (answer === "3")
+        return "opencode";
+    return "claude-code";
+}
+async function promptScope() {
+    const answer = await promptChoice(t("init.installLocation"), [t("init.installLocal"), t("init.installGlobal")], "1");
+    return answer === "2" ? "global" : "project";
+}
+async function promptLanguage() {
+    const answer = await promptChoice("Interface language", ["English (en-US)", "Chinese (zh-CN)"], "1");
+    setLocale(INIT_LANGUAGE_CHOICES[Number(answer) - 1] ?? "en-US");
+    return INIT_LANGUAGE_CHOICES[Number(answer) - 1] ?? "en-US";
+}
+async function promptModules() {
+    const items = [
+        { id: "core", label: t("init.moduleCore"), desc: t("init.moduleCoreDesc"), checked: true, required: true },
+        { id: "brainstorm-prd", label: t("init.moduleBrainstormPrd"), desc: t("init.moduleBrainstormPrdDesc"), checked: false, required: false },
+    ];
+    const input = process.stdin;
+    const output = process.stdout;
+    if (!input.isTTY) {
+        return items.filter((item) => item.checked).map((item) => item.id);
+    }
+    let selectedIndex = 0;
+    let renderedLines = 0;
+    emitKeypressEvents(input);
+    const wasRaw = input.isRaw;
+    function render(initial = false) {
+        if (!initial) {
+            moveCursor(output, 0, -renderedLines);
+            cursorTo(output, 0);
+            clearScreenDown(output);
+        }
+        const lines = [];
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            const cursor = i === selectedIndex ? ">" : " ";
+            const check = item.checked ? "x" : " ";
+            const req = item.required ? ` ${t("init.moduleRequired")}` : "";
+            lines.push(`${cursor} [${check}] ${item.label}${req} - ${item.desc}`);
+        }
+        lines.push(colorText("muted", t("init.moduleCheckboxHint")));
+        output.write(`${lines.join("\n")}\n`);
+        renderedLines = lines.length;
+    }
+    try {
+        input.setRawMode(true);
+        input.resume();
+        render(true);
+        return await new Promise((resolve, reject) => {
+            const onKeypress = (_text, key) => {
+                if ((key.ctrl && key.name === "c") || key.name === "escape") {
+                    cleanup();
+                    reject(new Error(t("init.cancelled")));
+                    return;
+                }
+                if (key.name === "up") {
+                    selectedIndex = selectedIndex === 0 ? items.length - 1 : selectedIndex - 1;
+                    render();
+                    return;
+                }
+                if (key.name === "down") {
+                    selectedIndex = selectedIndex === items.length - 1 ? 0 : selectedIndex + 1;
+                    render();
+                    return;
+                }
+                if (key.name === "space") {
+                    if (!items[selectedIndex].required) {
+                        items[selectedIndex].checked = !items[selectedIndex].checked;
+                        render();
+                    }
+                    return;
+                }
+                if (key.name === "return" || key.name === "enter") {
+                    cleanup();
+                    output.write("\n");
+                    resolve(items.filter((item) => item.checked).map((item) => item.id));
+                    return;
+                }
+            };
+            const cleanup = () => {
+                input.off("keypress", onKeypress);
+                input.setRawMode(wasRaw);
+                if (!wasRaw) {
+                    input.pause();
+                }
+            };
+            input.on("keypress", onKeypress);
+        });
+    }
+    finally {
+        if (input.isRaw !== wasRaw) {
+            input.setRawMode(wasRaw);
+        }
+    }
+}
+async function promptChoice(title, labels, defaultValue) {
+    const defaultIndex = Number(defaultValue) - 1;
+    let selectedIndex = Math.min(Math.max(defaultIndex, 0), labels.length - 1);
+    let renderedLines = 0;
+    const input = process.stdin;
+    const output = process.stdout;
+    if (!input.isTTY) {
+        return String(selectedIndex + 1);
+    }
+    emitKeypressEvents(input);
+    const wasRaw = input.isRaw;
+    function render(initial = false) {
+        if (!initial) {
+            moveCursor(output, 0, -renderedLines);
+            cursorTo(output, 0);
+            clearScreenDown(output);
+        }
+        const lines = renderChoiceLines(title, labels, selectedIndex);
+        output.write(`${lines.join("\n")}\n`);
+        renderedLines = lines.length;
+    }
+    try {
+        input.setRawMode(true);
+        input.resume();
+        render(true);
+        return await new Promise((resolve, reject) => {
+            const onKeypress = (_text, key) => {
+                if ((key.ctrl && key.name === "c") || key.name === "escape") {
+                    cleanup();
+                    reject(new Error(t("init.cancelled")));
+                    return;
+                }
+                if (key.name === "up") {
+                    selectedIndex = selectedIndex === 0 ? labels.length - 1 : selectedIndex - 1;
+                    render();
+                    return;
+                }
+                if (key.name === "down") {
+                    selectedIndex = selectedIndex === labels.length - 1 ? 0 : selectedIndex + 1;
+                    render();
+                    return;
+                }
+                if (key.name === "return" || key.name === "enter") {
+                    cleanup();
+                    output.write("\n");
+                    resolve(String(selectedIndex + 1));
+                    return;
+                }
+            };
+            const cleanup = () => {
+                input.off("keypress", onKeypress);
+                input.setRawMode(wasRaw);
+                if (!wasRaw) {
+                    input.pause();
+                }
+            };
+            input.on("keypress", onKeypress);
+        });
+    }
+    finally {
+        if (input.isRaw !== wasRaw) {
+            input.setRawMode(wasRaw);
+        }
+    }
+}
+function renderChoiceLines(title, labels, selectedIndex) {
+    return [
+        formatTitle(title),
+        ...labels.map((label, index) => {
+            const marker = index === selectedIndex ? ">" : " ";
+            const number = `${index + 1}.`;
+            return `${marker} ${number} ${label}`;
+        }),
+        colorText("muted", t("init.promptHint"))
+    ];
+}
+function normalizeInitLanguage(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "zh" || normalized === "zh-cn" || normalized === "cn" || normalized === "chinese") {
+        return "zh-CN";
+    }
+    if (normalized === "en" || normalized === "en-us" || normalized === "english") {
+        return "en-US";
+    }
+    return undefined;
+}
+function printInstallResult(result) {
+    console.log();
+    console.log(formatTitle(t("init.title")));
+    printKeyValue("adapter", result.adapter);
+    printKeyValue("format", result.format);
+    printKeyValue("target", result.targetPath);
+    if (result.format === "plugin") {
+        printKeyValue("plugin", result.pluginId);
+        printKeyValue("marketplace", result.marketplacePath);
+        printKeyValue("scope", result.scope);
+    }
+    if (result.format === "copy" && result.modules && result.modules.length > 0) {
+        printKeyValue("modules", result.modules.join(", "));
+    }
+    console.log();
+    for (const file of result.files) {
+        printFileStatus(file.status, file.target);
+    }
+    const totalCount = result.files.length;
+    if (totalCount > 0) {
+        console.log();
+        console.log(`  ${colorText("muted", t("init.filesInstalled", { count: String(totalCount) }))}`);
+    }
+}
+function printUpdateResult(result) {
+    const counts = result.files.reduce((accumulator, file) => {
+        accumulator[file.status] += 1;
+        return accumulator;
+    }, {
+        created: 0,
+        updated: 0,
+        unchanged: 0,
+        conflict: 0,
+        "would-create": 0,
+        "would-update": 0,
+        "would-conflict": 0
+    });
+    printPanel(t("update.title"), [
+        ["adapter", result.adapter],
+        ["target", result.targetPath],
+        [
+            "summary",
+            `created=${counts.created} updated=${counts.updated} unchanged=${counts.unchanged} conflict=${counts.conflict} ` +
+                `would-create=${counts["would-create"]} would-update=${counts["would-update"]} would-conflict=${counts["would-conflict"]}`
+        ],
+        ["state", `config=${result.configStatus} manifest=${result.manifestStatus}`]
+    ]);
+    for (const file of result.files) {
+        printFileStatus(file.status, file.target);
+    }
+}
+//# sourceMappingURL=init.js.map