@vicoa/opencode 0.1.0 → 0.1.1

package/README.md

@@ -75,7 +75,7 @@ npm run build
 ```json
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugins": ["file://<path/to/opencode-vicoa>"]
+  "plugins": ["file://<path/to/opencode-vicoa/dist/index.js>"]
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vicoa/opencode",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "OpenCode plugin for using OpenCode anywhere, on any device with Vicoa",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -34,6 +34,7 @@
   ],
   "author": "Vicoa",
   "license": "Apache-2.0",
+  "homepage": "https://vicoa.ai",
   "repository": {
     "type": "git",
     "url": "https://github.com/vicoa-ai/opencode-vicoa.git"

package/dist/commands.d.ts

@@ -1,24 +0,0 @@
-import type { VicoaClient } from './vicoa-client.js';
-export declare const OPENCODE_SLASH_AGENT_TYPE = "opencode";
-export declare const OPENCODE_SLASH_COMMAND_ACTIONS: Record<string, string>;
-export declare const OPENCODE_EXECUTE_COMMAND_KEYS: Record<string, string>;
-/**
- * Execute a TUI command via the OpenCode client.
- */
-export declare function executeTuiCommand(client: any, command: string): Promise<void>;
-export type OpencodeCommandMap = Record<string, {
-    description: string;
-}>;
-export type ParsedSlashCommand = {
-    name: string;
-    rawName: string;
-    arguments: string;
-};
-export declare function parseSlashCommand(input: string): ParsedSlashCommand | null;
-export declare function scanOpencodeCommands(projectDir: string | undefined, homeDir: string): Promise<OpencodeCommandMap>;
-/**
- * Handle slash command execution. Returns true if the command was executed
- * directly (built-in with no arguments), false if it should be submitted as
- * a prompt (built-in with args, custom command, or unknown command).
- */
-export declare function handleSlashCommand(userMessage: string, client: any, currentSessionId?: string, vicoaClient?: VicoaClient): Promise<boolean>;

package/dist/commands.js

@@ -1,228 +0,0 @@
-import path from 'path';
-import * as fs from 'fs/promises';
-import { log } from './plugin/utils.js';
-export const OPENCODE_SLASH_AGENT_TYPE = 'opencode';
-export const OPENCODE_SLASH_COMMAND_ACTIONS = {
-    sessions: 'session.list',
-    resume: 'session.list',
-    continue: 'session.list',
-    new: 'session.new',
-    clear: 'session.new',
-    models: 'model.list',
-    agents: 'agent.list',
-    mcps: 'mcp.list',
-    connect: 'provider.connect',
-    status: 'opencode.status',
-    themes: 'theme.switch',
-    help: 'help.show',
-    exit: 'app.exit',
-    quit: 'app.exit',
-    q: 'app.exit',
-    editor: 'prompt.editor',
-    share: 'session.share',
-    rename: 'session.rename',
-    timeline: 'session.timeline',
-    fork: 'session.fork',
-    compact: 'session.compact',
-    summarize: 'session.compact',
-    unshare: 'session.unshare',
-    undo: 'session.undo',
-    redo: 'session.redo',
-    timestamps: 'session.toggle.timestamps',
-    'toggle-timestamps': 'session.toggle.timestamps',
-    thinking: 'session.toggle.thinking',
-    'toggle-thinking': 'session.toggle.thinking',
-    copy: 'session.copy',
-    export: 'session.export',
-};
-export const OPENCODE_EXECUTE_COMMAND_KEYS = {
-    'session.new': 'session_new',
-    'session.share': 'session_share',
-    'session.interrupt': 'session_interrupt',
-    'session.compact': 'session_compact',
-    'session.page.up': 'messages_page_up',
-    'session.page.down': 'messages_page_down',
-    'session.line.up': 'messages_line_up',
-    'session.line.down': 'messages_line_down',
-    'session.half.page.up': 'messages_half_page_up',
-    'session.half.page.down': 'messages_half_page_down',
-    'session.first': 'messages_first',
-    'session.last': 'messages_last',
-    'agent.cycle': 'agent_cycle',
-};
-/**
- * Execute a TUI command via the OpenCode client.
- */
-export async function executeTuiCommand(client, command) {
-    const executeKey = OPENCODE_EXECUTE_COMMAND_KEYS[command];
-    if (executeKey) {
-        await client.tui.executeCommand({ body: { command: executeKey } });
-        return;
-    }
-    await client.tui.publish({
-        body: {
-            type: 'tui.command.execute',
-            properties: { command },
-        },
-    });
-}
-export function parseSlashCommand(input) {
-    const trimmed = input.trim();
-    if (!trimmed.startsWith('/')) {
-        return null;
-    }
-    const body = trimmed.slice(1).trim();
-    if (!body) {
-        return null;
-    }
-    const [rawName, ...rest] = body.split(/\s+/);
-    if (!rawName) {
-        return null;
-    }
-    return {
-        rawName,
-        name: rawName.toLowerCase(),
-        arguments: rest.join(' ').trim(),
-    };
-}
-async function pathExists(target) {
-    try {
-        await fs.stat(target);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function walkMarkdownFiles(root) {
-    const results = [];
-    if (!(await pathExists(root))) {
-        return results;
-    }
-    const entries = await fs.readdir(root, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(root, entry.name);
-        if (entry.isDirectory()) {
-            results.push(...(await walkMarkdownFiles(fullPath)));
-        }
-        else if (entry.isFile() && entry.name.toLowerCase().endsWith('.md')) {
-            results.push(fullPath);
-        }
-    }
-    return results;
-}
-function getOpencodeCommandRoots(projectDir, homeDir) {
-    const roots = new Set();
-    if (process.env.OPENCODE_CONFIG_DIR) {
-        roots.add(process.env.OPENCODE_CONFIG_DIR);
-    }
-    if (process.env.XDG_CONFIG_HOME) {
-        roots.add(path.join(process.env.XDG_CONFIG_HOME, 'opencode'));
-    }
-    roots.add(path.join(homeDir, '.config', 'opencode'));
-    if (process.platform === 'win32') {
-        const appData = process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
-        roots.add(path.join(appData, 'opencode'));
-    }
-    // ~/.opencode fallback (all platforms).
-    roots.add(path.join(homeDir, '.opencode'));
-    // Per-project override.
-    if (projectDir) {
-        roots.add(path.join(projectDir, '.opencode'));
-    }
-    return Array.from(roots);
-}
-function parseCommandDescription(content, fallbackName) {
-    const lines = content.split('\n');
-    let description = '';
-    if (lines.length > 0 && lines[0].trim() === '---') {
-        for (let i = 1; i < lines.length; i += 1) {
-            const line = lines[i].trim();
-            if (line === '---') {
-                break;
-            }
-            const [key, value] = line.split(':', 2).map((item) => item?.trim());
-            if (key?.toLowerCase() === 'description' && value) {
-                description = value.replace(/^['"]|['"]$/g, '').trim();
-                break;
-            }
-        }
-    }
-    if (!description) {
-        for (const line of lines) {
-            const stripped = line.trim();
-            if (!stripped) {
-                continue;
-            }
-            description = stripped.startsWith('#') ? stripped.replace(/^#+/, '').trim() : stripped;
-            break;
-        }
-    }
-    return description || `Custom command: ${fallbackName}`;
-}
-export async function scanOpencodeCommands(projectDir, homeDir) {
-    const commands = {};
-    const roots = getOpencodeCommandRoots(projectDir, homeDir);
-    for (const root of roots) {
-        const commandRoot = path.join(root, 'commands');
-        const files = await walkMarkdownFiles(commandRoot);
-        for (const filePath of files) {
-            const relativePath = path.relative(commandRoot, filePath);
-            const normalized = relativePath.split(path.sep).join('/');
-            const commandName = normalized.replace(/\.md$/i, '');
-            if (!commandName) {
-                continue;
-            }
-            try {
-                const content = await fs.readFile(filePath, 'utf-8');
-                const description = parseCommandDescription(content, commandName);
-                commands[commandName] = { description };
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    return commands;
-}
-/**
- * Handle slash command execution. Returns true if the command was executed
- * directly (built-in with no arguments), false if it should be submitted as
- * a prompt (built-in with args, custom command, or unknown command).
- */
-export async function handleSlashCommand(userMessage, client, currentSessionId, vicoaClient) {
-    const parsed = parseSlashCommand(userMessage);
-    if (!parsed) {
-        return false;
-    }
-    const action = OPENCODE_SLASH_COMMAND_ACTIONS[parsed.name];
-    // Built-in command with no arguments — use the direct TUI action shortcut.
-    if (action && !parsed.arguments) {
-        // Special handling for /share command: call the API directly to get the URL
-        if (parsed.name === 'share' && currentSessionId && vicoaClient) {
-            try {
-                const { data: session } = await client.session.share({
-                    path: { id: currentSessionId },
-                });
-                if (session?.share?.url) {
-                    await vicoaClient.sendMessage(`Share url: ${session.share.url}`);
-                    log(client, 'info', `[Vicoa] Shared session and sent URL to UI: ${session.share.url}`);
-                }
-                else {
-                    log(client, 'warn', '[Vicoa] Session shared but no URL in response');
-                }
-                return true;
-            }
-            catch (error) {
-                log(client, 'warn', `[Vicoa] Failed to share session: ${error}`);
-                // Fall back to TUI command if API call fails
-            }
-        }
-        await executeTuiCommand(client, action);
-        log(client, 'info', `[Vicoa] Executed slash command: /${parsed.rawName}`);
-        return true;
-    }
-    // Built-in with arguments, or a custom command — fall through so the raw
-    // slash command text is submitted as a prompt (OpenCode parses args natively).
-    return false;
-}

package/dist/credentials.d.ts

@@ -1,27 +0,0 @@
-/**
- * Credentials loader for Vicoa
- *
- * Reads API key from ~/.vicoa/credentials.json (same as Vicoa CLI)
- */
-export interface Credentials {
-    write_key?: string;
-}
-/**
- * Get path to Vicoa credentials file
- */
-export declare function getCredentialsPath(): string;
-/**
- * Load Vicoa API key from credentials file
- *
- * Returns the API key from ~/.vicoa/credentials.json if it exists,
- * otherwise returns null.
- */
-export declare function loadApiKey(): string | null;
-/**
- * Get Vicoa API key from environment or credentials file
- *
- * Priority:
- * 1. VICOA_API_KEY environment variable
- * 2. ~/.vicoa/credentials.json (write_key)
- */
-export declare function getApiKey(): string | null;

package/dist/credentials.js

@@ -1,56 +0,0 @@
-/**
- * Credentials loader for Vicoa
- *
- * Reads API key from ~/.vicoa/credentials.json (same as Vicoa CLI)
- */
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-/**
- * Get path to Vicoa credentials file
- */
-export function getCredentialsPath() {
-    return path.join(os.homedir(), '.vicoa', 'credentials.json');
-}
-/**
- * Load Vicoa API key from credentials file
- *
- * Returns the API key from ~/.vicoa/credentials.json if it exists,
- * otherwise returns null.
- */
-export function loadApiKey() {
-    const credentialsPath = getCredentialsPath();
-    // Check if file exists
-    if (!fs.existsSync(credentialsPath)) {
-        return null;
-    }
-    try {
-        const data = fs.readFileSync(credentialsPath, 'utf-8');
-        const credentials = JSON.parse(data);
-        const apiKey = credentials.write_key;
-        if (apiKey && typeof apiKey === 'string' && apiKey.trim().length > 0) {
-            return apiKey.trim();
-        }
-        return null;
-    }
-    catch (error) {
-        console.error(`[Vicoa] Error reading credentials file: ${error}`);
-        return null;
-    }
-}
-/**
- * Get Vicoa API key from environment or credentials file
- *
- * Priority:
- * 1. VICOA_API_KEY environment variable
- * 2. ~/.vicoa/credentials.json (write_key)
- */
-export function getApiKey() {
-    // Check environment variable first
-    const envKey = process.env.VICOA_API_KEY;
-    if (envKey && envKey.trim().length > 0) {
-        return envKey.trim();
-    }
-    // Fall back to credentials file
-    return loadApiKey();
-}

package/dist/format-utils.d.ts

@@ -1,10 +0,0 @@
-import type { FilePart, PatchPart, ReasoningPart, ToolPart } from '@opencode-ai/sdk';
-type ToolInput = Record<string, unknown>;
-export declare function formatToolUsage(toolName: string, inputData: ToolInput): string;
-export declare function formatToolResult(output: string, toolName?: string): string;
-export declare function shouldSuppressToolOutput(toolName: string): boolean;
-export declare function formatToolPart(toolPart: ToolPart): string;
-export declare function formatReasoningPart(part: ReasoningPart): string;
-export declare function formatFilePart(part: FilePart): string;
-export declare function formatPatchPart(part: PatchPart): string;
-export {};

package/dist/format-utils.js

@@ -1,335 +0,0 @@
-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]';
-        return `${base}\nResult: ${result}`;
-    }
-    if (toolPart.state.status === 'error') {
-        const error = toolPart.state.error ? truncateText(toolPart.state.error, 200) : 'Unknown error';
-        return `${base}\nResult: Error - ${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/message-poller.d.ts

@@ -1,16 +0,0 @@
-/**
- * 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/message-poller.js

@@ -1,45 +0,0 @@
-/**
- * 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/file-sync.d.ts

@@ -1,5 +0,0 @@
-import type { VicoaClient } from './vicoa-client.js';
-export declare function syncProjectFiles(vicoaClient: VicoaClient, projectPath: string): Promise<void>;
-/**
- * Sync project files to Vicoa backend for @ mentions
- */

package/dist/plugin/file-sync.js

@@ -1,187 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { formatProjectPath } from './path-utils.js';
-// Common patterns to always exclude (matching Python version)
-const DEFAULT_EXCLUDE_PATTERNS = [
-    '.git/',
-    '.pytest_cache/',
-    '.dart_tool/',
-    '.ruff_cache/',
-    '.mypy_cache/',
-    '__pycache__/',
-    'node_modules/',
-    '.venv/',
-    'venv/',
-    '.tox/',
-    '.eggs/',
-    '*.egg-info/',
-    'dist/',
-    'build/',
-    'target/', // Rust build output
-    '.next/', // Next.js
-    '.nuxt/', // Nuxt
-    'coverage/',
-    '.coverage',
-    '.nyc_output/',
-    '*.pyc',
-    '*.pyo',
-    '*.pyd',
-];
-// Extract directory names from exclude patterns
-function getExcludedDirNames() {
-    const excluded = new Set();
-    for (const pattern of DEFAULT_EXCLUDE_PATTERNS) {
-        // Skip file patterns (contain wildcards)
-        if (pattern.includes('*')) {
-            continue;
-        }
-        // Strip trailing slashes and add to set
-        const dirName = pattern.replace(/\/$/, '');
-        if (dirName) {
-            excluded.add(dirName);
-        }
-    }
-    return excluded;
-}
-// Load .gitignore patterns
-async function loadGitignorePatterns(projectPath) {
-    const gitignorePath = path.join(projectPath, '.gitignore');
-    try {
-        const content = await fs.readFile(gitignorePath, 'utf-8');
-        return content
-            .split('\n')
-            .map(line => line.trim())
-            .filter(line => line && !line.startsWith('#'));
-    }
-    catch {
-        return [];
-    }
-}
-// Simple gitignore pattern matcher (basic implementation)
-function matchesGitignorePattern(filePath, patterns) {
-    for (const pattern of patterns) {
-        const normalizedPattern = pattern.trim();
-        if (!normalizedPattern)
-            continue;
-        // Convert to regex for simple matching
-        const regexPattern = normalizedPattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-        const regex = new RegExp(`^${regexPattern}`);
-        // Check both relative path and basename
-        if (regex.test(filePath) || regex.test(path.basename(filePath))) {
-            return true;
-        }
-    }
-    return false;
-}
-// Scan project files recursively
-async function scanProjectFiles(projectPath, vicoaClient, maxFiles = 100000) {
-    const base = path.resolve(projectPath);
-    try {
-        const stats = await fs.stat(base);
-        if (!stats.isDirectory()) {
-            return [];
-        }
-    }
-    catch {
-        return [];
-    }
-    const excludePatterns = [...DEFAULT_EXCLUDE_PATTERNS];
-    const gitignorePatterns = await loadGitignorePatterns(base);
-    excludePatterns.push(...gitignorePatterns);
-    const skipDirs = getExcludedDirNames();
-    const files = [];
-    const folders = new Set();
-    async function walkDirectory(dirPath, relativePath = '') {
-        try {
-            const entries = await fs.readdir(dirPath, { withFileTypes: true });
-            for (const entry of entries) {
-                // Skip excluded directories early
-                if (entry.isDirectory() && skipDirs.has(entry.name)) {
-                    continue;
-                }
-                const entryRelativePath = relativePath ? path.join(relativePath, entry.name) : entry.name;
-                const entryFullPath = path.join(dirPath, entry.name);
-                if (entry.isDirectory()) {
-                    await walkDirectory(entryFullPath, entryRelativePath);
-                    // Add folder to results (with trailing slash)
-                    const folderPath = entryRelativePath.replace(/\\/g, '/') + '/';
-                    folders.add(folderPath);
-                }
-                else if (entry.isFile()) {
-                    // Check if file should be excluded
-                    if (matchesGitignorePattern(entryRelativePath, excludePatterns)) {
-                        continue;
-                    }
-                    files.push(entryRelativePath.replace(/\\/g, '/'));
-                    // Extract parent folders
-                    const parts = entryRelativePath.split(path.sep);
-                    for (let i = 0; i < parts.length - 1; i++) {
-                        const folderPath = parts.slice(0, i + 1).join('/') + '/';
-                        folders.add(folderPath);
-                    }
-                }
-                // Stop at max_files limit
-                if (files.length >= maxFiles) {
-                    vicoaClient.log('warn', `Large project detected: ${maxFiles}+ files found`);
-                    vicoaClient.log('warn', `Only syncing first ${maxFiles} files for performance`);
-                    vicoaClient.log('warn', 'File mentions may be incomplete');
-                    return;
-                }
-            }
-        }
-        catch (error) {
-            vicoaClient.log('warn', `Error scanning directory ${dirPath}: ${error}`);
-        }
-    }
-    await walkDirectory(base);
-    // Combine folders and files
-    return Array.from(folders).concat(files);
-}
-// Sync project files to Vicoa backend
-export async function syncProjectFiles(vicoaClient, projectPath) {
-    try {
-        // Use absolute path for file scanning (needed for fs operations)
-        const absolutePath = path.resolve(projectPath);
-        vicoaClient.log('info', 'Preparing fuzzy file search with @ ...');
-        const files = await scanProjectFiles(absolutePath, vicoaClient);
-        if (files.length === 0) {
-            return; // No files to sync
-        }
-        // Send tilde path to backend (consistent with Claude wrapper)
-        const formattedPath = formatProjectPath(absolutePath);
-        await vicoaClient.syncFiles(formattedPath, files);
-        vicoaClient.log('info', `Synced ${files.length} files for fuzzy search`);
-    }
-    catch (error) {
-        vicoaClient.log('warn', `Failed to sync project files: ${error}`);
-        // Silently fail - don't block plugin startup
-    }
-}
-// Backup vicoa client api call here
-/**
- * Sync project files to Vicoa backend for @ mentions
- */
-// async syncFiles(projectPath: string, files: string[]): Promise<void> {
-//   try {
-//     const response = await fetch(`${this.config.baseUrl}/api/v1/files/sync`, {
-//       method: 'POST',
-//       headers: {
-//         'Authorization': `Bearer ${this.config.apiKey}`,
-//         'Content-Type': 'application/json',
-//       },
-//       body: JSON.stringify({
-//         project_path: projectPath,
-//         files,
-//       }),
-//     });
-//     if (!response.ok) {
-//       const error = await response.text();
-//       this.log('warn', `Failed to sync project files: ${response.statusText} - ${error}`);
-//     }
-//   } catch (error) {
-//     this.log('warn', `Error syncing project files: ${error}`);
-//   }
-// }

package/dist/vicoa-client.d.ts

@@ -1,67 +0,0 @@
-/**
- * Vicoa API client for OpenCode plugin
- *
- * This client uses Vicoa's existing REST APIs to communicate with the dashboard.
- * It mimics the Python VicoaClient functionality but runs in TypeScript/Node.js.
- */
-export interface VicoaClientConfig {
-    apiKey: string;
-    baseUrl: string;
-    agentType: string;
-    agentInstanceId: string;
-    logFunc?: (level: string, msg: string) => void;
-}
-export interface VicoaMessage {
-    id: string;
-    content: string;
-    sender_type: 'USER' | 'AGENT';
-    requires_user_input: boolean;
-    created_at: string;
-}
-export declare class VicoaClient {
-    private config;
-    lastMessageId: string | null;
-    log: (level: string, msg: string) => void;
-    constructor(config: VicoaClientConfig);
-    /**
-     * Register agent instance with Vicoa backend
-     */
-    registerAgentInstance(project: string, homeDir: string): Promise<{
-        agent_instance_id: string;
-    }>;
-    /**
-     * Sync custom slash commands to Vicoa backend
-     */
-    syncCommands(agentType: string, commands: Record<string, {
-        description: string;
-    }>): Promise<void>;
-    /**
-     * Send agent message to Vicoa dashboard
-     */
-    sendMessage(content: string, requiresUserInput?: boolean): Promise<string | null>;
-    /**
-     * Send user message from terminal to Vicoa dashboard
-     * This is used when the user types a message directly in the OpenCode terminal
-     */
-    sendUserMessage(content: string): Promise<string | null>;
-    /**
-     * Poll for pending user messages from Vicoa dashboard
-     */
-    getPendingMessages(): Promise<VicoaMessage[]>;
-    /**
-     * Request user input (equivalent to Claude wrapper's request_user_input)
-     */
-    requestUserInput(messageId: string): Promise<void>;
-    /**
-     * Update agent instance status
-     */
-    updateStatus(status: 'ACTIVE' | 'AWAITING_INPUT' | 'PAUSED' | 'STALE' | 'COMPLETED' | 'FAILED' | 'KILLED' | 'DISCONNECTED' | 'DELETED'): Promise<void>;
-    /**
-     * Update agent instance title/name
-     */
-    updateAgentInstanceName(name: string): Promise<void>;
-    /**
-     * End session
-     */
-    endSession(): Promise<void>;
-}

package/dist/vicoa-client.js

@@ -1,259 +0,0 @@
-/**
- * Vicoa API client for OpenCode plugin
- *
- * This client uses Vicoa's existing REST APIs to communicate with the dashboard.
- * It mimics the Python VicoaClient functionality but runs in TypeScript/Node.js.
- */
-export class VicoaClient {
-    config;
-    lastMessageId = null;
-    log;
-    constructor(config) {
-        this.config = config;
-        this.log = config.logFunc || ((level, msg) => console.log(`[${level}] ${msg}`));
-    }
-    /**
-     * Register agent instance with Vicoa backend
-     */
-    async registerAgentInstance(project, homeDir) {
-        const response = await fetch(`${this.config.baseUrl}/api/v1/agent-instances`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${this.config.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                agent_type: this.config.agentType,
-                transport: 'local',
-                agent_instance_id: this.config.agentInstanceId,
-                name: this.config.agentType,
-                project,
-                home_dir: homeDir,
-            }),
-        });
-        if (!response.ok) {
-            const error = await response.text();
-            throw new Error(`Failed to register agent instance: ${response.statusText} - ${error}`);
-        }
-        return (await response.json());
-    }
-    /**
-     * Sync custom slash commands to Vicoa backend
-     */
-    async syncCommands(agentType, commands) {
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/v1/commands/sync`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    agent_type: agentType,
-                    commands,
-                }),
-            });
-            if (!response.ok) {
-                const error = await response.text();
-                this.log('warn', `Failed to sync slash commands: ${response.statusText} - ${error}`);
-            }
-        }
-        catch (error) {
-            this.log('warn', `Error syncing slash commands: ${error}`);
-        }
-    }
-    /**
-     * Send agent message to Vicoa dashboard
-     */
-    async sendMessage(content, requiresUserInput = false) {
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/v1/messages/agent`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    content,
-                    agent_type: this.config.agentType,
-                    agent_instance_id: this.config.agentInstanceId,
-                    requires_user_input: requiresUserInput,
-                }),
-            });
-            if (!response.ok) {
-                const error = await response.text();
-                this.log('warn', `Failed to send message: ${response.statusText} - ${error}`);
-                return null;
-            }
-            const result = (await response.json());
-            // Update last message ID for polling
-            if (result.message_id) {
-                this.lastMessageId = result.message_id;
-            }
-            return result.message_id;
-        }
-        catch (error) {
-            this.log('warn', `Error sending message: ${error}`);
-            return null;
-        }
-    }
-    /**
-     * Send user message from terminal to Vicoa dashboard
-     * This is used when the user types a message directly in the OpenCode terminal
-     */
-    async sendUserMessage(content) {
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/v1/messages/user`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    content,
-                    agent_instance_id: this.config.agentInstanceId,
-                }),
-            });
-            if (!response.ok) {
-                const error = await response.text();
-                this.log('warn', `Failed to send user message: ${response.statusText} - ${error}`);
-                return null;
-            }
-            const result = (await response.json());
-            // Update last message ID
-            if (result.message_id) {
-                this.lastMessageId = result.message_id;
-            }
-            return result.message_id;
-        }
-        catch (error) {
-            this.log('warn', `Error sending user message: ${error}`);
-            return null;
-        }
-    }
-    /**
-     * Poll for pending user messages from Vicoa dashboard
-     */
-    async getPendingMessages() {
-        try {
-            const url = new URL(`${this.config.baseUrl}/api/v1/messages/pending`);
-            url.searchParams.set('agent_instance_id', this.config.agentInstanceId);
-            if (this.lastMessageId) {
-                url.searchParams.set('last_read_message_id', this.lastMessageId);
-            }
-            const response = await fetch(url.toString(), {
-                method: 'GET',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                },
-            });
-            if (!response.ok) {
-                // Polling errors are non-fatal
-                this.log('debug', `Failed to poll messages: ${response.statusText}`);
-                return [];
-            }
-            const result = (await response.json());
-            // Check if the response is stale
-            if (result.status === 'stale') {
-                this.log('debug', 'Message polling returned stale status');
-                return [];
-            }
-            const messages = result.messages || [];
-            // Update last message ID
-            if (messages.length > 0) {
-                const lastMsg = messages[messages.length - 1];
-                this.lastMessageId = lastMsg.id;
-            }
-            return messages;
-        }
-        catch (error) {
-            this.log('debug', `Error polling messages: ${error}`);
-            return [];
-        }
-    }
-    /**
-     * Request user input (equivalent to Claude wrapper's request_user_input)
-     */
-    async requestUserInput(messageId) {
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/v1/messages/${messageId}/request-input`, {
-                method: 'PATCH',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                },
-            });
-            if (!response.ok) {
-                this.log('warn', `Failed to request user input: ${response.statusText}`);
-            }
-        }
-        catch (error) {
-            this.log('warn', `Error requesting user input: ${error}`);
-        }
-    }
-    /**
-     * Update agent instance status
-     */
-    async updateStatus(status) {
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/v1/agent-instances/${this.config.agentInstanceId}/status`, {
-                method: 'PUT',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ status }),
-            });
-            if (!response.ok) {
-                this.log('warn', `Failed to update status: ${response.statusText}`);
-            }
-        }
-        catch (error) {
-            this.log('warn', `Error updating status: ${error}`);
-        }
-    }
-    /**
-     * Update agent instance title/name
-     */
-    async updateAgentInstanceName(name) {
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/v1/agent-instances/${this.config.agentInstanceId}`, {
-                method: 'PATCH',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ name }),
-            });
-            if (!response.ok) {
-                this.log('warn', `Failed to update agent instance name: ${response.statusText}`);
-            }
-        }
-        catch (error) {
-            this.log('warn', `Error updating agent instance name: ${error}`);
-        }
-    }
-    /**
-     * End session
-     */
-    async endSession() {
-        await this.updateStatus('COMPLETED');
-        try {
-            const response = await fetch(`${this.config.baseUrl}/api/v1/sessions/end`, {
-                method: 'POST',
-                headers: {
-                    'Authorization': `Bearer ${this.config.apiKey}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({
-                    agent_instance_id: this.config.agentInstanceId,
-                }),
-            });
-            if (!response.ok) {
-                this.log('warn', `Failed to end session: ${response.statusText}`);
-            }
-        }
-        catch (error) {
-            this.log('warn', `Error ending session: ${error}`);
-        }
-    }
-}