@vicoa/opencode 0.1.0

package/dist/plugin/commands.js

@@ -0,0 +1,228 @@
+import path from 'path';
+import * as fs from 'fs/promises';
+import { log } from './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/plugin/control.d.ts

@@ -0,0 +1,15 @@
+import type { VicoaClient } from './vicoa-client.js';
+type ControlCommandContext = {
+    client: any;
+    vicoaClient: VicoaClient;
+    currentSessionId?: string;
+    getTuiCurrentAgent: () => string | undefined;
+    setTuiCurrentAgent: (agent: string | undefined) => void;
+    setPreferredAgent: (agent: string | undefined) => void;
+};
+export declare function cycleTuiToAgent(client: any, targetAgent: string, currentAgent: string | undefined): Promise<boolean>;
+/**
+ * Handle control commands from Vicoa (matching Claude wrapper pattern)
+ */
+export declare function handleControlCommand(content: string, context: ControlCommandContext): Promise<boolean>;
+export {};

package/dist/plugin/control.js

@@ -0,0 +1,140 @@
+import { executeTuiCommand } from './commands.js';
+import { log } from './utils.js';
+// Cycle the TUI's agent indicator to `targetAgent` by firing agent.cycle
+// the right number of times.  The TUI wraps around at the end of the list,
+// so we only need (targetIndex - currentIndex + len) % len steps.
+// Returns true if the cycle was attempted, false if we couldn't determine
+// the current position (e.g. no user message seen yet).
+export async function cycleTuiToAgent(client, targetAgent, currentAgent) {
+    try {
+        // Fetch the same filtered list the TUI uses: primary agents only, not hidden.
+        // hey-api returns { data, error, … } when throwOnError is false (the default).
+        const { data: allAgents } = await client.app.agents();
+        const primaryAgents = allAgents.filter((a) => a.mode !== 'subagent' && !a.hidden);
+        const targetIdx = primaryAgents.findIndex((a) => a.name === targetAgent);
+        if (targetIdx === -1)
+            return false; // shouldn't happen — already validated
+        // If we haven't seen a user message yet we don't know where the TUI is.
+        // Optimistic fallback: assume it's on index 0 (the default agent).
+        const currentName = currentAgent ?? primaryAgents[0]?.name;
+        const currentIdx = primaryAgents.findIndex((a) => a.name === currentName);
+        if (currentIdx === -1)
+            return false;
+        const steps = (targetIdx - currentIdx + primaryAgents.length) % primaryAgents.length;
+        for (let i = 0; i < steps; i++) {
+            await executeTuiCommand(client, 'agent.cycle');
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function extractControlPayload(content) {
+    const trimmed = content.trim();
+    try {
+        const parsed = JSON.parse(trimmed);
+        const payload = parsed.control_command ?? (parsed.type === 'control' ? parsed : null);
+        if (payload) {
+            return payload;
+        }
+    }
+    catch {
+        // Ignore and try to scan embedded JSON
+    }
+    const candidates = trimmed.match(/\{[^{}]*\}/g) ?? [];
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(candidate);
+            const payload = parsed.control_command ?? (parsed.type === 'control' ? parsed : null);
+            if (payload) {
+                return payload;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Handle control commands from Vicoa (matching Claude wrapper pattern)
+ */
+export async function handleControlCommand(content, context) {
+    const { client, vicoaClient, currentSessionId, getTuiCurrentAgent, setPreferredAgent, setTuiCurrentAgent } = context;
+    // Try to parse as JSON control command
+    try {
+        const controlPayload = extractControlPayload(content);
+        if (controlPayload) {
+            const { setting, value } = controlPayload;
+            if (setting === 'interrupt') {
+                log(client, 'info', '[Vicoa] Interrupt command received');
+                if (!currentSessionId) {
+                    await vicoaClient.sendMessage('Failed to interrupt');
+                    log(client, 'warn', '[Vicoa] Interrupt failed: no active session');
+                    return true;
+                }
+                try {
+                    await executeTuiCommand(client, 'session.interrupt');
+                    await executeTuiCommand(client, 'session.interrupt');
+                    await vicoaClient.sendMessage('Interrupted');
+                    log(client, 'info', '[Vicoa] Interrupted');
+                }
+                catch (tuiError) {
+                    await vicoaClient.sendMessage('Failed to interrupt.');
+                    log(client, 'error', `[Vicoa] TUI interrupt failed: ${tuiError}`);
+                }
+                return true;
+            }
+            if (setting === 'agent_type') {
+                const nextAgent = typeof value === 'string' ? value.toLowerCase() : '';
+                if (!nextAgent) {
+                    log(client, 'warn', '[Vicoa] Agent type control command missing value');
+                    return true;
+                }
+                let selectedAgent = nextAgent;
+                // Validate against the agents OpenCode actually knows about.
+                // Filter to primary (non-subagent, non-hidden) — same set the TUI cycles through.
+                try {
+                    const { data: agents } = await client.app.agents();
+                    const primaryAgents = agents.filter((a) => a.mode !== 'subagent' && !a.hidden);
+                    const validNames = primaryAgents.map((a) => a.name);
+                    const match = validNames.find((n) => n.toLowerCase() === nextAgent);
+                    if (!match) {
+                        log(client, 'warn', `[Vicoa] Unknown agent "${nextAgent}". Available: ${validNames.join(', ')}`);
+                        await vicoaClient.sendMessage(`Unknown agent "${nextAgent}". Available agents: ${validNames.join(', ')}`);
+                        return true;
+                    }
+                    // Use the canonical casing returned by OpenCode
+                    selectedAgent = match;
+                    setPreferredAgent(match);
+                    // Cycle the TUI indicator so the terminal also shows the new agent.
+                    // session.prompt alone only affects a single message server-side;
+                    // the TUI's displayed agent is purely client-side state mutated by
+                    // agent.cycle commands.
+                    const cycled = await cycleTuiToAgent(client, match, getTuiCurrentAgent());
+                    if (cycled) {
+                        setTuiCurrentAgent(match);
+                        log(client, 'info', `[Vicoa] TUI agent indicator cycled to ${match}`);
+                    }
+                    else {
+                        log(client, 'warn', `[Vicoa] Could not cycle TUI to ${match}, will still route messages via session.prompt`);
+                    }
+                }
+                catch (error) {
+                    // If agent listing fails, accept the value optimistically
+                    log(client, 'warn', `[Vicoa] Could not list agents for validation: ${error}`);
+                    setPreferredAgent(nextAgent);
+                }
+                await vicoaClient.sendMessage(`Agent changed to ${selectedAgent}.`);
+                return true;
+            }
+            log(client, 'warn', `[Vicoa] Unknown control command: ${setting}`);
+            return true;
+        }
+    }
+    catch {
+        // Not a JSON control command, treat as regular message
+    }
+    return false;
+}

package/dist/plugin/credentials.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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/plugin/credentials.js

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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,187 @@
+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/plugin/format-utils.d.ts

@@ -0,0 +1,10 @@
+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 {};