micro-models-agent 2.10.0 → 2.12.0

package/dist/cli/onboarding-commands.js

@@ -0,0 +1,126 @@
+// Онбординг-команды REPL: /memory, /meet, /init (чистый диспатч + регистрация).
+import { t } from "../i18n/index";
+import { pc } from "../ui/colors";
+import { MemoryStore } from "../modules/memory/store";
+import { runMeet } from "../modules/onboarding/meet";
+import { runInit } from "../modules/onboarding/init";
+import { globalMemoryDir } from "../config/paths";
+const CATEGORIES = ["conventions", "decisions", "errors", "facts"];
+/** Чистый диспатч `/memory`: возвращает строки, рендерит вызывающий. */
+export function applyMemoryCommand(store, args) {
+    const [sub, ...rest] = args;
+    if (!sub)
+        return renderOverview(store);
+    switch (sub) {
+        case "get": {
+            const key = rest[0];
+            const prefs = store.getPreferences();
+            if (!key || !(key in prefs))
+                return [pc.yellow(t("repl.memory_not_found", { key: key ?? "" }))];
+            return [`${key}=${prefs[key]}`];
+        }
+        case "set": {
+            const [key, ...value] = rest;
+            if (!key || value.length === 0)
+                return [t("repl.memory_usage")];
+            store.setPreference(key, value.join(" "));
+            return [pc.green(t("repl.memory_set", { key, value: value.join(" ") }))];
+        }
+        case "unset": {
+            const key = rest[0];
+            if (!key)
+                return [t("repl.memory_usage")];
+            const ok = store.deletePreference(key);
+            return [ok ? t("repl.memory_unset", { key }) : pc.yellow(t("repl.memory_not_found", { key }))];
+        }
+        case "find": {
+            const query = rest.join(" ");
+            if (!query)
+                return [t("repl.memory_usage")];
+            const hits = store.search(query);
+            return hits.length ? hits.map((h) => `${pc.dim(h.file)}  ${h.match}`) : [t("repl.memory_empty")];
+        }
+        case "forget": {
+            const [category, nRaw] = rest;
+            if (!category || !CATEGORIES.includes(category))
+                return [t("repl.memory_usage")];
+            const n = parseInt(nRaw ?? "0", 10);
+            const ok = n > 0 && store.deleteEntry(category, n);
+            return [
+                ok
+                    ? t("repl.memory_forgotten", { category, n: String(n) })
+                    : pc.yellow(t("repl.memory_entry_not_found", { category, n: String(nRaw ?? n) })),
+            ];
+        }
+        default:
+            return [t("repl.memory_usage")];
+    }
+}
+function renderOverview(store) {
+    const out = [];
+    const prefs = store.getPreferences();
+    out.push(pc.bold(t("repl.memory_prefs")));
+    const entries = Object.entries(prefs);
+    if (entries.length === 0)
+        out.push(pc.dim(t("repl.memory_empty")));
+    for (const [k, v] of entries)
+        out.push(`  ${k} = ${v}`);
+    for (const cat of CATEGORIES) {
+        const all = store.read(cat).split(/\r?\n/);
+        const idxs = all.map((l, i) => (l.startsWith("- ") ? i : -1)).filter((i) => i >= 0);
+        const shown = idxs.slice(-3);
+        if (shown.length === 0)
+            continue;
+        out.push(pc.dim(`[${cat}]`));
+        for (const i of shown)
+            out.push(`  [${idxs.indexOf(i) + 1}] ${all[i]}`);
+    }
+    return out;
+}
+/**
+ * Регистрирует `/memory`, `/meet`, `/init`. `/setup` осознанно НЕ
+ * перерегистрируется: визардом настройки уже владеет `/wizard`
+ * (см. repl-commands) с алиасом `setup` — вторая регистрация продублировала/
+ * перекрыла бы его. `/setup` тем самым переиспользует тот хендлер.
+ */
+export function registerOnboardingCommands(ctx) {
+    const store = () => new MemoryStore(globalMemoryDir());
+    ctx.registerCommand({
+        name: "memory",
+        description: t("repl.memory_usage"),
+        usage: t("repl.memory_usage"),
+        action: async (args) => {
+            for (const l of applyMemoryCommand(store(), args))
+                ctx.output.writeLine(l);
+        },
+    });
+    ctx.registerCommand({
+        name: "meet",
+        description: t("cli.meet"),
+        aliases: ["познакомимся"],
+        usage: t("repl.meet_usage"),
+        action: async (args) => {
+            const sub = args[0];
+            if (sub === "stop" || sub === "end") {
+                if (ctx.toolCtx.onboarding) {
+                    const { exitMeetMode } = await import("../modules/onboarding/mode");
+                    exitMeetMode(ctx);
+                    ctx.output.writeLine(t("repl.meet_stop_done"));
+                }
+                else {
+                    ctx.output.writeLine(t("repl.meet_stop_none"));
+                }
+                return;
+            }
+            await runMeet(ctx);
+        },
+    });
+    ctx.registerCommand({
+        name: "init",
+        description: t("repl.init"),
+        usage: t("repl.init_usage"),
+        action: async () => {
+            await runInit(ctx);
+        },
+    });
+}

