micro-models-agent 0.7.10 → 0.9.0

package/dist/modules/user-profile/compressor.js

@@ -0,0 +1,16 @@
+export class ProfileCompressor {
+    compress(info) {
+        const parts = [
+            `OS: ${info.os}`,
+            `Shell: ${info.shell}`,
+            `Platform: ${info.platform}`,
+        ];
+        if (Object.keys(info.preferences).length > 0) {
+            const prefs = Object.entries(info.preferences)
+                .map(([k, v]) => `${k}=${v}`)
+                .join(',');
+            parts.push(`Prefs: ${prefs}`);
+        }
+        return parts.join(', ');
+    }
+}

package/dist/modules/user-profile/index.js

@@ -0,0 +1 @@
+export { UserProfile } from './profile';

package/dist/modules/user-profile/profile.js

@@ -0,0 +1,68 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir, hostname, platform, type } from 'os';
+import { env } from 'process';
+import { ProfileCompressor } from './compressor';
+export class UserProfile {
+    profileDir;
+    info = null;
+    preferences = {};
+    constructor(profileDir) {
+        this.profileDir = profileDir;
+    }
+    collect() {
+        this.info = {
+            platform: platform(),
+            os: `${type()} ${hostname()}`,
+            hostname: hostname(),
+            shell: env.SHELL || env.ComSpec || 'unknown',
+            home: homedir(),
+            nodeVersion: process.version,
+            preferences: { ...this.preferences },
+        };
+        return this.info;
+    }
+    save() {
+        if (!existsSync(this.profileDir)) {
+            mkdirSync(this.profileDir, { recursive: true });
+        }
+        writeFileSync(join(this.profileDir, 'profile.json'), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), 'utf-8');
+    }
+    load() {
+        const path = join(this.profileDir, 'profile.json');
+        if (!existsSync(path))
+            return null;
+        try {
+            const data = JSON.parse(readFileSync(path, 'utf-8'));
+            this.info = {
+                platform: data.platform,
+                os: data.os,
+                hostname: data.hostname,
+                shell: data.shell,
+                home: data.home,
+                nodeVersion: data.nodeVersion,
+                preferences: data.preferences || {},
+            };
+            this.preferences = data.preferences || {};
+            return this.info;
+        }
+        catch {
+            return null;
+        }
+    }
+    getInfo() {
+        return this.info;
+    }
+    setPreference(key, value) {
+        this.preferences[key] = value;
+    }
+    getPreference(key) {
+        return this.preferences[key];
+    }
+    compress() {
+        if (!this.info)
+            this.collect();
+        const compressor = new ProfileCompressor();
+        return compressor.compress(this.info);
+    }
+}

package/dist/tools/approve.js

@@ -0,0 +1,32 @@
+import { t } from "../i18n/index";
+import { askChoice } from "./user-input";
+export const approveTool = {
+    name: "approve",
+    description: "Request user approval for an action. The user picks Yes or No from a menu.",
+    tags: ["core"],
+    interactive: true,
+    parameters: {
+        type: "object",
+        properties: {
+            action: {
+                type: "string",
+                description: "Description of the action requiring approval",
+            },
+        },
+        required: ["action"],
+    },
+    handler: async (ctx, args) => {
+        if (ctx.exitOnComplete) {
+            return { success: false, output: t("tool.interactive_disabled") };
+        }
+        const action = String(args.action || "");
+        const indexes = await askChoice(t("tool.approve_prompt", { action }), [
+            { label: t("tool.approve_yes"), description: t("tool.approve_yes_desc") },
+            { label: t("tool.approve_no"), description: t("tool.approve_no_desc") },
+        ]);
+        if (indexes[0] === 0) {
+            return { success: true, output: t("tool.approved") };
+        }
+        return { success: false, output: t("tool.rejected") };
+    },
+};

package/dist/tools/bash.js

