kimaki 0.4.76 → 0.4.78

package/dist/opencode-command.test.js

@@ -0,0 +1,48 @@
+// Regression tests for Windows OpenCode command resolution and spawn args.
+import { describe, expect, test } from 'vitest';
+import { getSpawnCommandAndArgs, selectResolvedCommand, splitCommandLookupOutput, } from './opencode-command.js';
+describe('splitCommandLookupOutput', () => {
+    test('splits windows command lookup output into trimmed lines', () => {
+        expect(splitCommandLookupOutput('C:\\Program Files\\nodejs\\opencode\r\nC:\\Program Files\\nodejs\\opencode.cmd\r\n')).toEqual([
+            'C:\\Program Files\\nodejs\\opencode',
+            'C:\\Program Files\\nodejs\\opencode.cmd',
+        ]);
+    });
+});
+describe('selectResolvedCommand', () => {
+    test('prefers npm cmd shims on windows', () => {
+        expect(selectResolvedCommand({
+            output: 'C:\\Program Files\\nodejs\\opencode\r\nC:\\Program Files\\nodejs\\opencode.cmd\r\n',
+            isWindows: true,
+        })).toBe('C:\\Program Files\\nodejs\\opencode.cmd');
+    });
+    test('keeps first result on non-windows platforms', () => {
+        expect(selectResolvedCommand({
+            output: '/usr/local/bin/opencode\n/opt/homebrew/bin/opencode\n',
+            isWindows: false,
+        })).toBe('/usr/local/bin/opencode');
+    });
+});
+describe('getSpawnCommandAndArgs', () => {
+    test('wraps windows cmd shims through cmd.exe without double-quoting by node', () => {
+        expect(getSpawnCommandAndArgs({
+            resolvedCommand: 'C:\\Program Files\\nodejs\\opencode.cmd',
+            baseArgs: ['serve', '--port', '4096'],
+            platform: 'win32',
+        })).toEqual({
+            command: 'cmd.exe',
+            args: ['/d', '/s', '/c', '"C:\\Program Files\\nodejs\\opencode.cmd"', 'serve', '--port', '4096'],
+            windowsVerbatimArguments: true,
+        });
+    });
+    test('leaves direct executables unchanged on windows', () => {
+        expect(getSpawnCommandAndArgs({
+            resolvedCommand: 'C:\\tools\\opencode.exe',
+            baseArgs: ['serve', '--port', '4096'],
+            platform: 'win32',
+        })).toEqual({
+            command: 'C:\\tools\\opencode.exe',
+            args: ['serve', '--port', '4096'],
+        });
+    });
+});

package/dist/opencode-interrupt-plugin.js

@@ -63,6 +63,8 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
             started: false,
             timer,
             abortAfterStepMessageID: latestAssistantMessageIDBySession.get(sessionID),
+            agent: undefined,
+            model: undefined,
         });
     }
     function markStarted({ messageID }) {
@@ -127,9 +129,19 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                 clearPendingByMessageId({ messageID });
                 return;
             }
+            // Keep the queued user message execution context across abort+resume.
+            // Without this, OpenCode re-resolves model defaults and can ignore
+            // /model session overrides (issue #77).
+            const resumeBody = { parts: [] };
+            if (currentPending.agent) {
+                resumeBody.agent = currentPending.agent;
+            }
+            if (currentPending.model) {
+                resumeBody.model = currentPending.model;
+            }
             await ctx.client.session.promptAsync({
                 path: { id: sessionID },
-                body: { parts: [] },
+                body: resumeBody,
             });
             clearPendingByMessageId({ messageID });
             const nextPending = getNextPendingMessage({ sessionID });
@@ -223,6 +235,12 @@ const interruptOpencodeSessionOnUserMessage = async (ctx) => {
                 sessionID,
                 delayMs: interruptStepTimeoutMs,
             });
+            const pending = pendingByMessageId.get(messageID);
+            if (!pending) {
+                return;
+            }
+            pending.agent = output.message.agent;
+            pending.model = output.message.model;
         },
     };
 };

package/dist/opencode-interrupt-plugin.test.js

