open-multi-agent-kit 0.78.0

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

@@ -0,0 +1,2 @@
+import type { InitCommandOptions } from "./types.js";
+export declare function initCommand(options: InitCommandOptions): Promise<void>;

package/dist/commands/init/core.js

@@ -0,0 +1,298 @@
+import { mkdir, writeFile, readFile, symlink } from "fs/promises";
+import { dirname, join } from "path";
+import { getProjectRoot, getUserHome, normalizeUserHomePath, pathExists } from "../../util/fs.js";
+import { getOmkVersionSync } from "../../util/version.js";
+import { style, header, status } from "../../util/theme.js";
+import { defaultLspConfigJson } from "../../lsp/default-config.js";
+import { t } from "../../util/i18n.js";
+import { OMK_CORE_VERIFIED_PRESET } from "../../runtime/core-verified-preset.js";
+import { packageRoot } from "./constants.js";
+import { OKABE_AGENT_YAML, ROOT_AGENT_YAML, ROLE_YAMLS, ROOT_PROMPT_MD, HOOK_SCRIPTS, KIMI_CONFIG_TOML, MEMORY_FILES, getDesignMd, GEMINI_MD, CLAUDE_MD, ROADMAP_MD, SECURITY_MD, } from "./content.js";
+import { readTemplateFile } from "./utils.js";
+import { copyTemplateDir, copySafeSkillRoot, createMcpJson, ensureProjectMcpConfig, checkOmkInPath, maybeInstallShellCompletion } from "./scaffold.js";
+import { createThemeJson, createRuntimePresetsJson, getConfigToml } from "./config.js";
+import { resolveLocalUserRuntime, runInitInteractiveSetup, shouldImportUserSkills, } from "./interactive.js";
+export async function initCommand(options) {
+    const root = getProjectRoot();
+    const initHomeDir = normalizeUserHomePath(options.homeDir) ?? getUserHome(options.env ?? process.env);
+    const mcpJson = createMcpJson(root);
+    console.log(header(`open-multi-agent-kit init (profile: ${options.profile})`));
+    const localUserRuntime = await resolveLocalUserRuntime(options, initHomeDir);
+    // 1. Create directories (parallel)
+    const dirs = [
+        ".omk/memory",
+        ".omk/runs",
+        ".omk/checkpoints",
+        ".omk/agents/roles",
+        ".omk/prompts/role-addons",
+        ".omk/hooks",
+        ".omk/worktrees",
+        ".omk/logs",
+        ".omk/snippets",
+        ".kimi/skills",
+        ".kimi/hooks",
+        ".agents/skills",
+    ];
+    await Promise.all(dirs.map((d) => mkdir(join(root, d), { recursive: true })));
+    // 2. Write AGENTS.md (skip if exists)
+    const agentsMdPath = join(root, "AGENTS.md");
+    if (await pathExists(agentsMdPath)) {
+        console.log(t("init.agentsMdExists"));
+    }
+    else {
+        const agentsMdContent = await readFile(join(packageRoot, "templates", "AGENTS.md"), "utf8");
+        await writeFile(agentsMdPath, agentsMdContent);
+    }
+    // 2.5 Write .kimi/AGENTS.md (Kimi-specific rules)
+    const kimiAgentsMdPath = join(root, ".kimi", "AGENTS.md");
+    if (await pathExists(kimiAgentsMdPath)) {
+        console.log(t("init.kimiAgentsMdExists"));
+    }
+    else {
+        const kimiAgentsMdContent = await readFile(join(packageRoot, "templates", ".kimi", "AGENTS.md"), "utf8");
+        await writeFile(kimiAgentsMdPath, kimiAgentsMdContent);
+    }
+    // 3. Write / migrate agents (parallel)
+    const okabeYamlPath = join(root, ".omk/agents/okabe.yaml");
+    await writeFile(okabeYamlPath, OKABE_AGENT_YAML);
+    const rootYamlPath = join(root, ".omk/agents/root.yaml");
+    if (await pathExists(rootYamlPath)) {
+        // Existing root.yaml migration: fix relative path bug
+        const existing = await readFile(rootYamlPath, "utf8");
+        if (existing.includes("system_prompt_path: ./prompts/root.md")) {
+            const migrated = existing.replace(/system_prompt_path:\s*\.\/prompts\/root\.md/, "system_prompt_path: ../prompts/root.md");
+            await writeFile(rootYamlPath, migrated);
+            console.log(status.ok(t("init.rootYamlMigrated")));
+        }
+    }
+    else {
+        const rootAgentYaml = await readTemplateFile(join(".omk", "agents", "root.yaml"), ROOT_AGENT_YAML);
+        await writeFile(rootYamlPath, rootAgentYaml);
+    }
+    await Promise.all(Object.entries(ROLE_YAMLS).map(async ([name, content]) => {
+        const roleYaml = await readTemplateFile(join(".omk", "agents", "roles", `${name}.yaml`), content);
+        await writeFile(join(root, ".omk/agents/roles", `${name}.yaml`), roleYaml);
+    }));
+    // 4. Write prompts
+    const rootPromptMd = await readTemplateFile(join(".omk", "prompts", "root.md"), ROOT_PROMPT_MD);
+    await writeFile(join(root, ".omk/prompts/root.md"), rootPromptMd);
+    // 5+6. Copy package skill templates by default.
+    // Fresh open-source init should reference only the maintainer-packaged OMK
+    // skills. Local maintainers can explicitly opt into importing personal skills
+    // with --import-user-skills or OMK_INIT_IMPORT_USER_SKILLS=1.
+    const kimiSkillsSrc = join(packageRoot, "templates", "skills", "kimi");
+    const agentsSkillsSrc = join(packageRoot, "templates", "skills", "agents");
+    const skillCopies = [];
+    const importUserSkills = shouldImportUserSkills(options);
+    if (importUserSkills) {
+        const personalSkillSources = [
+            {
+                label: "~/.kimi/skills",
+                src: join(initHomeDir, ".kimi", "skills"),
+                dest: join(root, ".kimi", "skills"),
+            },
+            {
+                label: "~/.codex/skills",
+                src: join(initHomeDir, ".codex", "skills"),
+                dest: join(root, ".kimi", "skills"),
+            },
+            {
+                label: "~/.agents/skills",
+                src: join(initHomeDir, ".agents", "skills"),
+                dest: join(root, ".agents", "skills"),
+            },
+        ];
+        for (const source of personalSkillSources) {
+            if (await pathExists(source.src)) {
+                console.log(style.purple(`   📦 Importing ${source.label} (trusted local opt-in)...`));
+                skillCopies.push(copySafeSkillRoot(source.src, source.dest).then((stats) => {
+                    if (stats.skippedUnsafe > 0) {
+                        console.log(status.warn(`Skipped ${stats.skippedUnsafe} secret-bearing skills from ${source.label}`));
+                    }
+                    if (stats.skippedUnavailable > 0) {
+                        console.log(status.warn(`Skipped ${stats.skippedUnavailable} unavailable skills from ${source.label}`));
+                    }
+                }));
+            }
+        }
+    }
+    // Global skills symlink for local-user init
+    let globalSkillsSymlinked = false;
+    if (localUserRuntime && initHomeDir) {
+        const globalKimiSkills = join(initHomeDir, ".kimi", "skills");
+        if (await pathExists(globalKimiSkills)) {
+            const dest = join(root, ".kimi", "skills");
+            if (!(await pathExists(dest))) {
+                console.log(style.purple("   📦 Symlinking global ~/.kimi/skills..."));
+                await mkdir(dirname(dest), { recursive: true });
+                try {
+                    await symlink(globalKimiSkills, dest, "dir");
+                    globalSkillsSymlinked = true;
+                }
+                catch (err) {
+                    console.warn(status.warn(`Failed to symlink global skills: ${err.message}`));
+                }
+            }
+        }
+    }
+    if (!globalSkillsSymlinked && await pathExists(kimiSkillsSrc)) {
+        console.log(style.purple(t("init.copyKimiSkills")));
+        skillCopies.push(copySafeSkillRoot(kimiSkillsSrc, join(root, ".kimi", "skills")).then(() => undefined));
+    }
+    else if (!globalSkillsSymlinked) {
+        console.log(status.warn(t("init.kimiSkillsMissing")));
+    }
+    if (await pathExists(agentsSkillsSrc)) {
+        console.log(style.purple(t("init.copyPortableSkills")));
+        skillCopies.push(copySafeSkillRoot(agentsSkillsSrc, join(root, ".agents", "skills")).then(() => undefined));
+    }
+    else {
+        console.log(status.warn(t("init.portableSkillsMissing")));
+    }
+    if (skillCopies.length > 0)
+        await Promise.all(skillCopies);
+    // 7. Write hooks (parallel)
+    await Promise.all(Object.entries(HOOK_SCRIPTS).map(async ([name, content]) => {
+        const hookPath = join(root, ".omk/hooks", name);
+        await writeFile(hookPath, content, { mode: 0o755 });
+    }));
+    // 8. Write configs
+    const runtimeScope = localUserRuntime ? "all" : "project";
+    let configTomlContent = getConfigToml({
+        mcpScope: runtimeScope,
+        skillsScope: runtimeScope,
+        hooksScope: runtimeScope,
+    });
+    if (localUserRuntime && initHomeDir) {
+        const globalConfigPath = join(initHomeDir, ".omk", "config.toml");
+        const globalConfig = await readFile(globalConfigPath, "utf-8").catch(() => null);
+        if (globalConfig) {
+            configTomlContent = globalConfig
+                .replace(/^mcp_scope\s*=.*$/gm, `mcp_scope = "${runtimeScope}"`)
+                .replace(/^skills_scope\s*=.*$/gm, `skills_scope = "${runtimeScope}"`)
+                .replace(/^hooks_scope\s*=.*$/gm, `hooks_scope = "${runtimeScope}"`);
+            console.log(style.purple("   📦 Inheriting global .omk/config.toml defaults..."));
+        }
+    }
+    await writeFile(join(root, ".omk/config.toml"), configTomlContent);
+    let kimiConfigContent = KIMI_CONFIG_TOML;
+    if (localUserRuntime && initHomeDir) {
+        const globalKimiConfigPath = join(initHomeDir, ".kimi", "config.toml");
+        const globalKimiConfig = await readFile(globalKimiConfigPath, "utf-8").catch(() => null);
+        if (globalKimiConfig) {
+            kimiConfigContent = globalKimiConfig;
+            console.log(style.purple("   📦 Inheriting global ~/.kimi/config.toml..."));
+        }
+    }
+    await writeFile(join(root, ".omk/kimi.config.toml"), kimiConfigContent);
+    await ensureProjectMcpConfig(join(root, ".omk/mcp.json"), mcpJson, { removeRuntimeManagedOmkProject: true });
+    await writeFile(join(root, ".omk/theme.json"), createThemeJson());
+    await writeFile(join(root, ".omk/runtime-preset.json"), JSON.stringify(OMK_CORE_VERIFIED_PRESET, null, 2) + "\n");
+    await writeFile(join(root, ".omk/runtime-presets.json"), createRuntimePresetsJson());
+    // Project-local server config must not import global definitions by default.
+    const projectMcpPath = join(root, ".kimi", "mcp.json");
+    const globalMcpPath = join(initHomeDir, ".kimi", "mcp.json");
+    const hasGlobalMcp = localUserRuntime && initHomeDir && await pathExists(globalMcpPath);
+    const { DEFAULT_PROJECT_MCP_COMMENT } = await import("./constants.js");
+    const mcpComment = hasGlobalMcp
+        ? "Project-local server config. Global entries are inherited from ~/.kimi/mcp.json at runtime when scope = 'all'."
+        : DEFAULT_PROJECT_MCP_COMMENT;
+    await ensureProjectMcpConfig(projectMcpPath, { _comment: mcpComment, mcpServers: {} }, { removeRuntimeManagedOmkProject: true });
+    await writeFile(join(root, ".omk/lsp.json"), defaultLspConfigJson());
+    // 9. Write memory files (parallel)
+    await Promise.all(Object.entries(MEMORY_FILES).map(([name, content]) => writeFile(join(root, ".omk/memory", name), content)));
+    // 9.5. Copy default snippet templates if they exist
+    const snippetsSrc = join(packageRoot, "templates", "snippets");
+    const snippetsDest = join(root, ".omk", "snippets");
+    if (await pathExists(snippetsSrc)) {
+        console.log(style.purple("   📦 Copying snippet templates..."));
+        await copyTemplateDir(snippetsSrc, snippetsDest);
+    }
+    // 9.6. Copy spec-kit OMK preset template
+    const presetSrc = join(packageRoot, "templates", "spec-kit-omk-preset");
+    const presetDest = join(root, ".omk", "templates", "spec-kit-omk-preset");
+    if (await pathExists(presetSrc)) {
+        console.log(style.purple("   📦 Copying spec-kit OMK preset..."));
+        await copyTemplateDir(presetSrc, presetDest);
+    }
+    // 10. Write project docs (skip if already exist)
+    const docs = {
+        "DESIGN.md": getDesignMd(getOmkVersionSync()),
+        "GEMINI.md": GEMINI_MD,
+        "CLAUDE.md": CLAUDE_MD,
+        "ROADMAP.md": ROADMAP_MD,
+        "SECURITY.md": SECURITY_MD,
+    };
+    for (const [name, content] of Object.entries(docs)) {
+        const docPath = join(root, name);
+        if (await pathExists(docPath)) {
+            console.log(`   ℹ️ ${name} already exists — skipping`);
+        }
+        else {
+            await writeFile(docPath, content);
+        }
+    }
+    console.log(status.success("OMK initialized."));
+    console.log();
+    console.log("Created:");
+    console.log("- AGENTS.md");
+    console.log("- .kimi/AGENTS.md");
+    console.log("- DESIGN.md");
+    console.log("- .omk/agents/root.yaml");
+    console.log("- .omk/agents/roles/");
+    console.log("- .omk/prompts/root.md");
+    console.log("- .omk/config.toml");
+    console.log("- .omk/kimi.config.toml");
+    console.log("- .omk/lsp.json");
+    console.log("- .omk/hooks/");
+    console.log("- .omk/snippets/");
+    console.log("- .kimi/mcp.json");
+    console.log("- .omk/mcp.json");
+    console.log("- .omk/theme.json");
+    console.log("- .omk/runtime-preset.json");
+    console.log("- .omk/runtime-presets.json");
+    console.log("- .kimi/skills/");
+    console.log("- .agents/skills/");
+    console.log("- .omk/memory/");
+    console.log("- .omk/templates/spec-kit-omk-preset/");
+    console.log();
+    console.log("Default behavior:");
+    console.log("- AGENTS.md is loaded into primary provider root prompt.");
+    console.log("- Todo list is required for multi-step work.");
+    console.log("- Subagents are required for non-trivial work.");
+    console.log("- Project skills are auto-discovered from .kimi/skills and .agents/skills.");
+    console.log("- Runtime presets include omk-core-verified, omk-ts-product, omk-worktree-team, and omk-release-guard.");
+    if (localUserRuntime) {
+        console.log("- Local user runtime enabled: global ~/.kimi/mcp.json and ~/.kimi/skills are used at runtime.");
+        console.log("- Personal/global MCP servers and skills are not copied into the project.");
+    }
+    else {
+        console.log("- omk-project is virtual runtime MCP injected; project MCP files are for user-added servers, remote/global MCPs are explicit opt-in.");
+    }
+    console.log("- Built-in tools: SearchWeb, FetchURL (no config required).");
+    console.log(style.gray("  Fresh init does not copy user-global skills or MCP servers into the project."));
+    console.log(style.gray("  Trusted local users can add --local-user --home-dir <~/.kimi/mcp.json> for runtime-only global MCP/skills, or --import-user-skills to copy reviewed personal skills."));
+    await runInitInteractiveSetup(options, initHomeDir);
+    // Warn about environment variable files — OMK prefers config.toml for stability
+    for (const envFile of [".env", ".env.local", ".env.development"]) {
+        if (await pathExists(join(root, envFile))) {
+            console.log(style.orange(`⚠️  Found ${envFile}. OMK recommends using .omk/config.toml instead of environment variable files for stability.`));
+            break;
+        }
+    }
+    // ── Shell integration & PATH check ──
+    const pathCheck = await checkOmkInPath();
+    if (!pathCheck.inPath) {
+        console.log("");
+        console.log(style.orange("⚠️  omk is not in PATH."));
+        console.log(style.gray("   Run one of the following:"));
+        console.log(style.gray("   1) npm install -g @omk/cli"));
+        console.log(style.gray("   2) npm link (for development)"));
+        console.log(style.gray("   3) alias omk='npx -p @omk/cli omk'"));
+    }
+    else {
+        await maybeInstallShellCompletion(root);
+    }
+    console.log("");
+    console.log(style.purpleBold("   Next steps: ") + style.cream("omk doctor → omk chat"));
+}

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