package/dist/cli/plugin-commands.js

@@ -2,8 +2,9 @@ import { bootstrap } from "../core/bootstrap";
 import { readMmaVersion } from "../core/version";
 import { t } from "../i18n/index";
 import { getDefaultChannel } from "../output";
+// CLI-группа `mma plugins`: список плагинов.
 /**
- * Create the `mma plugins` subcommand group.
+ * Создаёт группу субкоманд `mma plugins`.
  */
 export function createPluginCommand(program) {
     const pluginsCmd = program.command("plugins").description(t("cli.plugins.description"));

package/dist/cli/relaunch.js

@@ -1,24 +1,27 @@
+// Перезапуск CLI в свежем процессе после визарда настройки.
 import { spawnSync } from "node:child_process";
+import { t } from "../i18n/index";
 import { getDefaultChannel } from "../output";
+import { MMA_ENV } from "../config/env";
 /**
- * Args that relaunch the current CLI in a fresh process: drop the runtime's
- * argv[0] (the bun/node binary) and keep the entry script plus every user arg.
+ * Аргументы для перезапуска текущего CLI в свежем процессе: дропаем argv[0]
+ * рантайма (бинарник bun/node), оставляем входной скрипт и все юзер-аргументы.
  */
 export function relaunchArgs(argv) {
     return argv.slice(1);
 }
 /**
- * Re-exec the current CLI in a brand-new process with inherited stdio, then
- * exit with its status.
+ * Переисполняет текущий CLI в brand-new процессе с inherit stdio и выходит
+ * с его статусом.
  *
- * First-run setup uses this so the wizard and the REPL never share a process:
- * on Bun/Windows the raw-mode `LineEditor` only receives keypresses when it is
- * the FIRST consumer of stdin, and reusing one editor across the
- * wizard → bootstrap → REPL phases leaks prompt/frame state. A fresh process
- * makes the REPL editor the first stdin consumer by construction.
+ * Первый запуск использует это, чтобы визард и REPL не делили процесс: на
+ * Bun/Windows raw-режимный `LineEditor` получает keypress, только будучи ПЕРВЫМ
+ * потребителем stdin, а переиспользование одного редактора через фазы
+ * wizard → bootstrap → REPL протекает состоянием промпта/кадра. Свежий процесс
+ * делает REPL-редактор первым потребителем по построению.
  *
- * `MMA_POST_SETUP=1` is set on the child so a failed config write can never
- * loop the wizard.
+ * `MMA_POST_SETUP=1` ставится ребёнку, чтобы неуспешная запись конфига не могла
+ * зациклить визард.
  */
 export function relaunchCli() {
     const args = relaunchArgs(process.argv);
@@ -27,10 +30,10 @@ export function relaunchCli() {
         process.exit(0);
     const child = spawnSync(process.execPath, args, {
         stdio: "inherit",
-        env: { ...process.env, MMA_POST_SETUP: "1" },
+        env: { ...process.env, [MMA_ENV.POST_SETUP]: "1" },
     });
     if (child.error) {
-        getDefaultChannel().writeLine(`Failed to relaunch the CLI: ${child.error.message}`, "stderr");
+        getDefaultChannel().writeLine(t("cli.relaunch_failed", { message: child.error.message }), "stderr");
         process.exit(1);
     }
     process.exit(child.status ?? 0);

package/dist/cli/repl-commands-lsp.js

@@ -0,0 +1,75 @@
+/**
+ * Команда REPL `/lsp`: вынесена из `repl-commands.ts` (нарезка крупных файлов).
+ */
+import { pc } from "../ui/colors";
+import { t } from "../i18n/index";
+import { errMsg } from "../utils";
+/** Регистрирует `/lsp` (status/restart/check) через handler-map (правило #17). */
+export function registerLspCommands(ctx) {
+    ctx.registerCommand({
+        name: "lsp",
+        description: t("repl.lsp"),
+        usage: t("repl.lsp_usage"),
+        examples: ["/lsp status", "/lsp restart", "/lsp check src/index.ts"],
+        action: async (args) => {
+            // Доступ к LSP-модулю через реестр модулей агента.
+            const lspModule = ctx.agent.getModule("lsp");
+            if (!lspModule) {
+                ctx.output.writeLine(pc.yellow(t("repl.lsp_not_available")));
+                return;
+            }
+            const handlers = {
+                status: () => {
+                    const disabled = lspModule.getDisabledServers();
+                    const failures = lspModule.getFailureCounts();
+                    const config = ctx.config.lsp;
+                    ctx.output.writeLine(pc.bold(t("repl.lsp_status_header")));
+                    ctx.output.writeLine(`${t("repl.lsp_enabled")} ${config?.enabled ? pc.green(t("repl.yes")) : pc.red(t("repl.no"))}`);
+                    if (disabled.length > 0) {
+                        ctx.output.writeLine(pc.yellow(`${t("repl.lsp_disabled_servers")} ${disabled.join(", ")}`));
+                    }
+                    if (failures.size > 0) {
+                        ctx.output.writeLine(pc.dim(t("repl.lsp_failure_counts")));
+                        for (const [server, count] of failures) {
+                            ctx.output.writeLine(pc.dim(`  ${server}: ${count}`));
+                        }
+                    }
+                    if (disabled.length === 0 && failures.size === 0) {
+                        ctx.output.writeLine(pc.green(t("repl.lsp_all_ok")));
+                    }
+                },
+                restart: () => {
+                    ctx.output.writeLine(pc.yellow(t("repl.lsp_restarting")));
+                    lspModule.resetDisabledServers();
+                    ctx.output.writeLine(pc.green(t("repl.lsp_restarted")));
+                },
+                check: async (rest) => {
+                    const path = rest[0];
+                    if (!path) {
+                        ctx.output.writeLine(pc.yellow(t("repl.lsp_check_usage")));
+                        return;
+                    }
+                    ctx.output.writeLine(pc.dim(t("repl.lsp_checking", { path })));
+                    // Запуск тула lsp_check через публичный API агента (не через приватные deps)
+                    try {
+                        const result = await ctx.agent.runTool("lsp_check", { path });
+                        if (result?.output) {
+                            ctx.output.writeLine(result.output);
+                        }
+                    }
+                    catch (e) {
+                        ctx.output.writeLine(pc.red(t("repl.lsp_check_error", { error: errMsg(e) })), "stderr");
+                    }
+                },
+            };
+            const subcommand = args[0] || "status";
+            const handler = handlers[subcommand];
+            if (!handler) {
+                ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "lsp", sub: subcommand })));
+                ctx.output.writeLine(pc.dim(t("repl.lsp_usage")));
+                return;
+            }
+            await handler(args.slice(1));
+        },
+    });
+}