@@ -90,11 +90,6 @@ function createChatOutput({ sessionID, messageID, parts, }) {
             sessionID,
             role: 'user',
             time: { created: Date.now() },
-            agent: 'build',
-            model: {
-                providerID: 'deterministic-provider',
-                modelID: 'deterministic-v2',
-            },
         },
         parts: parts || [{ type: 'text', text: 'user message' }],
     };

package/dist/opencode-plugin-loading.e2e.test.js

@@ -4,29 +4,13 @@
 // No Discord infrastructure needed — just the OpenCode server process.
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
-import net from 'node:net';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { test, expect } from 'vitest';
 import { resolveOpencodeCommand } from './opencode.js';
+import { getSpawnCommandAndArgs } from './opencode-command.js';
+import { chooseLockPort } from './test-utils.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-async function getOpenPort() {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.listen(0, () => {
-            const address = server.address();
-            if (address && typeof address === 'object') {
-                server.close(() => {
-                    resolve(address.port);
-                });
-            }
-            else {
-                reject(new Error('Failed to get port'));
-            }
-        });
-        server.on('error', reject);
-    });
-}
 async function waitForHealth({ port, maxAttempts = 30, }) {
     for (let i = 0; i < maxAttempts; i++) {
         try {
@@ -47,12 +31,17 @@ async function waitForHealth({ port, maxAttempts = 30, }) {
 test('opencode server loads plugin without errors', async () => {
     const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e');
     fs.mkdirSync(projectDir, { recursive: true });
-    const port = await getOpenPort();
+    const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' });
     const pluginPath = new URL('../src/opencode-plugin.ts', import.meta.url).href;
     const stderrLines = [];
-    const serverProcess = spawn(resolveOpencodeCommand(), ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'], {
+    const { command, args, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
+        resolvedCommand: resolveOpencodeCommand(),
+        baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
+    });
+    const serverProcess = spawn(command, args, {
         stdio: 'pipe',
         cwd: projectDir,
+        windowsVerbatimArguments,
         env: {
             ...process.env,
             OPENCODE_CONFIG_CONTENT: JSON.stringify({

package/dist/opencode-plugin.js

@@ -267,7 +267,7 @@ const kimakiPlugin = async ({ directory }) => {
                         if (memoryContent) {
                             const condensed = condenseMemoryMd(memoryContent);
                             output.parts.push({
-                                id: crypto.randomUUID(),
+                                id: `prt_${crypto.randomUUID()}`,
                                 sessionID,
                                 messageID,
                                 type: 'text',
@@ -304,7 +304,7 @@ const kimakiPlugin = async ({ directory }) => {
                                 hour12: false,
                             });
                             output.parts.push({
-                                id: crypto.randomUUID(),
+                                id: `prt_${crypto.randomUUID()}`,
                                 sessionID,
                                 messageID,
                                 type: 'text',
@@ -315,7 +315,7 @@ const kimakiPlugin = async ({ directory }) => {
                             // When the user comes back after a long break, remind the model
                             // to save any important context from the previous conversation.
                             output.parts.push({
-                                id: crypto.randomUUID(),
+                                id: `prt_${crypto.randomUUID()}`,
                                 sessionID,
                                 messageID,
                                 type: 'text',
@@ -340,7 +340,7 @@ const kimakiPlugin = async ({ directory }) => {
                             })();
                             sessionGitStates.set(sessionID, gitState);
                             output.parts.push({
-                                id: crypto.randomUUID(),
+                                id: `prt_${crypto.randomUUID()}`,
                                 sessionID,
                                 messageID,
                                 type: 'text',

package/dist/opencode.js

@@ -27,6 +27,7 @@ import * as errore from 'errore';
 import { createLogger, LogPrefix } from './logger.js';
 import { notifyError } from './sentry.js';
 import { DirectoryNotAccessibleError, ServerStartError, ServerNotReadyError, FetchError, } from './errors.js';
+import { ensureKimakiCommandShim, getPathEnvKey, getSpawnCommandAndArgs, prependPathEntry, selectResolvedCommand, } from './opencode-command.js';
 const opencodeLogger = createLogger(LogPrefix.OPENCODE);
 const STARTUP_STDERR_TAIL_LIMIT = 30;
 const STARTUP_STDERR_LINE_MAX_LENGTH = 120;
@@ -96,6 +97,8 @@ function buildStartupTimeoutReason({ maxAttempts, stderrTail, }) {
 let singleServer = null;
 let serverRetryCount = 0;
 const serverLifecycleListeners = new Set();
+let processCleanupHandlersRegistered = false;
+let startingServerProcess = null;
 // Cached SDK clients per directory. Each client has a fixed
 // x-opencode-directory header pointing to its project directory.
 const clientCache = new Map();
@@ -110,6 +113,77 @@ export function subscribeOpencodeServerLifecycle(listener) {
         serverLifecycleListeners.delete(listener);
     };
 }
+function killSingleServerProcessNow({ reason, }) {
+    if (!singleServer) {
+        return;
+    }
+    const serverProcess = singleServer.process;
+    const pid = serverProcess.pid;
+    if (!pid || serverProcess.killed) {
+        return;
+    }
+    const killResult = errore.try({
+        try: () => {
+            serverProcess.kill('SIGTERM');
+        },
+        catch: (error) => {
+            return new Error('Failed to send SIGTERM to opencode server', {
+                cause: error,
+            });
+        },
+    });
+    if (killResult instanceof Error) {
+        opencodeLogger.warn(`[cleanup:${reason}] ${killResult.message} (pid: ${pid}, port: ${singleServer.port})`);
+        return;
+    }
+    opencodeLogger.log(`[cleanup:${reason}] Sent SIGTERM to opencode server (pid: ${pid}, port: ${singleServer.port})`);
+}
+function killStartingServerProcessNow({ reason, }) {
+    const serverProcess = startingServerProcess;
+    if (!serverProcess) {
+        return;
+    }
+    const pid = serverProcess.pid;
+    if (!pid || serverProcess.killed) {
+        return;
+    }
+    const killResult = errore.try({
+        try: () => {
+            serverProcess.kill('SIGTERM');
+        },
+        catch: (error) => {
+            return new Error('Failed to send SIGTERM to starting opencode server', {
+                cause: error,
+            });
+        },
+    });
+    if (killResult instanceof Error) {
+        opencodeLogger.warn(`[cleanup:${reason}] ${killResult.message} (pid: ${pid})`);
+        return;
+    }
+    opencodeLogger.log(`[cleanup:${reason}] Sent SIGTERM to starting opencode server (pid: ${pid})`);
+}
+function ensureProcessCleanupHandlersRegistered() {
+    if (processCleanupHandlersRegistered) {
+        return;
+    }
+    processCleanupHandlersRegistered = true;
+    opencodeLogger.log('Registering process cleanup handlers for opencode server');
+    process.on('exit', () => {
+        killSingleServerProcessNow({ reason: 'process-exit' });
+        killStartingServerProcessNow({ reason: 'process-exit' });
+    });
+    // Fallback for short-lived CLI subcommands that call process.exit without
+    // running discord-bot.ts shutdown handlers.
+    process.on('SIGINT', () => {
+        killSingleServerProcessNow({ reason: 'sigint' });
+        killStartingServerProcessNow({ reason: 'sigint' });
+    });
+    process.on('SIGTERM', () => {
+        killSingleServerProcessNow({ reason: 'sigterm' });
+        killStartingServerProcessNow({ reason: 'sigterm' });
+    });
+}
 // ── Resolve opencode binary ──────────────────────────────────────
 // Resolve the full path to the opencode binary so we can spawn without
 // shell: true. Using shell: true creates an intermediate sh process — when
@@ -123,17 +197,31 @@ export function resolveOpencodeCommand() {
     }
     const envPath = process.env.OPENCODE_PATH;
     if (envPath) {
-        resolvedOpencodeCommand = envPath;
-        return envPath;
+        const resolvedFromEnv = selectResolvedCommand({
+            output: envPath,
+            isWindows: process.platform === 'win32',
+        });
+        if (resolvedFromEnv) {
+            resolvedOpencodeCommand = resolvedFromEnv;
+            return resolvedFromEnv;
+        }
     }
     const isWindows = process.platform === 'win32';
     const whichCmd = isWindows ? 'where' : 'which';
-    const result = errore.tryFn({
+    const result = errore.try({
         try: () => {
-            return execFileSync(whichCmd, ['opencode'], {
+            const commandOutput = execFileSync(whichCmd, ['opencode'], {
                 encoding: 'utf8',
                 timeout: 5000,
-            }).trim().split('\n')[0].trim();
+            });
+            const resolved = selectResolvedCommand({
+                output: commandOutput,
+                isWindows,
+            });
+            if (resolved) {
+                return resolved;
+            }
+            throw new Error('opencode not found in PATH');
         },
         catch: () => new Error('opencode not found in PATH'),
     });
@@ -147,23 +235,6 @@ export function resolveOpencodeCommand() {
     opencodeLogger.log(`Resolved opencode binary: ${result}`);
     return result;
 }
-/**
- * Build the spawn command and args, handling Windows .cmd shims.
- * On Windows, .cmd/.bat files can't be spawned directly without a shell —
- * we wrap them with cmd.exe /d /s /c instead of using shell: true
- * (which creates an intermediate sh process that eats SIGTERM).
- */
-function getSpawnCommandAndArgs(baseArgs) {
-    const resolved = resolveOpencodeCommand();
-    if (process.platform !== 'win32') {
-        return { command: resolved, args: baseArgs };
-    }
-    const lower = resolved.toLowerCase();
-    if (lower.endsWith('.cmd') || lower.endsWith('.bat')) {
-        return { command: 'cmd.exe', args: ['/d', '/s', '/c', `"${resolved}"`, ...baseArgs] };
-    }
-    return { command: resolved, args: baseArgs };
-}
 async function getOpenPort() {
     return new Promise((resolve, reject) => {
         const server = net.createServer();
@@ -235,12 +306,16 @@ async function ensureSingleServer() {
     }
 }
 async function startSingleServer() {
+    ensureProcessCleanupHandlersRegistered();
     const port = await getOpenPort();
     const serveArgs = ['serve', '--port', port.toString()];
     if (store.getState().verboseOpencodeServer) {
         serveArgs.push('--print-logs', '--log-level', 'DEBUG');
     }
-    const { command: spawnCommand, args: spawnArgs } = getSpawnCommandAndArgs(serveArgs);
+    const { command: spawnCommand, args: spawnArgs, windowsVerbatimArguments, } = getSpawnCommandAndArgs({
+        resolvedCommand: resolveOpencodeCommand(),
+        baseArgs: serveArgs,
+    });
     // Server config uses permissive defaults. Per-directory external_directory
     // permissions are set at session creation time via session.create({ permission }).
     // Common directories (tmpdir, ~/.config/opencode, ~/.kimaki) are pre-allowed
@@ -266,9 +341,26 @@ async function startSingleServer() {
         [kimakiDataDir]: 'allow',
         [`${kimakiDataDir}/*`]: 'allow',
     };
+    const kimakiShimDirectory = ensureKimakiCommandShim({
+        dataDir: getDataDir(),
+        execPath: process.execPath,
+        execArgv: process.execArgv,
+        entryScript: process.argv[1] || fileURLToPath(new URL('../bin.js', import.meta.url)),
+    });
+    const pathEnvKey = getPathEnvKey(process.env);
+    const pathEnv = kimakiShimDirectory instanceof Error
+        ? process.env[pathEnvKey]
+        : prependPathEntry({
+            entry: kimakiShimDirectory,
+            existingPath: process.env[pathEnvKey],
+        });
+    if (kimakiShimDirectory instanceof Error) {
+        opencodeLogger.warn(kimakiShimDirectory.message);
+    }
     const serverProcess = spawn(spawnCommand, spawnArgs, {
         stdio: 'pipe',
         detached: false,
+        windowsVerbatimArguments,
         // No project-specific cwd — the server handles all directories via
         // x-opencode-directory header. Use home dir as a neutral working dir.
         cwd: os.homedir(),
@@ -319,8 +411,10 @@ async function startSingleServer() {
             ...(process.env.KIMAKI_SENTRY_DSN && {
                 KIMAKI_SENTRY_DSN: process.env.KIMAKI_SENTRY_DSN,
             }),
+            ...(pathEnv && { [pathEnvKey]: pathEnv }),
         },
     });
+    startingServerProcess = serverProcess;
     // Buffer logs until we know if server started successfully.
     // Once ready, switch to forwarding if --verbose-opencode-server is set.
     const logBuffer = [];
@@ -368,6 +462,9 @@ async function startSingleServer() {
         logBuffer.push(`Failed to start server on port ${port}: ${error}`);
     });
     serverProcess.on('exit', (code, signal) => {
+        if (startingServerProcess === serverProcess) {
+            startingServerProcess = null;
+        }
         opencodeLogger.log(`Opencode server exited with code: ${code}, signal: ${signal}`);
         singleServer = null;
         clientCache.clear();
@@ -405,6 +502,10 @@ async function startSingleServer() {
         startupStderrTail,
     });
     if (waitResult instanceof Error) {
+        killStartingServerProcessNow({ reason: 'startup-failed' });
+        if (startingServerProcess === serverProcess) {
+            startingServerProcess = null;
+        }
         // Dump buffered logs on failure
         opencodeLogger.error(`Server failed to start:`);
         for (const line of logBuffer) {
@@ -426,6 +527,9 @@ async function startSingleServer() {
         port,
         baseUrl: `http://127.0.0.1:${port}`,
     };
+    if (startingServerProcess === serverProcess) {
+        startingServerProcess = null;
+    }
     singleServer = server;
     notifyServerLifecycle({ type: 'started', port });
     return server;
@@ -527,6 +631,20 @@ export function buildSessionPermissions({ directory, originalRepoDirectory, }) {
         .join(os.homedir(), '.kimaki')
         .replaceAll('\\', '/');
     rules.push({ permission: 'external_directory', pattern: kimakiDataDir, action: 'allow' }, { permission: 'external_directory', pattern: `${kimakiDataDir}/*`, action: 'allow' });
+    // Allow opencode tool output artifacts under XDG data so agents can inspect
+    // prior tool outputs without interactive permission prompts.
+    const opencodeToolOutputDir = path
+        .join(os.homedir(), '.local', 'share', 'opencode', 'tool-output')
+        .replaceAll('\\', '/');
+    rules.push({
+        permission: 'external_directory',
+        pattern: opencodeToolOutputDir,
+        action: 'allow',
+    }, {
+        permission: 'external_directory',
+        pattern: `${opencodeToolOutputDir}/*`,
+        action: 'allow',
+    });
     // For worktrees: allow access to the original repository directory
     if (originalRepo) {
         rules.push({ permission: 'external_directory', pattern: originalRepo, action: 'allow' }, { permission: 'external_directory', pattern: `${originalRepo}/*`, action: 'allow' });
@@ -555,20 +673,25 @@ export async function stopOpencodeServer() {
     if (!singleServer) {
         return false;
     }
-    opencodeLogger.log(`Stopping opencode server (pid: ${singleServer.process.pid}, port: ${singleServer.port})`);
-    if (!singleServer.process.killed) {
+    const server = singleServer;
+    opencodeLogger.log(`Stopping opencode server (pid: ${server.process.pid}, port: ${server.port})`);
+    if (!server.process.killed) {
         const killResult = errore.try({
             try: () => {
-                singleServer.process.kill('SIGTERM');
+                server.process.kill('SIGTERM');
             },
             catch: (error) => {
-                return new Error(`Failed to send SIGTERM to opencode server`, { cause: error });
+                return new Error('Failed to send SIGTERM to opencode server', {
+                    cause: error,
+                });
             },
         });
         if (killResult instanceof Error) {
             opencodeLogger.warn(killResult.message);
         }
     }
+    killStartingServerProcessNow({ reason: 'stop-opencode-server' });
+    startingServerProcess = null;
     singleServer = null;
     clientCache.clear();
     serverRetryCount = 0;

package/dist/patch-text-parser.js

@@ -0,0 +1,97 @@
+// Shared apply_patch text parsing utilities.
+// Used by diff-patch-plugin.ts (file path extraction for snapshots) and
+// message-formatting.ts (per-file addition/deletion counts for Discord display).
+//
+// The apply_patch tool uses three path header formats:
+//   *** Add File: path    — new file
+//   *** Update File: path — existing file edit
+//   *** Delete File: path — file removal
+//   *** Move to: path     — rename destination
+//   --- a/path / +++ b/path — unified diff headers (fallback)
+/**
+ * Extract all file paths referenced in a patchText string.
+ * Handles custom apply_patch headers, move targets, and unified diff headers.
+ * Returns deduplicated paths.
+ */
+export function extractPatchFilePaths(patchText) {
+    const custom = [
+        ...patchText.matchAll(/^\*\*\* (?:Add|Update|Delete) File:\s+(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const moved = [
+        ...patchText.matchAll(/^\*\*\* Move to:\s+(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const unified = [
+        ...patchText.matchAll(/^(?:---|\+\+\+) [ab]\/(.+)$/gm),
+    ].map((m) => {
+        return (m[1] ?? '').trim();
+    });
+    const all = [...custom, ...moved, ...unified].filter(Boolean);
+    return all.filter((v, i, a) => {
+        return a.indexOf(v) === i;
+    });
+}
+/**
+ * Parse a patchText string and count additions/deletions per file.
+ * Patch format uses `*** Add File:`, `*** Update File:`, `*** Delete File:` headers,
+ * with diff lines prefixed by `+` (addition) or `-` (deletion) inside `@@` hunks.
+ */
+export function parsePatchFileCounts(patchText) {
+    const counts = new Map();
+    const lines = patchText.split('\n');
+    let currentFile = '';
+    let currentType = '';
+    let inHunk = false;
+    for (const line of lines) {
+        const addMatch = line.match(/^\*\*\* Add File:\s*(.+)/);
+        const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)/);
+        const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+)/);
+        if (addMatch || updateMatch || deleteMatch) {
+            const match = addMatch || updateMatch || deleteMatch;
+            currentFile = (match?.[1] ?? '').trim();
+            currentType = addMatch ? 'add' : updateMatch ? 'update' : 'delete';
+            counts.set(currentFile, { additions: 0, deletions: 0 });
+            inHunk = false;
+            continue;
+        }
+        if (line.startsWith('@@')) {
+            inHunk = true;
+            continue;
+        }
+        if (line.startsWith('*** ')) {
+            inHunk = false;
+            continue;
+        }
+        if (!currentFile) {
+            continue;
+        }
+        const entry = counts.get(currentFile);
+        if (!entry) {
+            continue;
+        }
+        if (currentType === 'add') {
+            // all content lines in Add File are additions
+            if (line.length > 0 && !line.startsWith('*** ')) {
+                entry.additions++;
+            }
+        }
+        else if (currentType === 'delete') {
+            // all content lines in Delete File are deletions
+            if (line.length > 0 && !line.startsWith('*** ')) {
+                entry.deletions++;
+            }
+        }
+        else if (inHunk) {
+            if (line.startsWith('+')) {
+                entry.additions++;
+            }
+            else if (line.startsWith('-')) {
+                entry.deletions++;
+            }
+        }
+    }
+    return counts;
+}

package/dist/platform/components-v2.js

@@ -0,0 +1,20 @@
+// Platform-level Discord Components V2 constants and structural types.
+// Keeps Discord numeric protocol details out of command/render modules.
+export const PLATFORM_COMPONENT_TYPE = {
+    ACTION_ROW: 1,
+    BUTTON: 2,
+    TEXT_DISPLAY: 10,
+    SEPARATOR: 14,
+    CONTAINER: 17,
+};
+export const PLATFORM_BUTTON_STYLE = {
+    PRIMARY: 1,
+    SECONDARY: 2,
+    SUCCESS: 3,
+    DANGER: 4,
+    LINK: 5,
+};
+export const PLATFORM_SEPARATOR_SPACING = {
+    SMALL: 1,
+    LARGE: 2,
+};