@vicoa/opencode 0.1.0

package/dist/plugin/format-utils.js

@@ -0,0 +1,339 @@
+const LANGUAGE_MAP = {
+    py: 'python',
+    js: 'javascript',
+    ts: 'typescript',
+    jsx: 'jsx',
+    tsx: 'tsx',
+    java: 'java',
+    cpp: 'cpp',
+    c: 'c',
+    cs: 'csharp',
+    rb: 'ruby',
+    go: 'go',
+    rs: 'rust',
+    php: 'php',
+    swift: 'swift',
+    kt: 'kotlin',
+    yaml: 'yaml',
+    yml: 'yaml',
+    json: 'json',
+    xml: 'xml',
+    html: 'html',
+    css: 'css',
+    scss: 'scss',
+    sql: 'sql',
+    sh: 'bash',
+    bash: 'bash',
+    md: 'markdown',
+    txt: 'text',
+};
+function truncateText(text, maxLength = 100) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return `${text.slice(0, maxLength)}...`;
+}
+function detectLanguage(filePath) {
+    const extension = filePath.includes('.') ? filePath.split('.').pop() ?? '' : '';
+    return LANGUAGE_MAP[extension] ?? '';
+}
+function getString(input, keys, fallback = '') {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === 'string') {
+            return value;
+        }
+    }
+    return fallback;
+}
+function getBoolean(input, keys, fallback = false) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === 'boolean') {
+            return value;
+        }
+    }
+    return fallback;
+}
+function getArray(input, keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (Array.isArray(value)) {
+            return value;
+        }
+    }
+    return [];
+}
+function formatDiffBlock(oldText, newText) {
+    const diffLines = ['```diff'];
+    if (!oldText && newText) {
+        for (const line of newText.split('\n')) {
+            diffLines.push(`+ ${line}`);
+        }
+    }
+    else if (oldText && !newText) {
+        for (const line of oldText.split('\n')) {
+            diffLines.push(`- ${line}`);
+        }
+    }
+    else {
+        const oldLines = oldText.split('\n');
+        const newLines = newText.split('\n');
+        const commonPrefix = [];
+        const commonSuffix = [];
+        for (let i = 0; i < Math.min(oldLines.length, newLines.length); i += 1) {
+            if (oldLines[i] === newLines[i]) {
+                commonPrefix.push(oldLines[i]);
+            }
+            else {
+                break;
+            }
+        }
+        const oldRemaining = oldLines.slice(commonPrefix.length);
+        const newRemaining = newLines.slice(commonPrefix.length);
+        if (oldRemaining.length && newRemaining.length) {
+            for (let i = 1; i <= Math.min(oldRemaining.length, newRemaining.length); i += 1) {
+                if (oldRemaining[oldRemaining.length - i] === newRemaining[newRemaining.length - i]) {
+                    commonSuffix.unshift(oldRemaining[oldRemaining.length - i]);
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        const changedOld = commonSuffix.length
+            ? oldRemaining.slice(0, oldRemaining.length - commonSuffix.length)
+            : oldRemaining;
+        const changedNew = commonSuffix.length
+            ? newRemaining.slice(0, newRemaining.length - commonSuffix.length)
+            : newRemaining;
+        if ((commonPrefix.length || commonSuffix.length) && (changedOld.length || changedNew.length)) {
+            const contextBefore = commonPrefix.slice(-2);
+            const contextAfter = commonSuffix.slice(0, 2);
+            for (const line of contextBefore) {
+                diffLines.push(`  ${line}`);
+            }
+            for (const line of changedOld) {
+                diffLines.push(`- ${line}`);
+            }
+            for (const line of changedNew) {
+                diffLines.push(`+ ${line}`);
+            }
+            for (const line of contextAfter) {
+                diffLines.push(`  ${line}`);
+            }
+        }
+        else {
+            for (const line of oldLines) {
+                diffLines.push(`- ${line}`);
+            }
+            for (const line of newLines) {
+                diffLines.push(`+ ${line}`);
+            }
+        }
+    }
+    diffLines.push('```');
+    return diffLines;
+}
+export function formatToolUsage(toolName, inputData) {
+    if (toolName.startsWith('mcp__vicoa__')) {
+        return `Using tool: ${toolName}`;
+    }
+    const normalizedTool = toolName.toLowerCase();
+    if (normalizedTool === 'write') {
+        const filePath = getString(inputData, ['file_path', 'filePath', 'path', 'filename'], 'unknown');
+        const content = getString(inputData, ['content', 'text', 'value']);
+        const lang = detectLanguage(filePath);
+        return [`Using tool: Write - \`${filePath}\``, `\`\`\`${lang}`, content, '```']
+            .filter((line) => line.length > 0)
+            .join('\n');
+    }
+    if (normalizedTool === 'read' || normalizedTool === 'notebookread' || normalizedTool === 'notebookedit') {
+        const filePath = getString(inputData, ['file_path', 'filePath', 'path', 'notebook_path'], 'unknown');
+        return `Using tool: ${toolName} - \`${filePath}\``;
+    }
+    if (normalizedTool === 'edit') {
+        const filePath = getString(inputData, ['file_path', 'filePath', 'path'], 'unknown');
+        const oldString = getString(inputData, ['old_string', 'oldString']);
+        const newString = getString(inputData, ['new_string', 'newString']);
+        const replaceAll = getBoolean(inputData, ['replace_all', 'replaceAll']);
+        const diffLines = [`Using tool: **Edit** - \`${filePath}\``];
+        if (replaceAll) {
+            diffLines.push('*Replacing all occurrences*');
+        }
+        diffLines.push('');
+        diffLines.push(...formatDiffBlock(oldString, newString));
+        return diffLines.join('\n');
+    }
+    if (normalizedTool === 'multiedit') {
+        const filePath = getString(inputData, ['file_path', 'filePath', 'path'], 'unknown');
+        const edits = getArray(inputData, ['edits']);
+        const lines = [
+            `Using tool: **MultiEdit** - \`${filePath}\``,
+            `*Making ${edits.length} edit${edits.length === 1 ? '' : 's'}:*`,
+            '',
+        ];
+        edits.forEach((edit, index) => {
+            const editIndex = index + 1;
+            const oldString = typeof edit.old_string === 'string' ? edit.old_string : edit.oldString ?? '';
+            const newString = typeof edit.new_string === 'string' ? edit.new_string : edit.newString ?? '';
+            const replaceAll = Boolean(edit.replace_all ?? edit.replaceAll ?? false);
+            lines.push(replaceAll ? `### Edit ${editIndex} *(replacing all occurrences)*` : `### Edit ${editIndex}`);
+            lines.push('');
+            lines.push(...formatDiffBlock(oldString, newString));
+            lines.push('');
+        });
+        return lines.join('\n');
+    }
+    if (normalizedTool === 'bash') {
+        const command = getString(inputData, ['command', 'cmd']);
+        return `Using tool: Bash - \`${command}\``;
+    }
+    if (normalizedTool === 'grep' || normalizedTool === 'glob') {
+        const pattern = getString(inputData, ['pattern', 'query'], 'unknown');
+        const path = getString(inputData, ['path', 'directory'], 'current directory');
+        return `Using tool: ${toolName} - \`${truncateText(pattern, 50)}\` in ${path}`;
+    }
+    if (normalizedTool === 'list' || normalizedTool === 'ls') {
+        const path = getString(inputData, ['path'], 'unknown');
+        return `Using tool: list - \`${path}\``;
+    }
+    if (normalizedTool === 'patch') {
+        const file = getString(inputData, ['file', 'path'], 'unknown');
+        return `Using tool: patch - \`${file}\``;
+    }
+    if (normalizedTool === 'skill') {
+        const name = getString(inputData, ['name', 'skill'], 'unknown');
+        return `Using tool: skill - \`${name}\``;
+    }
+    if (normalizedTool === 'question') {
+        const text = getString(inputData, ['text', 'question', 'message'], '');
+        return text ? `Asking: ${truncateText(text, 100)}` : 'Using tool: question';
+    }
+    if (normalizedTool === 'lsp') {
+        const command = getString(inputData, ['command', 'method'], 'unknown');
+        const file = getString(inputData, ['file', 'path'], '');
+        return file ? `Using tool: lsp - ${command} on \`${file}\`` : `Using tool: lsp - ${command}`;
+    }
+    if (normalizedTool === 'todowrite') {
+        const todos = getArray(inputData, ['todos']);
+        if (!todos.length) {
+            return 'Using tool: TodoWrite - clearing todo list';
+        }
+        const statusSymbol = {
+            pending: '○',
+            in_progress: '◐',
+            completed: '●',
+        };
+        const lines = ['Using tool: TodoWrite - Todo List', ''];
+        for (const todo of todos) {
+            const status = typeof todo.status === 'string' ? todo.status : 'pending';
+            const content = typeof todo.content === 'string' ? todo.content : '';
+            const symbol = statusSymbol[status] ?? '•';
+            lines.push(`${symbol} ${truncateText(content, 100)}`);
+        }
+        return lines.join('\n');
+    }
+    if (normalizedTool === 'todoread') {
+        return 'Using tool: todoread';
+    }
+    if (normalizedTool === 'task') {
+        const description = getString(inputData, ['description'], 'unknown task');
+        const subagentType = getString(inputData, ['subagent_type', 'subagentType', 'agent'], 'unknown');
+        return `Using tool: Task - ${truncateText(description, 50)} (agent: ${subagentType})`;
+    }
+    if (normalizedTool === 'webfetch') {
+        const url = getString(inputData, ['url'], 'unknown');
+        return `Using tool: WebFetch - \`${truncateText(url, 80)}\``;
+    }
+    if (normalizedTool === 'websearch') {
+        const query = getString(inputData, ['query'], 'unknown');
+        return `Using tool: WebSearch - ${truncateText(query, 80)}`;
+    }
+    if (toolName === 'ListMcpResourcesTool') {
+        return 'Using tool: List MCP Resources';
+    }
+    const defaultKeys = ['file', 'path', 'query', 'content', 'message', 'description', 'name'];
+    for (const key of defaultKeys) {
+        if (typeof inputData[key] === 'string') {
+            return `Using tool: ${toolName} - ${truncateText(String(inputData[key]), 50)}`;
+        }
+    }
+    return `Using tool: ${toolName}`;
+}
+// Most tool outputs don't need truncation - show them in full.
+// Only truncate for tools that tend to produce very large/noisy output.
+const TRUNCATE_OUTPUT_TOOLS = new Set(['']); // set to empty for not to filter message now.
+const TRUNCATE_LIMIT = 500;
+export function formatToolResult(output, toolName) {
+    try {
+        const parsed = JSON.parse(output);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            const keys = Object.keys(parsed).slice(0, 3);
+            const summary = `JSON object with keys: ${keys.join(', ')}`;
+            return keys.length < Object.keys(parsed).length ? `${summary} and ${Object.keys(parsed).length - keys.length} more` : summary;
+        }
+    }
+    catch {
+        // not JSON
+    }
+    // Default: don't truncate tool output unless it's in the truncate list
+    if (toolName && TRUNCATE_OUTPUT_TOOLS.has(toolName.toLowerCase())) {
+        return truncateText(output, TRUNCATE_LIMIT);
+    }
+    return output;
+}
+// Tools whose Result line is noise: either raw file/list content (read-side)
+// or a boilerplate success confirmation like "Edit applied successfully."
+// (write-side).  Only the usage line is shown for these.
+const SUPPRESS_OUTPUT_TOOLS = new Set([
+    'read', 'notebookread', 'list', 'ls', 'glob', 'grep', 'todoread', 'lsp',
+    'write', 'edit', 'multiedit', 'patch', 'notebookedit', 'todowrite',
+]);
+export function shouldSuppressToolOutput(toolName) {
+    return SUPPRESS_OUTPUT_TOOLS.has(toolName.toLowerCase());
+}
+export function formatToolPart(toolPart) {
+    const base = formatToolUsage(toolPart.tool, toolPart.state.input ?? {});
+    if (toolPart.state.status === 'completed') {
+        if (shouldSuppressToolOutput(toolPart.tool)) {
+            return base;
+        }
+        const result = toolPart.state.output ? formatToolResult(toolPart.state.output, toolPart.tool) : '[empty]';
+        // Filter out empty results - just show the tool usage
+        if (result === '[empty]') {
+            return base;
+        }
+        return `${base}\nResult: ${result}`;
+    }
+    if (toolPart.state.status === 'error') {
+        const error = toolPart.state.error ? truncateText(toolPart.state.error, 200) : 'Unknown error';
+        return `${base}\n${error}`;
+    }
+    return base;
+}
+export function formatReasoningPart(part) {
+    if (!part.text) {
+        return '';
+    }
+    return `[Thinking: ${truncateText(part.text, 200)}]`;
+}
+export function formatFilePart(part) {
+    if (part.mime?.startsWith('image/') && part.url) {
+        const altText = part.filename ?? 'image';
+        return `![${altText}](${part.url})`;
+    }
+    const source = part.source?.text?.value ?? '';
+    const path = part.source?.path ?? part.filename ?? part.url ?? 'file';
+    if (source) {
+        const lang = detectLanguage(path);
+        return [`File: \`${path}\``, `\`\`\`${lang}`, source, '```'].join('\n');
+    }
+    return `File: \`${path}\``;
+}
+export function formatPatchPart(part) {
+    if (part.files?.length) {
+        return `Patch updated: ${part.files.join(', ')}`;
+    }
+    return 'Patch updated';
+}

package/dist/plugin/message-poller.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Polls Vicoa backend for user messages and sends them to OpenCode
+ *
+ * This mimics the Claude wrapper's message queue and polling functionality.
+ */
+import type { VicoaClient } from './vicoa-client.js';
+export declare class MessagePoller {
+    private client;
+    private interval;
+    private pollIntervalMs;
+    private onMessage;
+    private log;
+    constructor(client: VicoaClient, onMessage: (content: string) => Promise<void>, logFunc?: (level: string, msg: string) => void, pollIntervalMs?: number);
+    start(): void;
+    stop(): void;
+}

package/dist/plugin/message-poller.js

@@ -0,0 +1,45 @@
+/**
+ * Polls Vicoa backend for user messages and sends them to OpenCode
+ *
+ * This mimics the Claude wrapper's message queue and polling functionality.
+ */
+export class MessagePoller {
+    client;
+    interval = null;
+    pollIntervalMs;
+    onMessage;
+    log;
+    constructor(client, onMessage, logFunc, pollIntervalMs = 1000) {
+        this.client = client;
+        this.onMessage = onMessage;
+        this.pollIntervalMs = pollIntervalMs;
+        this.log = logFunc || ((level, msg) => console.log(`[${level}] ${msg}`));
+    }
+    start() {
+        if (this.interval) {
+            return;
+        }
+        this.log('info', 'Starting message poller');
+        this.interval = setInterval(async () => {
+            try {
+                const messages = await this.client.getPendingMessages();
+                for (const msg of messages) {
+                    if (msg.sender_type === 'USER' && msg.content) {
+                        this.log('debug', `Received user message: ${msg.content.substring(0, 100)}...`);
+                        await this.onMessage(msg.content);
+                    }
+                }
+            }
+            catch (error) {
+                this.log('warn', `Error polling messages: ${error}`);
+            }
+        }, this.pollIntervalMs);
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+            this.log('info', 'Stopped message poller');
+        }
+    }
+}

package/dist/plugin/path-utils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Path utilities for normalizing project paths
+ *
+ * Matches the behavior of Python's vicoa.utils.get_project_path()
+ * to ensure consistent path representation across agents.
+ */
+/**
+ * Format a project path to use ~ for home directory.
+ *
+ * This creates a more readable path representation by replacing the home
+ * directory prefix with ~, consistent with how paths are displayed across
+ * agent instances.
+ *
+ * @param projectPath - The path to format. Can be absolute or relative.
+ * @returns The formatted path with ~ replacing home directory if applicable.
+ *
+ * @example
+ * ```typescript
+ * formatProjectPath("/Users/john/projects/myapp")
+ * // Returns: "~/projects/myapp"
+ *
+ * formatProjectPath("/opt/app")
+ * // Returns: "/opt/app"
+ * ```
+ */
+export declare function formatProjectPath(projectPath: string): string;
+/**
+ * Expand ~ in a path to the full home directory path.
+ *
+ * This is the inverse of formatProjectPath - it converts tilde paths
+ * back to absolute paths for use in file operations.
+ *
+ * @param projectPath - The path to expand (may contain ~)
+ * @returns The absolute path with ~ expanded
+ *
+ * @example
+ * ```typescript
+ * expandProjectPath("~/projects/myapp")
+ * // Returns: "/Users/john/projects/myapp"
+ *
+ * expandProjectPath("/opt/app")
+ * // Returns: "/opt/app"
+ * ```
+ */
+export declare function expandProjectPath(projectPath: string): string;

package/dist/plugin/path-utils.js

@@ -0,0 +1,62 @@
+/**
+ * Path utilities for normalizing project paths
+ *
+ * Matches the behavior of Python's vicoa.utils.get_project_path()
+ * to ensure consistent path representation across agents.
+ */
+import * as os from 'os';
+import * as path from 'path';
+/**
+ * Format a project path to use ~ for home directory.
+ *
+ * This creates a more readable path representation by replacing the home
+ * directory prefix with ~, consistent with how paths are displayed across
+ * agent instances.
+ *
+ * @param projectPath - The path to format. Can be absolute or relative.
+ * @returns The formatted path with ~ replacing home directory if applicable.
+ *
+ * @example
+ * ```typescript
+ * formatProjectPath("/Users/john/projects/myapp")
+ * // Returns: "~/projects/myapp"
+ *
+ * formatProjectPath("/opt/app")
+ * // Returns: "/opt/app"
+ * ```
+ */
+export function formatProjectPath(projectPath) {
+    // Resolve to absolute path first
+    const absolutePath = path.resolve(projectPath);
+    const homeDir = os.homedir();
+    // Replace home directory with tilde
+    if (absolutePath.startsWith(homeDir)) {
+        return '~' + absolutePath.slice(homeDir.length);
+    }
+    return absolutePath;
+}
+/**
+ * Expand ~ in a path to the full home directory path.
+ *
+ * This is the inverse of formatProjectPath - it converts tilde paths
+ * back to absolute paths for use in file operations.
+ *
+ * @param projectPath - The path to expand (may contain ~)
+ * @returns The absolute path with ~ expanded
+ *
+ * @example
+ * ```typescript
+ * expandProjectPath("~/projects/myapp")
+ * // Returns: "/Users/john/projects/myapp"
+ *
+ * expandProjectPath("/opt/app")
+ * // Returns: "/opt/app"
+ * ```
+ */
+export function expandProjectPath(projectPath) {
+    if (projectPath.startsWith('~/') || projectPath === '~') {
+        const homeDir = os.homedir();
+        return path.join(homeDir, projectPath.slice(2));
+    }
+    return path.resolve(projectPath);
+}

package/dist/plugin/permission.d.ts

@@ -0,0 +1,30 @@
+import type { Permission } from '@opencode-ai/sdk';
+/**
+ * Permission option for user selection
+ */
+export type PermissionOption = {
+    label: string;
+    response: 'once' | 'always' | 'reject';
+};
+/**
+ * Default options shown when the permission metadata doesn't supply its own.
+ * Mirrors the three choices Claude Code's own TUI presents.
+ */
+export declare const DEFAULT_PERMISSION_OPTIONS: PermissionOption[];
+/**
+ * Build the option list for a permission request. If the permission's
+ * metadata includes an `options` array we use those labels (mapped to the
+ * standard responses in order); otherwise fall back to the defaults.
+ */
+export declare function buildPermissionOptions(permission: Permission): PermissionOption[];
+/**
+ * Format a permission request for display in Vicoa UI.
+ * Shows the permission type, patterns, and code diff/preview if available.
+ */
+export declare function formatPermissionRequest(permission: Permission, options: PermissionOption[]): string;
+/**
+ * Given a user reply string (from the Vicoa poller) and the options that were
+ * sent for that permission, return the matching OpenCode permission response
+ * value, or null if it doesn't match.
+ */
+export declare function parsePermissionReply(userReply: string, options: PermissionOption[]): 'once' | 'always' | 'reject' | null;

package/dist/plugin/permission.js

@@ -0,0 +1,125 @@
+/**
+ * Default options shown when the permission metadata doesn't supply its own.
+ * Mirrors the three choices Claude Code's own TUI presents.
+ */
+export const DEFAULT_PERMISSION_OPTIONS = [
+    { label: 'Allow', response: 'once' },
+    { label: 'Allow always', response: 'always' },
+    { label: 'Reject', response: 'reject' },
+];
+/**
+ * Build the option list for a permission request. If the permission's
+ * metadata includes an `options` array we use those labels (mapped to the
+ * standard responses in order); otherwise fall back to the defaults.
+ */
+export function buildPermissionOptions(permission) {
+    const meta = permission.metadata;
+    const metaOptions = meta?.options;
+    // If metadata supplies an options array, use those labels but keep standard responses
+    if (Array.isArray(metaOptions) && metaOptions.length > 0) {
+        const responses = ['once', 'always', 'reject'];
+        return metaOptions.slice(0, 3).map((label, i) => ({
+            label: String(label),
+            response: responses[i] ?? 'reject',
+        }));
+    }
+    return DEFAULT_PERMISSION_OPTIONS;
+}
+/**
+ * Format a permission request for display in Vicoa UI.
+ * Shows the permission type, patterns, and code diff/preview if available.
+ */
+export function formatPermissionRequest(permission, options) {
+    // Handle both V1 (type/pattern) and V2 (permission/patterns) SDK structures
+    const permissionType = permission.permission || permission.type || 'unknown';
+    // Extract patterns from either V1 (pattern) or V2 (patterns) format
+    let patterns = [];
+    if (permission.patterns) {
+        patterns = permission.patterns;
+    }
+    else if (permission.pattern) {
+        patterns = Array.isArray(permission.pattern) ? permission.pattern : [permission.pattern];
+    }
+    // Format as: **Type** (`pattern`) - consistent with tool use format
+    let message = '**Permission Required**\n\n';
+    if (patterns.length === 0) {
+        message += `**${permissionType}**`;
+    }
+    else if (patterns.length === 1) {
+        message += `**${permissionType}** (\`${patterns[0]}\`)`;
+    }
+    else {
+        message += `**${permissionType}** (${patterns.length} patterns)\n`;
+        patterns.forEach(p => {
+            message += `  • \`${p}\`\n`;
+        });
+    }
+    // Add code diff or content preview if available in metadata
+    const meta = permission.metadata;
+    if (meta?.input && typeof meta.input === 'object') {
+        const input = meta.input;
+        // For Edit tool - show diff
+        if (permissionType === 'edit' && input.old_string && input.new_string) {
+            const oldStr = String(input.old_string);
+            const newStr = String(input.new_string);
+            message += '\n```diff\n';
+            // Simple diff: show removed and added lines
+            for (const line of oldStr.split('\n')) {
+                message += `- ${line}\n`;
+            }
+            for (const line of newStr.split('\n')) {
+                message += `+ ${line}\n`;
+            }
+            message += '```';
+        }
+        // For Write tool - show content preview
+        else if (permissionType === 'write' && input.content) {
+            const content = String(input.content);
+            const preview = content.length > 500 ? content.slice(0, 500) + '...' : content;
+            message += '\n```\n' + preview + '\n```';
+        }
+        // For Bash tool - show command
+        else if (permissionType === 'bash' && input.command) {
+            message += '\n```bash\n' + input.command + '\n```';
+        }
+    }
+    // Add additional context from metadata if available
+    if (meta?.description && typeof meta.description === 'string') {
+        message += `\n\n${meta.description}`;
+    }
+    // Format options in the same [OPTIONS] envelope the Python wrapper uses,
+    // so the Vicoa UI renders them as actionable buttons/choices.
+    const optionLines = options.map((opt, i) => `${i + 1}. ${opt.label}`);
+    message += `\n\n[OPTIONS]\n${optionLines.join('\n')}\n[/OPTIONS]`;
+    return message;
+}
+/**
+ * Given a user reply string (from the Vicoa poller) and the options that were
+ * sent for that permission, return the matching OpenCode permission response
+ * value, or null if it doesn't match.
+ */
+export function parsePermissionReply(userReply, options) {
+    const trimmed = userReply.trim().toLowerCase();
+    // Try direct label match (case-insensitive)
+    for (const opt of options) {
+        if (opt.label.toLowerCase() === trimmed) {
+            return opt.response;
+        }
+    }
+    // Try numeric match (1, 2, 3)
+    const num = Number.parseInt(trimmed, 10);
+    if (!Number.isNaN(num) && num >= 1 && num <= options.length) {
+        return options[num - 1].response;
+    }
+    // Fallback: look for keywords
+    if (/^(allow|yes|y|ok|approve|1)$/i.test(trimmed)) {
+        return 'once';
+    }
+    if (/^(always|forever|permanent|2)$/i.test(trimmed)) {
+        return 'always';
+    }
+    if (/^(reject|no|n|deny|cancel|3)$/i.test(trimmed)) {
+        return 'reject';
+    }
+    return null;
+}

package/dist/plugin/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared utility functions for the OpenCode Vicoa plugin
+ */
+/**
+ * Helper to log messages using OpenCode's app.log format
+ */
+export declare function log(client: any, level: 'debug' | 'info' | 'warn' | 'error', message: string): void;