micro-models-agent 0.28.8 → 0.28.17

package/dist/cli/repl.js

@@ -0,0 +1,486 @@
+import * as readline from "readline";
+import { pc } from "../ui/colors";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { Completer, SlashCommandProvider, SessionNameProvider, SubcommandProvider, SkillNameProvider, } from "./completer";
+import { Renderer } from "../ui/renderer";
+import { box } from "../ui/box";
+import { t } from "../i18n/index";
+import { registerAllCommands } from "./repl-commands";
+function readVersion() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, "..", "..", "package.json"),
+        join(here, "..", "package.json"),
+    ];
+    for (const p of candidates) {
+        if (existsSync(p)) {
+            try {
+                const raw = JSON.parse(readFileSync(p, "utf8"));
+                if (raw.version)
+                    return raw.version;
+            }
+            catch {
+                // Broken package.json — fall through to the next candidate
+            }
+        }
+    }
+    return "0.0.0";
+}
+const version = readVersion();
+function formatContextBar(used, limit, compactions, quality) {
+    const pct = Math.min(100, Math.round((used / limit) * 100));
+    const barLen = 20;
+    const filled = Math.round((pct / 100) * barLen);
+    const bar = pc.green("█".repeat(filled)) + pc.dim("░".repeat(barLen - filled));
+    const pctStr = pct >= 75 ? pc.yellow(`${pct}%`) : pc.dim(`${pct}%`);
+    let line = `  ${bar}  ${pctStr}  ${pc.dim(`(${used} / ${limit} tokens)`)}`;
+    if (compactions !== undefined) {
+        line += pc.dim(`  compactions: ${compactions}`);
+    }
+    if (quality !== undefined) {
+        const qColor = quality >= 70 ? pc.green : quality >= 40 ? pc.yellow : pc.red;
+        line += `  ${qColor(`quality: ${quality}%`)}`;
+    }
+    return line;
+}
+export class Repl {
+    completer = new Completer();
+    running = false;
+    agentRunning = false;
+    inputLocked = false;
+    historyPath;
+    history = [];
+    maxHistory = 1000;
+    lastEscTime = 0;
+    doubleEscDelay = 500;
+    configDir;
+    baseDir;
+    noAgentsMd;
+    pendingClipboardImage = null;
+    rl;
+    agent;
+    config;
+    sessionManager;
+    skillsModule;
+    pluginManager;
+    logger;
+    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger) {
+        this.agent = agent;
+        this.config = config;
+        this.sessionManager = sessionManager;
+        this.skillsModule = skillsModule;
+        this.pluginManager = pluginManager;
+        this.logger = logger;
+        this.configDir = configDir || join(homedir(), ".mma");
+        this.baseDir = baseDir || process.cwd();
+        this.noAgentsMd = noAgentsMd === true;
+        this.historyPath = join(homedir(), ".mma", "repl-history");
+        this.loadHistory();
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: pc.cyan("> "),
+            history: this.history,
+            historySize: this.maxHistory,
+            tabSize: 2,
+            completer: (line) => {
+                const [matches, partial] = this.completer.complete(line);
+                if (matches.length > 0)
+                    return [matches, partial];
+                return [[], line];
+            },
+        });
+        registerAllCommands(this);
+        this.setupCompleter();
+        this.setupListeners();
+    }
+    loadHistory() {
+        if (existsSync(this.historyPath)) {
+            try {
+                const raw = readFileSync(this.historyPath, "utf-8");
+                this.history = raw.split("\n").filter(Boolean).slice(-this.maxHistory);
+            }
+            catch {
+                this.history = [];
+            }
+        }
+    }
+    saveHistory() {
+        const allHistory = this.history.slice(-this.maxHistory);
+        writeFileSync(this.historyPath, allHistory.join("\n"), "utf-8");
+    }
+    setupCompleter() {
+        const slashCommands = Array.from(this.commands.keys());
+        this.completer.registerProvider(new SlashCommandProvider(slashCommands));
+        if (this.sessionManager) {
+            this.completer.registerProvider(new SessionNameProvider(() => this.sessionManager.list().map((s) => s.name)));
+        }
+        if (this.skillsModule) {
+            this.completer.registerProvider(new SubcommandProvider("skill", [
+                "list",
+                "loaded",
+                "load",
+                "unload",
+                "search",
+            ]));
+            this.completer.registerProvider(new SkillNameProvider(this.skillsModule));
+        }
+    }
+    setupListeners() {
+        let multiLineBuffer = "";
+        let inMultiLine = false;
+        this.rl.on("line", async (line) => {
+            const trimmed = line.trim();
+            if (this.agentRunning || this.inputLocked) {
+                if (trimmed) {
+                    this.history.push(trimmed);
+                    if (this.history.length > this.maxHistory) {
+                        this.history = this.history.slice(-this.maxHistory);
+                    }
+                }
+                return;
+            }
+            if (trimmed) {
+                this.history.push(trimmed);
+                if (this.history.length > this.maxHistory) {
+                    this.history = this.history.slice(-this.maxHistory);
+                }
+            }
+            if (inMultiLine) {
+                multiLineBuffer += "\n" + line;
+                if (!this.isMultiLineInput(multiLineBuffer)) {
+                    inMultiLine = false;
+                    const fullInput = multiLineBuffer.trim();
+                    multiLineBuffer = "";
+                    if (fullInput) {
+                        if (fullInput.startsWith("/")) {
+                            await this.executeCommand(fullInput);
+                        }
+                        else {
+                            await this.runAgent(fullInput);
+                        }
+                    }
+                    if (this.running) {
+                        this.rl.setPrompt(pc.cyan("> "));
+                        this.rl.prompt();
+                    }
+                }
+                else {
+                    this.rl.setPrompt(pc.cyan("... "));
+                    this.rl.prompt();
+                }
+                return;
+            }
+            if (this.isMultiLineInput(trimmed)) {
+                inMultiLine = true;
+                multiLineBuffer = trimmed;
+                this.rl.setPrompt(pc.cyan("... "));
+                this.rl.prompt();
+                return;
+            }
+            if (!trimmed) {
+                this.rl.prompt();
+                return;
+            }
+            if (trimmed.startsWith("/")) {
+                await this.executeCommand(trimmed);
+            }
+            else {
+                await this.runAgent(trimmed);
+            }
+            if (this.running) {
+                this.rl.prompt();
+            }
+        });
+        this.rl.on("close", () => {
+            this.running = false;
+        });
+        if (process.stdin.isTTY) {
+            readline.emitKeypressEvents(process.stdin);
+            process.stdin.on("keypress", async (str, key) => {
+                if (key.name === "escape") {
+                    // Bun/Node's readline collapses a fast double-Esc into a single
+                    // keypress whose `sequence` contains two ESC bytes ("\x1b\x1b").
+                    // Counting bytes (not events) catches both the collapsed case and
+                    // the case where two separate escape keypresses land in the window.
+                    const escBytes = key.sequence
+                        ? (key.sequence.match(/\x1b/g) || []).length
+                        : 1;
+                    const now = Date.now();
+                    const withinWindow = now - this.lastEscTime < this.doubleEscDelay;
+                    this.lastEscTime = now;
+                    if (escBytes >= 2 || withinWindow) {
+                        this.lastEscTime = 0;
+                        if (this.agentRunning) {
+                            process.stdout.write(pc.yellow(`\n${t("repl.interrupt")}\n`));
+                            this.agent.shutdown();
+                        }
+                    }
+                    return;
+                }
+                if (key.ctrl && key.name === "v" && !this.agentRunning) {
+                    try {
+                        const { readClipboardImage, bufferToDataUrl } = await import("../llm/image-utils");
+                        const clipBuf = await readClipboardImage();
+                        if (clipBuf) {
+                            const { dataUrl } = await bufferToDataUrl(clipBuf);
+                            this.pendingClipboardImage = dataUrl;
+                            const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
+                            console.log(pc.green(`\n${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
+                            this.rl.prompt();
+                        }
+                        else {
+                            console.log(pc.yellow(`\n${t("image.clipboard_empty")}`));
+                            this.rl.prompt();
+                        }
+                    }
+                    catch {
+                        // clipboard read failed — ignore, let terminal paste text normally
+                    }
+                }
+            });
+        }
+        let forceExitTimer = null;
+        process.on("SIGINT", () => {
+            if (this.agentRunning) {
+                console.log(pc.yellow("\n[Ctrl+C] Остановка агента... (ещё раз — принудительно)"));
+                this.agent.shutdown();
+                this.agentRunning = false;
+                if (forceExitTimer)
+                    clearTimeout(forceExitTimer);
+                forceExitTimer = setTimeout(() => process.exit(1), 2000).unref();
+            }
+            else {
+                process.exit(0);
+            }
+        });
+    }
+    isMultiLineInput(line) {
+        if (line.endsWith("\\"))
+            return true;
+        const openBraces = (line.match(/\{/g) || []).length;
+        const closeBraces = (line.match(/\}/g) || []).length;
+        if (openBraces > closeBraces)
+            return true;
+        return false;
+    }
+    async runAgent(input) {
+        if (this.agentRunning)
+            return;
+        this.agentRunning = true;
+        try {
+            if (this.pendingClipboardImage) {
+                const contextManager = this.agent.contextManager;
+                if (contextManager) {
+                    contextManager.addPendingImage({
+                        type: "image_url",
+                        image_url: { url: this.pendingClipboardImage },
+                    });
+                }
+                this.pendingClipboardImage = null;
+            }
+            this.logger?.logREPL("user", input);
+            process.stdout.write("\n" + pc.green(t("repl.agent")));
+            const renderer = new Renderer({
+                spinner: this.config.ui?.spinner ?? true,
+                toolStyle: this.config.ui?.toolStyle ?? "inline",
+            });
+            const result = await this.agent.run(input, (c) => renderer.text(c), (m) => renderer.meta(m), (ev) => {
+                if (ev.type === "start") {
+                    renderer.toolStart(ev.tool, ev.args);
+                }
+                else {
+                    renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error, ev.ctxDelta);
+                }
+            }, (phase) => {
+                if (phase === "thinking") {
+                    renderer.thinkingStart();
+                }
+                else {
+                    renderer.thinkingEnd();
+                }
+            });
+            renderer.flush();
+            process.stdout.write("\n");
+            this.logger?.logREPL(result.success ? "assistant" : "system", result.text?.slice(0, 400) || result.error || "");
+            if (!result.success) {
+                console.error(pc.red(`${t("error.prefix")}${result.error}`));
+            }
+            this.showContextBar(result);
+        }
+        finally {
+            this.agentRunning = false;
+        }
+    }
+    commands = new Map();
+    registerCommand(cmd) {
+        this.commands.set(cmd.name, cmd);
+        if (cmd.aliases) {
+            for (const alias of cmd.aliases) {
+                this.commands.set(alias, cmd);
+            }
+        }
+    }
+    async withExclusiveInput(fn) {
+        this.inputLocked = true;
+        try {
+            await fn();
+        }
+        finally {
+            this.inputLocked = false;
+        }
+    }
+    async executeCommand(input) {
+        const parts = input.split(/\s+/);
+        const name = parts[0].slice(1);
+        const args = parts.slice(1);
+        const cmd = this.commands.get(name);
+        if (!cmd) {
+            console.log(pc.red(t("cli.unknown_cmd", { name })), t("cli.help_hint"));
+            return;
+        }
+        try {
+            await cmd.action(args);
+        }
+        catch (err) {
+            console.error(pc.red(t("error.command_error", {
+                message: err instanceof Error ? err.message : String(err),
+            })));
+        }
+    }
+    showHelp() {
+        const { COMMAND_GROUPS } = require("./repl-commands");
+        const order = ["general", "agent", "session", "skill"];
+        const seen = new Set();
+        for (const groupKey of order) {
+            const cmds = [];
+            for (const [name, cmd] of this.commands) {
+                if (cmd.aliases?.includes(name))
+                    continue;
+                if (seen.has(cmd.name))
+                    continue;
+                const group = COMMAND_GROUPS[cmd.name] ?? "general";
+                if (group !== groupKey)
+                    continue;
+                seen.add(cmd.name);
+                cmds.push(cmd);
+            }
+            if (cmds.length === 0)
+                continue;
+            console.log(pc.bold(t(`repl.group.${groupKey}`)));
+            for (const cmd of cmds) {
+                const aliases = cmd.aliases?.length
+                    ? ` (${pc.dim(cmd.aliases.join(", "))})`
+                    : "";
+                console.log(`  ${pc.cyan("/" + cmd.name)}${aliases}  ${pc.dim(cmd.description)}`);
+                if (cmd.usage) {
+                    console.log(`    ${pc.dim(cmd.usage)}`);
+                }
+            }
+            console.log();
+        }
+    }
+    lastCompactionShown = 0;
+    showContextBar(result) {
+        if (result.contextUsed === undefined ||
+            result.contextLimit === undefined ||
+            result.contextLimit <= 0) {
+            return;
+        }
+        const ui = this.config.ui;
+        if (ui?.showContextStats) {
+            console.log();
+            const ctxLine = formatContextBar(result.contextUsed, result.contextLimit, result.compactionCount, result.contextQuality);
+            console.log(ctxLine);
+            if (result.totalTokens !== undefined && result.totalTokens > 0) {
+                const apiLine = pc.dim(`  API: ${result.promptTokens} prompt + ${result.completionTokens} completion = ${result.totalTokens} total`);
+                console.log(apiLine);
+            }
+        }
+        else if (ui?.showCompaction && result.compactionCount !== undefined) {
+            if (result.compactionCount > this.lastCompactionShown) {
+                this.lastCompactionShown = result.compactionCount;
+                console.log(pc.dim(`\n  ⟳ Context compacted (${result.compactionCount})`));
+            }
+        }
+    }
+    start() {
+        this.running = true;
+        const info = [];
+        const row = (label, value) => {
+            info.push(` ${pc.yellow(label)} ${value}`);
+        };
+        const ctx = this.config.contextWindow;
+        const sysBudget = Math.floor(ctx * this.config.contextBudget.systemPrompt);
+        const resBudget = Math.floor(ctx * this.config.contextBudget.responseReserve);
+        const histBudget = ctx - sysBudget - resBudget;
+        row(t("repl.model"), pc.white(this.config.model));
+        row(t("repl.provider"), `${this.config.provider.type}  →  ${pc.dim(this.config.provider.baseUrl)}`);
+        row(t("repl.context"), `${pc.white(String(ctx))}  ${pc.dim(`(sys:${sysBudget}  res:${resBudget}  hist:${histBudget})`)}`);
+        const si = this.agent.getSystemPromptInfo();
+        row(t("repl.sysprompt_label"), pc.dim(t("repl.sysprompt_size", { used: si.tokenCount, budget: sysBudget })));
+        if (this.skillsModule) {
+            const budget = this.skillsModule.getBudget();
+            row(t("repl.skills_label"), `${pc.white(String(this.skillsModule.getAvailable().length))} available, ${pc.dim(`budget: ${budget.total} tokens`)}`);
+        }
+        if (this.pluginManager) {
+            const plugins = this.pluginManager
+                .getAllPlugins()
+                .filter((p) => !p.isBuiltin);
+            if (plugins.length > 0) {
+                const pluginNames = plugins.map((p) => p.name).join(", ");
+                row(t("repl.plugins_label"), `${pc.white(String(plugins.length))} active  ${pc.dim(`(${pluginNames})`)}`);
+            }
+        }
+        const mcpServers = this.config.mcpServers || {};
+        const enabledServers = Object.entries(mcpServers).filter(([, s]) => s.enabled !== false);
+        if (enabledServers.length > 0) {
+            const names = enabledServers.map(([name]) => name).join(", ");
+            row(t("repl.mcp_label"), `${pc.white(String(enabledServers.length))}  ${pc.dim(`(${names})`)}`);
+        }
+        const cwd = process.cwd();
+        row(t("repl.work_dir"), pc.dim(cwd));
+        if (this.noAgentsMd) {
+            row(t("repl.agents_label"), pc.red(t("repl.disabled")));
+        }
+        else {
+            const agentsMdCandidates = [
+                join(this.baseDir, "AGENTS.md"),
+                join(this.baseDir, ".mma", "AGENTS.md"),
+                join(this.configDir, "AGENTS.md"),
+            ];
+            const foundAgents = agentsMdCandidates.filter((p) => existsSync(p));
+            if (foundAgents.length > 0) {
+                for (const p of foundAgents) {
+                    row(t("repl.agents_label"), pc.dim(p));
+                }
+            }
+            else {
+                row(t("repl.agents_label"), pc.dim(t("repl.not_found")));
+            }
+        }
+        const meta = this.sessionManager?.getActiveMeta();
+        if (meta) {
+            const sessionPath = join(this.configDir, "sessions", meta.id);
+            row(t("repl.session_label"), `${pc.cyan(meta.name)} ${pc.dim(`(${meta.id.slice(0, 12)})`)}  —  ${meta.messageCount} msgs  ${pc.dim(sessionPath)}`);
+        }
+        const headerWidth = Math.max(50, Math.min(96, process.stdout.columns || 96));
+        for (const line of box(info, {
+            title: t("repl.title", { version }),
+            width: headerWidth,
+        })) {
+            console.log(line);
+        }
+        console.log();
+        this.rl.prompt();
+    }
+    stop() {
+        this.running = false;
+        this.saveHistory();
+        this.agent.shutdown();
+        this.rl.close();
+    }
+}

package/dist/cli/security-commands.js

@@ -0,0 +1,166 @@
+import { bootstrap } from "../core/bootstrap";
+import { saveConfig } from "../config/config";
+import { join } from "path";
+import { homedir } from "os";
+import { SECURITY_POLICIES, applySecurityPolicy, getSecurityPolicy, } from "../modules/security/security-policies";
+import { globalAuditNotifier } from "../modules/security/audit-notifier";
+import { t } from "../i18n/index";
+/**
+ * Create security subcommand
+ */
+export function createSecurityCommand(program) {
+    const securityCmd = program
+        .command("security")
+        .description(t("cli.security.description"));
+    // security status - show current security configuration
+    securityCmd
+        .command("status")
+        .description(t("cli.security.status"))
+        .action(async () => {
+        const { config } = await bootstrap();
+        const security = config.security || {};
+        const bash = security.bash || {};
+        const paths = security.paths || {};
+        const network = security.network || {};
+        const contentScan = security.contentScan || {};
+        const rateLimits = security.rateLimits || {};
+        const sessionEncryption = security.sessionEncryption || {};
+        const auditNotifier = security.auditNotifier || {};
+        console.log(t("cli.security.current_policy"));
+        console.log(`  ${t("cli.security.bash_enabled")}: ${bash.blacklist?.length > 0 ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.path_validation")}: ${paths.denied?.length > 0 ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.network_validation")}: ${network.deniedDomains?.length > 0 || network.allowedDomains?.length > 0 ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.content_scanning")}: ${contentScan.enabled ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.max_recursion")}: ${security.maxRecursionDepth ?? 3}`);
+        console.log(`  ${t("cli.security.max_file_ops")}: ${security.maxFileOperations ?? 100}`);
+        console.log(`  ${t("cli.security.rate_limit")}: ${rateLimits.maxRequestsPerMinute ?? 60}/min`);
+        console.log(`  ${t("cli.security.session_encryption")}: ${sessionEncryption.enabled ? t("cli.yes") : t("cli.no")}`);
+        console.log(`  ${t("cli.security.audit_notifier")}: ${auditNotifier.enabled ? t("cli.yes") : t("cli.no")}`);
+    });
+    // security policies - manage security policies
+    securityCmd
+        .command("policies")
+        .description(t("cli.security.policies"))
+        .action(async () => {
+        console.log(t("cli.security.available_policies"));
+        console.log("");
+        for (const [preset, policy] of Object.entries(SECURITY_POLICIES)) {
+            if (preset === 'custom')
+                continue;
+            const marker = " ";
+            console.log(` ${marker}${preset.padEnd(12)}  ${policy.name}`);
+            console.log(`             ${policy.description}`);
+            console.log(`             ${t("cli.security.recommended_for")}: ${policy.recommendedFor.join(", ")}`);
+            console.log("");
+        }
+    });
+    // security set-policy - apply a security policy
+    securityCmd
+        .command("set-policy")
+        .argument("<preset>", t("cli.security.preset"))
+        .description(t("cli.security.set_policy"))
+        .action(async (preset) => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        const validPresets = ['strict', 'balanced', 'permissive'];
+        if (!validPresets.includes(preset)) {
+            console.log(t("cli.security.invalid_preset", { presets: validPresets.join(", ") }));
+            return;
+        }
+        const policy = getSecurityPolicy(preset);
+        const newSecurityConfig = applySecurityPolicy(preset);
+        // Merge with existing config
+        appConfig.security = newSecurityConfig;
+        saveConfig(appConfig, configPath);
+        console.log(t("cli.security.policy_applied", { name: policy.name }));
+        console.log(t("cli.security.policy_description", { description: policy.description }));
+    });
+    // security enable-encryption - enable session file encryption
+    securityCmd
+        .command("enable-encryption")
+        .description(t("cli.security.enable_encryption"))
+        .action(async () => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        appConfig.security = appConfig.security || {};
+        appConfig.security.sessionEncryption = {
+            enabled: true,
+            encryptHistory: true,
+            encryptSessionLog: true,
+        };
+        saveConfig(appConfig, configPath);
+        console.log(t("cli.security.encryption_enabled"));
+    });
+    // security disable-encryption - disable session file encryption
+    securityCmd
+        .command("disable-encryption")
+        .description(t("cli.security.disable_encryption"))
+        .action(async () => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        appConfig.security = appConfig.security || {};
+        appConfig.security.sessionEncryption = {
+            enabled: false,
+            encryptHistory: false,
+            encryptSessionLog: false,
+        };
+        saveConfig(appConfig, configPath);
+        console.log(t("cli.security.encryption_disabled"));
+    });
+    // security enable-audit - enable audit notifications
+    securityCmd
+        .command("enable-audit")
+        .description(t("cli.security.enable_audit"))
+        .action(async () => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        appConfig.security = appConfig.security || {};
+        appConfig.security.auditNotifier = {
+            enabled: true,
+            minSeverity: 'medium',
+            eventTypes: ['security_block', 'bash_command', 'file_operation', 'network_request'],
+            maxRetries: 3,
+            webhookTimeout: 5000,
+        };
+        saveConfig(appConfig, configPath);
+        console.log(t("cli.security.audit_enabled"));
+    });
+    // security disable-audit - disable audit notifications
+    securityCmd
+        .command("disable-audit")
+        .description(t("cli.security.disable_audit"))
+        .action(async () => {
+        const configPath = join(homedir(), ".mma", "config.json");
+        const { config: appConfig } = await bootstrap();
+        appConfig.security = appConfig.security || {};
+        appConfig.security.auditNotifier = {
+            enabled: false,
+            maxRetries: 3,
+            webhookTimeout: 5000,
+        };
+        saveConfig(appConfig, configPath);
+        console.log(t("cli.security.audit_disabled"));
+    });
+    // security audit-stats - show audit notification statistics
+    securityCmd
+        .command("audit-stats")
+        .description(t("cli.security.audit_stats"))
+        .action(async () => {
+        const stats = globalAuditNotifier.getStats();
+        console.log(t("cli.security.audit_stats_title"));
+        console.log(`  ${t("cli.security.total_notifications")}: ${stats.total}`);
+        console.log("");
+        console.log(t("cli.security.by_severity"));
+        console.log(`  ${t("cli.security.low")}: ${stats.bySeverity.low}`);
+        console.log(`  ${t("cli.security.medium")}: ${stats.bySeverity.medium}`);
+        console.log(`  ${t("cli.security.high")}: ${stats.bySeverity.high}`);
+        console.log(`  ${t("cli.security.critical")}: ${stats.bySeverity.critical}`);
+        console.log("");
+        console.log(t("cli.security.by_type"));
+        for (const [type, count] of Object.entries(stats.byType)) {
+            if (count > 0) {
+                console.log(`  ${type}: ${count}`);
+            }
+        }
+    });
+}