@@ -0,0 +1,80 @@
+import { execSync } from 'child_process';
+import { platform } from 'os';
+import { isCommandAllowed, sanitizeCommandForLog } from '../modules/security/command-validator';
+import { logBashCommand, logSecurityBlock } from '../modules/security/audit-log';
+import { getSessionSecurityConfig } from '../modules/security/session-isolation';
+import { DEFAULT_SECURITY_CONFIG } from '../config/security';
+function adaptCommandForWindows(command) {
+    if (platform() !== 'win32')
+        return command;
+    // Windows mkdir does not support -p flag, but creates intermediate dirs by default
+    const trimmed = command.trim();
+    if (trimmed.startsWith('mkdir -p ')) {
+        return trimmed.replace(/^mkdir -p /, 'mkdir ');
+    }
+    if (trimmed === 'mkdir -p' || trimmed.startsWith('mkdir -p ')) {
+        return trimmed.replace(/mkdir -p/g, 'mkdir');
+    }
+    return command;
+}
+export const bashTool = {
+    name: 'bash',
+    description: 'Execute a shell command and return its output. Use for running tests, build, git, and shell operations.',
+    tags: ['shell', 'code'],
+    parameters: {
+        type: 'object',
+        properties: {
+            command: { type: 'string', description: 'Shell command to execute' },
+            workdir: { type: 'string', description: 'Working directory (default: baseDir)' },
+        },
+        required: ['command'],
+    },
+    handler: async (ctx, args) => {
+        const originalCommand = String(args.command);
+        const command = adaptCommandForWindows(originalCommand);
+        const workdir = args.workdir ? String(args.workdir) : ctx.baseDir;
+        // Get session-specific security config with defaults
+        const appConfig = ctx.config || {};
+        const fullSecurityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(appConfig, ctx.sessionContext)
+            : appConfig.security || DEFAULT_SECURITY_CONFIG;
+        const securityConfig = fullSecurityConfig.bash || DEFAULT_SECURITY_CONFIG.bash;
+        const validation = isCommandAllowed(command, securityConfig);
+        if (!validation.allowed) {
+            // Log security block
+            logSecurityBlock(ctx.sessionId, "bash_command", validation.reason || "Command blocked by security policy", sanitizeCommandForLog(originalCommand));
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Command is not allowed: ${validation.reason}`,
+            };
+        }
+        // Log command execution if enabled
+        if (securityConfig?.logCommands) {
+            logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, // Will be updated after execution
+            `Working directory: ${workdir}`);
+        }
+        try {
+            const output = execSync(command, {
+                cwd: workdir,
+                encoding: 'utf-8',
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: 120_000,
+            });
+            // Update audit log with success
+            if (securityConfig?.logCommands) {
+                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Working directory: ${workdir}, Output length: ${output.length}`);
+            }
+            return { success: true, output: output.trimEnd() };
+        }
+        catch (e) {
+            const stderr = e.stderr?.toString() || '';
+            const stdout = e.stdout?.toString() || '';
+            const errorOutput = stderr || stdout || e.message;
+            // Update audit log with failure
+            if (securityConfig?.logCommands) {
+                logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, `Working directory: ${workdir}, Error: ${errorOutput.slice(0, 100)}`);
+            }
+            return { success: false, output: errorOutput };
+        }
+    },
+};

package/dist/tools/browser.js

@@ -0,0 +1,97 @@
+import { BrowserSession } from '../modules/browser/session';
+import { DEFAULT_BROWSER_CONFIG } from '../modules/browser/types';
+import { t } from '../i18n/index';
+import { join } from 'path';
+let session = null;
+function getSession(ctx) {
+    if (!session) {
+        const cookieDir = join(ctx.baseDir, '.mma', 'browser');
+        session = new BrowserSession({
+            ...DEFAULT_BROWSER_CONFIG,
+            headless: ctx.config.browser?.headless ?? true,
+            maxElements: ctx.config.browser?.maxElements ?? 30,
+            navigationTimeout: ctx.config.browser?.navigationTimeout ?? 15000,
+            viewportWidth: ctx.config.browser?.viewportWidth ?? 1280,
+            viewportHeight: ctx.config.browser?.viewportHeight ?? 720,
+            cookieDir,
+        });
+    }
+    return session;
+}
+export function formatScreenshotForTextModel(snapshot) {
+    return `${t('tool.screenshot_unavailable')}\n\n${snapshot}`;
+}
+export function formatScreenshotResult(snapshot, screenshot, supportsVision) {
+    if (!supportsVision) {
+        return formatScreenshotForTextModel(snapshot);
+    }
+    const base64 = screenshot.toString('base64');
+    return `${snapshot}\n\n[Screenshot: data:image/png;base64,${base64}]`;
+}
+export function createBrowserTool() {
+    return {
+        name: 'browser',
+        tags: ['browser', 'vision'],
+        description: [
+            'Control a headless browser. Navigate pages, click elements, type text, scroll, take screenshots.',
+            'Returns a numbered list of interactive elements — use element numbers as targets for click/type.',
+            'Actions: open (url), click (target), type (target, text), scroll (direction), back, forward, screenshot, snapshot, close, wait (ms).',
+        ].join(' '),
+        parameters: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    enum: ['open', 'click', 'type', 'scroll', 'back', 'forward', 'screenshot', 'snapshot', 'close', 'wait'],
+                    description: 'Browser action to perform',
+                },
+                url: {
+                    type: 'string',
+                    description: 'URL to open (for action "open")',
+                },
+                target: {
+                    type: 'number',
+                    description: 'Element number from snapshot (for action "click" or "type")',
+                },
+                text: {
+                    type: 'string',
+                    description: 'Text to type (for action "type")',
+                },
+                direction: {
+                    type: 'string',
+                    enum: ['up', 'down', 'top', 'bottom'],
+                    description: 'Scroll direction (for action "scroll", default "down")',
+                },
+                ms: {
+                    type: 'number',
+                    description: 'Milliseconds to wait (for action "wait", default 1000)',
+                },
+            },
+            required: ['action'],
+        },
+        handler: async (ctx, args) => {
+            const action = String(args.action || '');
+            if (!action) {
+                return { success: false, output: t('tool.action_required') };
+            }
+            const s = getSession(ctx);
+            const result = await s.execute(action, args);
+            const supportsVision = ctx.config.model.includes('vision') ||
+                ctx.config.model.includes('gpt-4o') ||
+                ctx.config.model.includes('claude');
+            if (result.screenshot) {
+                return {
+                    success: result.success,
+                    output: formatScreenshotResult(result.output, result.screenshot, supportsVision),
+                };
+            }
+            return { success: result.success, output: result.output };
+        },
+    };
+}
+export function closeBrowserSession() {
+    if (session) {
+        session.close().catch(() => { });
+        session = null;
+    }
+}