@@ -0,0 +1,9 @@
+import type { InitCommandOptions } from "./types.js";
+export declare function shouldImportUserSkills(options: InitCommandOptions): boolean;
+export declare function explicitLocalUserRuntime(options: InitCommandOptions): boolean | undefined;
+export declare function resolveLocalUserRuntime(options: InitCommandOptions, homeDir: string): Promise<boolean>;
+export declare function askLocalUserRuntimeDuringInit(options: InitCommandOptions, homeDir: string): Promise<boolean>;
+export declare function isInitInteractiveSetupEligible(options: InitCommandOptions): boolean;
+export declare function runMcpServerSelectionDuringInit(options: InitCommandOptions): Promise<void>;
+export declare function runInitInteractiveSetup(options: InitCommandOptions, homeDir: string): Promise<void>;
+export declare function maybeAskForDeepSeekApiKeyDuringInit(options: InitCommandOptions, homeDir: string): Promise<void>;

package/dist/commands/init/interactive.js

@@ -0,0 +1,170 @@
+import { confirm, password } from "@inquirer/prompts";
+import { ExitPromptError } from "@inquirer/core";
+import { getProjectRoot } from "../../util/fs.js";
+import { style, status } from "../../util/theme.js";
+import { t } from "../../util/i18n.js";
+import { maybeAskForGitHubStar } from "../../util/first-run-star.js";
+import { getDeepSeekProviderStatus, setDeepSeekApiKey } from "../../providers/deepseek/deepseek-config.js";
+import { RECOMMENDED_MCP_SERVERS, getDefaultSelections, } from "../../mcp/server-catalog.js";
+import { mcpBulkInstallCommand } from "../mcp.js";
+import { redactSecretishText, isDisabledEnvValue, isEnabledEnvValue } from "./utils.js";
+export function shouldImportUserSkills(options) {
+    const env = options.env ?? process.env;
+    return Boolean(options.importUserSkills) || isEnabledEnvValue(env.OMK_INIT_IMPORT_USER_SKILLS);
+}
+export function explicitLocalUserRuntime(options) {
+    const env = options.env ?? process.env;
+    const profile = options.profile?.trim().toLowerCase() ?? "";
+    if (Boolean(options.localUser)
+        || isEnabledEnvValue(env.OMK_INIT_LOCAL_USER)
+        || ["local", "personal", "trusted-local"].includes(profile)) {
+        return true;
+    }
+    if (isDisabledEnvValue(env.OMK_INIT_LOCAL_USER))
+        return false;
+    return undefined;
+}
+export async function resolveLocalUserRuntime(options, homeDir) {
+    const explicit = explicitLocalUserRuntime(options);
+    if (explicit !== undefined)
+        return explicit;
+    if (!isInitInteractiveSetupEligible(options))
+        return false;
+    return askLocalUserRuntimeDuringInit(options, homeDir);
+}
+export async function askLocalUserRuntimeDuringInit(options, homeDir) {
+    try {
+        const useLocalGlobal = options.promptLocalUserRuntime
+            ? await options.promptLocalUserRuntime({ homeDir })
+            : await confirm({
+                message: "MCP 설정: 기존 로컬 글로벌 ~/.kimi MCP/skills를 그대로 사용할까요? (No = omk-project만 시작하고 여기서 MCP를 추가)",
+                default: false,
+            });
+        if (useLocalGlobal) {
+            console.log(status.ok("Init MCP mode: using local/global ~/.kimi MCP and skills at runtime."));
+        }
+        else {
+            console.log(style.gray("Init MCP mode: project only; start with omk-project and add MCPs here later."));
+        }
+        return useLocalGlobal;
+    }
+    catch (error) {
+        if (error instanceof ExitPromptError)
+            return false;
+        console.log(status.warn(`MCP runtime prompt failed; falling back to project-only mode: ${redactSecretishText(error)}`));
+        return false;
+    }
+}
+export function isInitInteractiveSetupEligible(options) {
+    const env = options.env ?? process.env;
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    if (options.interactiveSetup === false)
+        return false;
+    if (isDisabledEnvValue(env.OMK_INIT_PROMPTS))
+        return false;
+    if (env.CI || env.GITHUB_ACTIONS)
+        return false;
+    return Boolean(stdin.isTTY && stdout.isTTY);
+}
+export async function runMcpServerSelectionDuringInit(options) {
+    if (!isInitInteractiveSetupEligible(options))
+        return;
+    const env = options.env ?? process.env;
+    if (isDisabledEnvValue(env.OMK_INIT_MCP_SERVERS))
+        return;
+    try {
+        const defaultSelections = getDefaultSelections();
+        const choices = RECOMMENDED_MCP_SERVERS.map((server) => ({
+            name: `${server.name} — ${server.description} [${server.category}]`,
+            value: server,
+            checked: defaultSelections.includes(server.name),
+        }));
+        const { checkbox: checkboxPrompt } = await import("@inquirer/prompts");
+        const selected = await checkboxPrompt({
+            message: "Select additional MCP servers to install (Space to toggle, Enter to confirm):",
+            choices,
+        });
+        if (!selected || selected.length === 0) {
+            console.log(style.gray("No additional MCP servers selected."));
+            return;
+        }
+        console.log(style.purple(`   📦 Installing ${selected.length} MCP server(s) in parallel...`));
+        const root = getProjectRoot();
+        const { join } = await import("path");
+        const entries = selected.map((server) => ({
+            name: server.name,
+            command: server.command,
+            args: server.args.map((arg) => arg.replace("${PROJECT_ROOT}", root).replace("${DB_PATH}", join(root, ".omk", "memory", "graph.db"))),
+            env: server.env,
+            startupTimeoutSec: server.startupTimeoutSec,
+        }));
+        const result = await mcpBulkInstallCommand(entries);
+        for (const name of result.installed) {
+            console.log(status.ok(`Installed MCP server: ${name}`));
+        }
+        for (const name of result.skipped) {
+            console.log(style.gray(`Skipped (already exists): ${name}`));
+        }
+        for (const { name, error } of result.failed) {
+            console.log(status.warn(`Failed to install ${name}: ${error}`));
+        }
+    }
+    catch (error) {
+        if (error instanceof ExitPromptError)
+            return;
+        console.log(status.warn(`MCP server selection failed: ${redactSecretishText(error)}`));
+    }
+}
+export async function runInitInteractiveSetup(options, homeDir) {
+    if (!isInitInteractiveSetupEligible(options))
+        return;
+    const { getOmkVersionSync } = await import("../../util/version.js");
+    await maybeAskForGitHubStar({
+        version: getOmkVersionSync(),
+        homeDir,
+        env: options.env,
+        argv: options.argv ?? ["node", "omk", "init"],
+        stdin: options.stdin,
+        stdout: options.stdout,
+        commandName: "init",
+        prompt: options.promptGitHubStar,
+        starRepo: options.starRepo,
+    });
+    await runMcpServerSelectionDuringInit(options);
+    await maybeAskForDeepSeekApiKeyDuringInit(options, homeDir);
+}
+export async function maybeAskForDeepSeekApiKeyDuringInit(options, homeDir) {
+    const env = options.env ?? process.env;
+    if (isDisabledEnvValue(env.OMK_INIT_DEEPSEEK_PROMPT))
+        return;
+    try {
+        const providerOptions = { env, homeDir };
+        const currentStatus = await getDeepSeekProviderStatus(providerOptions);
+        if (currentStatus.apiKeySet) {
+            console.log(style.gray(t("init.deepseekAlreadyConfigured")));
+            return;
+        }
+        const shouldConfigure = options.promptDeepSeekSetup
+            ? await options.promptDeepSeekSetup()
+            : await confirm({
+                message: t("init.deepseekPrompt"),
+                default: false,
+            });
+        if (!shouldConfigure)
+            return;
+        const enteredCredential = options.promptDeepSeekApiKey
+            ? await options.promptDeepSeekApiKey()
+            : await password({
+                message: t("init.deepseekKeyPrompt"),
+                mask: "*",
+            });
+        await setDeepSeekApiKey(enteredCredential, providerOptions);
+        console.log(status.ok(t("init.deepseekSaved")));
+    }
+    catch (error) {
+        if (error instanceof ExitPromptError)
+            return;
+        console.log(status.warn(t("init.deepseekSetupFailed", redactSecretishText(error))));
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { CopyTemplateDirOptions, SkillCopyStats, McpServerDefinition } from "./types.js";
+export declare function copyTemplateDir(src: string, dest: string, options?: CopyTemplateDirOptions): Promise<void>;
+export declare function copySafeSkillRoot(src: string, dest: string): Promise<SkillCopyStats>;
+export declare function createOmkProjectMcpServer(projectRoot: string, options?: {
+    packageRoot?: string;
+    platform?: NodeJS.Platform;
+}): McpServerDefinition;
+export declare function createMcpJson(_projectRoot: string): {
+    mcpServers: Record<string, McpServerDefinition>;
+};
+export declare function ensureProjectMcpConfig(path: string, fallback: Record<string, unknown>, options?: {
+    removeRuntimeManagedOmkProject?: boolean;
+}): Promise<void>;
+export declare function checkOmkInPath(): Promise<{
+    inPath: boolean;
+}>;
+export declare function maybeInstallShellCompletion(_root: string): Promise<void>;

package/dist/commands/init/scaffold.js

@@ -0,0 +1,146 @@
+import { mkdir, copyFile, readdir, writeFile, readFile, rename } from "fs/promises";
+import { dirname, join } from "path";
+import { getCopyEntryKind, skillDirectoryHasSecretContent, shouldSkipSkillCopyEntry, shellQuote, stableNodeExecutable } from "./utils.js";
+export async function copyTemplateDir(src, dest, options = {}) {
+    const entries = await readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(src, entry.name);
+        if (await options.skipEntry?.(srcPath, entry))
+            continue;
+        const destPath = join(dest, entry.name);
+        const kind = await getCopyEntryKind(srcPath, entry);
+        if (kind === "directory") {
+            await mkdir(destPath, { recursive: true });
+            await copyTemplateDir(srcPath, destPath, options);
+        }
+        else if (kind === "file") {
+            await mkdir(dirname(destPath), { recursive: true });
+            await copyFile(srcPath, destPath);
+        }
+    }
+}
+export async function copySafeSkillRoot(src, dest) {
+    const stats = {
+        copied: 0,
+        skippedUnsafe: 0,
+        skippedUnavailable: 0,
+    };
+    const entries = await readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(src, entry.name);
+        if (entry.name.startsWith(".") || shouldSkipSkillCopyEntry(srcPath, entry))
+            continue;
+        const kind = await getCopyEntryKind(srcPath, entry);
+        if (kind !== "directory") {
+            if (entry.isSymbolicLink())
+                stats.skippedUnavailable++;
+            continue;
+        }
+        try {
+            if (await skillDirectoryHasSecretContent(srcPath)) {
+                stats.skippedUnsafe++;
+                continue;
+            }
+            await copyTemplateDir(srcPath, join(dest, entry.name), {
+                skipEntry: shouldSkipSkillCopyEntry,
+            });
+            stats.copied++;
+        }
+        catch {
+            stats.skippedUnavailable++;
+        }
+    }
+    return stats;
+}
+export function createOmkProjectMcpServer(projectRoot, options = {}) {
+    const isWin = (options.platform ?? process.platform) === "win32";
+    const env = { OMK_PROJECT_ROOT: projectRoot };
+    const node = stableNodeExecutable();
+    return {
+        command: isWin ? "omk" : "bash",
+        args: isWin ? ["mcp", "serve", "omk-project"] : ["-lc", createUnixOmkProjectMcpScript(node)],
+        env,
+    };
+}
+function createUnixOmkProjectMcpScript(node) {
+    const quotedNode = shellQuote(node);
+    const resolveRealpathScript = "const fs=require('fs');process.stdout.write(fs.realpathSync(process.argv[1]))";
+    return [
+        "set -e",
+        'omk_bin="$(command -v omk 2>/dev/null || true)"',
+        'if [ -n "$omk_bin" ]; then',
+        `  omk_cli="$(${quotedNode} -e ${shellQuote(resolveRealpathScript)} "$omk_bin" 2>/dev/null || true)"`,
+        '  if [ -n "$omk_cli" ]; then',
+        `    exec ${quotedNode} "$omk_cli" mcp serve omk-project`,
+        "  fi",
+        "fi",
+        'mcp_bin="$(command -v omk-project-mcp 2>/dev/null || true)"',
+        'if [ -n "$mcp_bin" ]; then',
+        `  mcp_js="$(${quotedNode} -e ${shellQuote(resolveRealpathScript)} "$mcp_bin" 2>/dev/null || true)"`,
+        '  if [ -n "$mcp_js" ]; then',
+        `    exec ${quotedNode} "$mcp_js"`,
+        "  fi",
+        "fi",
+        'echo "omk-project MCP server not found; install OMK or rerun omk init" >&2',
+        "exit 127",
+    ].join("\n");
+}
+export function createMcpJson(_projectRoot) {
+    return {
+        mcpServers: {
+        // omk-project is now auto-injected at runtime by injectKimiGlobals.
+        // Project-local .omk/mcp.json only needs to hold user-added MCP servers.
+        },
+    };
+}
+export async function ensureProjectMcpConfig(path, fallback, options = {}) {
+    const existing = await readFile(path, "utf-8").catch(() => null);
+    if (!existing) {
+        await writeFile(path, JSON.stringify(fallback, null, 2) + "\n");
+        return;
+    }
+    try {
+        const parsed = JSON.parse(existing);
+        if (options.removeRuntimeManagedOmkProject && parsed.mcpServers?.["omk-project"]) {
+            delete parsed.mcpServers["omk-project"];
+            await writeFile(path, JSON.stringify(parsed, null, 2) + "\n");
+        }
+    }
+    catch {
+        // Preserve malformed user-owned MCP config rather than overwriting custom entries.
+    }
+}
+export async function checkOmkInPath() {
+    try {
+        const result = await import("../../util/shell.js").then((m) => m.runShell("which", ["omk"], { timeout: 3000 }));
+        return { inPath: !result.failed && result.stdout.trim().length > 0 };
+    }
+    catch {
+        return { inPath: false };
+    }
+}
+export async function maybeInstallShellCompletion(_root) {
+    const bashrc = join(process.env.HOME || process.env.USERPROFILE || "", ".bashrc");
+    const zshrc = join(process.env.HOME || process.env.USERPROFILE || "", ".zshrc");
+    const omkAliasBlock = `# >>> omk shell integration
+export OMK_STAR_PROMPT=1
+export OMK_RENDER_LOGO=1
+# <<< end omk shell integration`;
+    for (const rcFile of [bashrc, zshrc]) {
+        if (!(await import("../../util/fs.js").then((m) => m.pathExists(rcFile))))
+            continue;
+        try {
+            const content = await readFile(rcFile, "utf-8");
+            if (content.includes("omk shell integration"))
+                continue;
+            const tmpRc = rcFile + ".omk.tmp";
+            await writeFile(tmpRc, content.trimEnd() + "\n\n" + omkAliasBlock + "\n");
+            await rename(tmpRc, rcFile);
+            const { status } = await import("../../util/theme.js");
+            console.log(status.ok(`Shell integration added: ${rcFile}`));
+        }
+        catch {
+            // ignore
+        }
+    }
+}