package/dist/cli/repl-commands-skills.js

@@ -0,0 +1,105 @@
+/**
+ * Команда REPL `/skill`: вынесена из `repl-commands.ts` (нарезка крупных файлов).
+ */
+import { pc } from "../ui/colors";
+import { t } from "../i18n/index";
+import { estimateTokens } from "../llm/token-counter";
+/** Регистрирует `/skill` (list/loaded/load/unload/search). Нет модуля скиллов — скип. */
+export function registerSkillCommands(ctx) {
+    if (!ctx.skillsModule)
+        return;
+    const listSkills = () => {
+        const available = ctx.skillsModule.getAvailable();
+        if (available.length === 0) {
+            ctx.output.writeLine(t("repl.no_skills"));
+            return;
+        }
+        ctx.output.writeLine(pc.bold(t("repl.available_skills")));
+        for (const skill of available) {
+            const tokens = estimateTokens(skill.content);
+            const loaded = ctx.skillsModule.getLoaded().some((s) => s.name === skill.name);
+            const marker = loaded ? pc.green(` ${t("repl.loaded")}`) : "";
+            ctx.output.writeLine(`  ${pc.cyan(skill.name)}${marker}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
+        }
+    };
+    const listLoaded = () => {
+        const loaded = ctx.skillsModule.getLoaded();
+        const budget = ctx.skillsModule.getBudget();
+        if (loaded.length === 0) {
+            ctx.output.writeLine(t("repl.no_loaded"));
+            return;
+        }
+        ctx.output.writeLine(pc.bold(t("repl.loaded_skills")));
+        for (const skill of loaded) {
+            const tokens = estimateTokens(skill.content);
+            ctx.output.writeLine(`  ${pc.cyan(skill.name)}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
+        }
+        ctx.output.writeLine(pc.dim(`\n  ${t("repl.budget", { used: budget.used, total: budget.total, remaining: budget.remaining })}`));
+    };
+    const loadSkill = (args) => {
+        const arg = args.join(" ");
+        if (!arg) {
+            ctx.output.writeLine(t("repl.skill_load_usage"));
+            return;
+        }
+        const result = ctx.skillsModule.loadByName(arg);
+        if (result.success) {
+            ctx.output.writeLine(pc.green(result.message));
+        }
+        else {
+            ctx.output.writeLine(pc.red(result.message), "stderr");
+        }
+    };
+    const unloadSkill = (args) => {
+        const arg = args.join(" ");
+        if (!arg) {
+            ctx.output.writeLine(t("repl.skill_unload_usage"));
+            return;
+        }
+        if (ctx.skillsModule.unload(arg)) {
+            ctx.output.writeLine(pc.green(t("repl.skill_unloaded", { name: arg })));
+        }
+        else {
+            ctx.output.writeLine(pc.red(t("repl.skill_not_loaded", { name: arg })), "stderr");
+        }
+    };
+    const searchSkills = (args) => {
+        const arg = args.join(" ");
+        if (!arg) {
+            ctx.output.writeLine(t("repl.skill_search_usage"));
+            return;
+        }
+        const results = ctx.skillsModule.search(arg);
+        if (results.length === 0) {
+            ctx.output.writeLine(t("repl.no_skill_match", { query: arg }));
+            return;
+        }
+        ctx.output.writeLine(pc.bold(t("repl.skills_matching", { query: arg })));
+        for (const skill of results) {
+            const tokens = estimateTokens(skill.content);
+            ctx.output.writeLine(`  ${pc.cyan(skill.name)}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
+        }
+    };
+    const skillHandlers = {
+        list: listSkills,
+        loaded: listLoaded,
+        load: loadSkill,
+        unload: unloadSkill,
+        search: searchSkills,
+    };
+    ctx.registerCommand({
+        name: "skill",
+        description: t("repl.skill"),
+        usage: t("repl.skill_usage"),
+        action: (args) => {
+            const subcmd = args[0];
+            const handler = subcmd ? skillHandlers[subcmd] : skillHandlers.list;
+            if (!handler) {
+                ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "skill", sub: subcmd })));
+                ctx.output.writeLine(t("repl.skill_usage"));
+                return;
+            }
+            handler(args.slice(1));
+        },
+    });
+}