package/dist/tools/create-dir.js

@@ -0,0 +1,57 @@
+import { mkdirSync, existsSync } from "fs";
+import { resolve, normalize } from "path";
+import { t } from "../i18n/index";
+import { isPathWritable } from "../modules/security/path-validator";
+import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+export const createDirTool = {
+    name: "create_dir",
+    description: "Create a directory (and any intermediate directories).",
+    tags: ["file"],
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "Directory path" },
+        },
+        required: ["path"],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const baseDir = resolve(ctx.baseDir);
+        const resolved = resolve(baseDir, normalize(path));
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        // Check file operations limit
+        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
+        const currentCount = ctx.fileOperationsCount ?? 0;
+        if (currentCount >= maxFileOps) {
+            logSecurityBlock(ctx.sessionId, "file_write", `Maximum file operations (${maxFileOps}) exceeded`, path);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
+            };
+        }
+        // Check path permissions
+        const scopeCheck = isPathWritable(ctx.baseDir, path, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", scopeCheck.reason || "Path not allowed", path);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        if (!existsSync(resolved)) {
+            mkdirSync(resolved, { recursive: true });
+        }
+        // Increment file operations counter
+        ctx.fileOperationsCount = currentCount + 1;
+        // Log directory creation
+        logFileWrite(ctx.sessionId, path, true, "Directory created");
+        ctx.trackCreatedPath?.(path);
+        return { success: true, output: t("file.created", { path }) };
+    },
+};

package/dist/tools/delete-file.js

@@ -0,0 +1,64 @@
+import { unlinkSync, existsSync, statSync, readFileSync } from "fs";
+import { resolve, normalize } from "path";
+import { t } from "../i18n/index";
+import { isPathWritable } from "../modules/security/path-validator";
+import { logFileDelete, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { generateDeleteDiff } from "../ui/diff";
+export const deleteFileTool = {
+    name: "delete_file",
+    description: "Delete a file from the filesystem.",
+    tags: ["file"],
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path" },
+        },
+        required: ["path"],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const baseDir = resolve(ctx.baseDir);
+        const resolved = resolve(baseDir, normalize(path));
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        // Check file operations limit
+        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
+        const currentCount = ctx.fileOperationsCount ?? 0;
+        if (currentCount >= maxFileOps) {
+            logSecurityBlock(ctx.sessionId, "file_delete", `Maximum file operations (${maxFileOps}) exceeded`, path);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
+            };
+        }
+        // Check path permissions
+        const scopeCheck = isPathWritable(ctx.baseDir, path, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_delete", scopeCheck.reason || "Path not allowed", path);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        if (!existsSync(resolved)) {
+            return { success: false, output: t("file.notfound", { path }) };
+        }
+        if (statSync(resolved).isDirectory()) {
+            return { success: false, output: t("file.is_directory", { path }) };
+        }
+        const content = readFileSync(resolved, "utf-8");
+        unlinkSync(resolved);
+        const diff = generateDeleteDiff(content);
+        // Increment file operations counter
+        ctx.fileOperationsCount = currentCount + 1;
+        // Log successful file deletion
+        logFileDelete(ctx.sessionId, path, true);
+        ctx.trackDeletedPath?.(path);
+        return { success: true, output: t("file.deleted", { path }), diff };
+    },
+};

package/dist/tools/edit-file.js

@@ -0,0 +1,78 @@
+import { readFileSync, writeFileSync } from "fs";
+import { resolve, normalize } from "path";
+import { t } from "../i18n/index";
+import { isPathWritable } from "../modules/security/path-validator";
+import { scanContent } from "../modules/security/content-scanner";
+import { logFileWrite, logSecurityBlock } from "../modules/security/audit-log";
+import { getSessionSecurityConfig } from "../modules/security/session-isolation";
+import { generateDiff } from "../ui/diff";
+export const editFileTool = {
+    name: "edit_file",
+    description: "Find and replace text in an existing file. Uses exact string match (not regex).",
+    tags: ["file", "code"],
+    parameters: {
+        type: "object",
+        properties: {
+            path: { type: "string", description: "File path" },
+            old: { type: "string", description: "Text to replace" },
+            new: { type: "string", description: "Replacement text" },
+        },
+        required: ["path", "old", "new"],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const baseDir = resolve(ctx.baseDir);
+        const resolved = resolve(baseDir, normalize(path));
+        // Get session-specific security config
+        const securityConfig = ctx.sessionContext
+            ? getSessionSecurityConfig(ctx.config, ctx.sessionContext)
+            : ctx.config.security;
+        // Check file operations limit
+        const maxFileOps = securityConfig?.maxFileOperations ?? 100;
+        const currentCount = ctx.fileOperationsCount ?? 0;
+        if (currentCount >= maxFileOps) {
+            logSecurityBlock(ctx.sessionId, "file_write", `Maximum file operations (${maxFileOps}) exceeded`, path);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] Maximum file operations (${maxFileOps}) exceeded`,
+            };
+        }
+        // Check path permissions
+        const scopeCheck = isPathWritable(ctx.baseDir, path, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", scopeCheck.reason || "Path not allowed", path);
+            return {
+                success: false,
+                output: t("file.path_not_allowed", {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        const content = readFileSync(resolved, "utf-8");
+        const oldStr = String(args.old);
+        const newStr = String(args.new);
+        if (!content.includes(oldStr)) {
+            return {
+                success: false,
+                output: t("file.string_not_found", { str: oldStr }),
+            };
+        }
+        const updated = content.replace(oldStr, newStr);
+        // Check new content for dangerous patterns
+        const scanResult = scanContent(updated, path, ctx.config.security?.contentScan);
+        if (!scanResult.allowed) {
+            logSecurityBlock(ctx.sessionId, "file_write", scanResult.reason || "Content contains dangerous patterns", path);
+            return {
+                success: false,
+                output: `[SECURITY BLOCKED] ${scanResult.reason}`,
+            };
+        }
+        writeFileSync(resolved, updated, "utf-8");
+        const diff = generateDiff(content, updated);
+        // Increment file operations counter
+        ctx.fileOperationsCount = currentCount + 1;
+        // Log successful file edit
+        logFileWrite(ctx.sessionId, path, true, "File edited");
+        return { success: true, output: t("file.replaced_in", { path }), diff };
+    },
+};

package/dist/tools/executor.js

@@ -0,0 +1,83 @@
+import { t } from "../i18n/index";
+const TOOL_EXECUTION_TIMEOUT_MS = 60000;
+export class ToolExecutor {
+    registry;
+    ctx;
+    pluginManager;
+    constructor(registry, ctx, pluginManager) {
+        this.registry = registry;
+        this.ctx = ctx;
+        this.pluginManager = pluginManager;
+    }
+    async execute(call) {
+        const tool = this.registry.get(call.name);
+        if (!tool) {
+            return {
+                success: false,
+                output: t("tool.unknown", { name: call.name }),
+                toolCallId: call.id,
+            };
+        }
+        for (const plugin of this.pluginManager.getAllPlugins()) {
+            if (plugin.onBeforeTool) {
+                try {
+                    const proceed = await plugin.onBeforeTool(this.ctx, call);
+                    if (!proceed) {
+                        return {
+                            success: false,
+                            output: t("tool.blocked", {
+                                plugin: plugin.constructor?.name || "unknown",
+                            }),
+                            toolCallId: call.id,
+                        };
+                    }
+                }
+                catch (e) {
+                    this.ctx.logger.warn(`Plugin onBeforeTool error: ${e.message}`);
+                }
+            }
+        }
+        let result;
+        try {
+            if (tool.interactive) {
+                // Interactive tools wait for user input — no timeout.
+                result = await tool.handler(this.ctx, call.arguments);
+            }
+            else {
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error(t("tool.timeout", {
+                        name: call.name,
+                        seconds: TOOL_EXECUTION_TIMEOUT_MS / 1000,
+                    }))), TOOL_EXECUTION_TIMEOUT_MS);
+                });
+                result = await Promise.race([
+                    tool.handler(this.ctx, call.arguments),
+                    timeoutPromise,
+                ]);
+            }
+            result.toolCallId = call.id;
+        }
+        catch (e) {
+            result = {
+                success: false,
+                output: `${t("error.prefix")}${e.message}`,
+                toolCallId: call.id,
+            };
+        }
+        for (const plugin of this.pluginManager.getAllPlugins()) {
+            if (plugin.onAfterTool) {
+                try {
+                    await plugin.onAfterTool(this.ctx, call, result);
+                }
+                catch (e) {
+                    this.ctx.logger.warn(`Plugin onAfterTool error: ${e.message}`);
+                }
+            }
+        }
+        this.ctx.logger.debug(`Tool ${call.name}: ${result.success ? "OK" : "FAIL"}`);
+        return result;
+    }
+    getToolDefinitions(tags) {
+        return this.registry.getAllForLLM(tags);
+    }
+}

package/dist/tools/file-info.js

@@ -0,0 +1,46 @@
+import { statSync, existsSync } from 'fs';
+import { resolve, normalize } from 'path';
+import { t } from '../i18n/index';
+import { isPathInScope } from '../modules/security/path-validator';
+export const fileInfoTool = {
+    name: 'file_info',
+    description: 'Get metadata about a file or directory (size, creation date, modification date).',
+    tags: ['file'],
+    parameters: {
+        type: 'object',
+        properties: {
+            path: { type: 'string', description: 'File path' },
+        },
+        required: ['path'],
+    },
+    handler: async (ctx, args) => {
+        const path = String(args.path);
+        const baseDir = resolve(ctx.baseDir);
+        const resolved = resolve(baseDir, normalize(path));
+        // Check path permissions
+        const scopeCheck = isPathInScope(ctx.baseDir, path, ctx.scope, ctx.config.security?.paths);
+        if (!scopeCheck.allowed) {
+            return {
+                success: false,
+                output: t('file.path_not_allowed', {
+                    path: `${path} — ${scopeCheck.reason}`,
+                }),
+            };
+        }
+        if (!existsSync(resolved)) {
+            return { success: false, output: t('file.not_found_short', { path }) };
+        }
+        const stat = statSync(resolved);
+        return {
+            success: true,
+            output: JSON.stringify({
+                path,
+                size: stat.size,
+                isDirectory: stat.isDirectory(),
+                isFile: stat.isFile(),
+                created: stat.birthtime,
+                modified: stat.mtime,
+            }, null, 2),
+        };
+    },
+};

package/dist/tools/filter-tools.js

@@ -0,0 +1,10 @@
+export function filterToolsByTags(tools, toolTags) {
+    if (!toolTags || toolTags.length === 0)
+        return tools;
+    const tagSet = new Set(toolTags);
+    return tools.filter(t => {
+        if (!t.tags || t.tags.length === 0)
+            return false;
+        return t.tags.some(tag => tagSet.has(tag));
+    });
+}

package/dist/tools/glob-tool.js

@@ -0,0 +1,19 @@
+import { globSync } from 'fs';
+import { t } from '../i18n/index';
+export const globTool = {
+    name: 'glob',
+    description: 'Search for files matching a glob pattern. Uses standard glob syntax (e.g., **/*.ts, src/**/*.test.ts).',
+    tags: ['file', 'code', 'research'],
+    parameters: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Glob pattern' },
+        },
+        required: ['pattern'],
+    },
+    handler: async (ctx, args) => {
+        const pattern = String(args.pattern);
+        const results = globSync(pattern, { cwd: ctx.baseDir });
+        return { success: true, output: results.length > 0 ? results.join('\n') : t('file.no_matches') };
+    },
+};