oh-my-opencode-lite 0.1.0

package/dist/mcp/context7.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * Context7 - official documentation lookup for libraries
+ * @see https://context7.com
+ */
+export declare const context7: RemoteMcpConfig;

package/dist/mcp/grep-app.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * grep.app - ultra-fast code search across GitHub repositories
+ * @see https://grep.app
+ */
+export declare const grep_app: RemoteMcpConfig;

package/dist/mcp/index.d.ts

@@ -0,0 +1,7 @@
+import type { ThothConfig } from '../config';
+import type { McpConfig } from './types';
+export type { LocalMcpConfig, McpConfig, RemoteMcpConfig } from './types';
+/**
+ * Creates MCP configurations, excluding disabled ones
+ */
+export declare function createBuiltinMcps(disabledMcps?: readonly string[], thothConfig?: ThothConfig): Record<string, McpConfig>;

package/dist/mcp/thoth.d.ts

@@ -0,0 +1,3 @@
+import { type ThothConfig } from '../config';
+import type { LocalMcpConfig } from './types';
+export declare function createThothMcp(config?: ThothConfig): LocalMcpConfig;

package/dist/mcp/types.d.ts

@@ -0,0 +1,12 @@
+export type RemoteMcpConfig = {
+    type: 'remote';
+    url: string;
+    headers?: Record<string, string>;
+    oauth?: false;
+};
+export type LocalMcpConfig = {
+    type: 'local';
+    command: string[];
+    environment?: Record<string, string>;
+};
+export type McpConfig = RemoteMcpConfig | LocalMcpConfig;

package/dist/mcp/websearch.d.ts

@@ -0,0 +1,6 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * Exa AI web search - real-time web search
+ * @see https://exa.ai
+ */
+export declare const websearch: RemoteMcpConfig;

package/dist/thoth/client.d.ts

@@ -0,0 +1,14 @@
+export interface CreateThothClientOptions {
+    project: string;
+    directory?: string;
+    httpPort?: number;
+    timeoutMs?: number;
+    enabled?: boolean;
+}
+export interface ThothClient {
+    readonly enabled: boolean;
+    memContext(sessionId?: string, limit?: number): Promise<string | null>;
+    memSessionStart(sessionId: string): Promise<boolean>;
+    memSavePrompt(sessionId: string, content: string): Promise<boolean>;
+}
+export declare function createThothClient(options: CreateThothClientOptions): ThothClient;

package/dist/thoth/index.d.ts

@@ -0,0 +1,2 @@
+export type { CreateThothClientOptions, ThothClient } from './client';
+export { createThothClient } from './client';

package/dist/tools/ast-grep/cli.d.ts

@@ -0,0 +1,15 @@
+import type { CliLanguage, SgResult } from './types';
+export interface RunOptions {
+    pattern: string;
+    lang: CliLanguage;
+    paths?: string[];
+    globs?: string[];
+    rewrite?: string;
+    context?: number;
+    updateAll?: boolean;
+}
+export declare function getAstGrepPath(): Promise<string | null>;
+export declare function startBackgroundInit(): void;
+export declare function runSg(options: RunOptions): Promise<SgResult>;
+export declare function isCliAvailable(): boolean;
+export declare function ensureCliAvailable(): Promise<boolean>;

package/dist/tools/ast-grep/constants.d.ts

@@ -0,0 +1,25 @@
+import { CLI_LANGUAGES } from './types';
+export declare function findSgCliPathSync(): string | null;
+export declare function getSgCliPath(): string;
+export declare function setSgCliPath(path: string): void;
+export { CLI_LANGUAGES };
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+export declare const DEFAULT_MAX_OUTPUT_BYTES: number;
+export declare const DEFAULT_MAX_MATCHES = 500;
+export declare const LANG_EXTENSIONS: Record<string, string[]>;
+export interface EnvironmentCheckResult {
+    cli: {
+        available: boolean;
+        path: string;
+        error?: string;
+    };
+}
+/**
+ * Check if ast-grep CLI is available.
+ * Call this at startup to provide early feedback about missing dependencies.
+ */
+export declare function checkEnvironment(): EnvironmentCheckResult;
+/**
+ * Format environment check result as user-friendly message.
+ */
+export declare function formatEnvironmentCheck(result: EnvironmentCheckResult): string;

package/dist/tools/ast-grep/downloader.d.ts

@@ -0,0 +1,5 @@
+export declare function getCacheDir(): string;
+export declare function getBinaryName(): string;
+export declare function getCachedBinaryPath(): string | null;
+export declare function downloadAstGrep(version?: string): Promise<string | null>;
+export declare function ensureAstGrepBinary(): Promise<string | null>;

package/dist/tools/ast-grep/index.d.ts

@@ -0,0 +1,10 @@
+import type { ToolDefinition } from '@opencode-ai/plugin';
+import { ast_grep_replace, ast_grep_search } from './tools';
+export declare const builtinTools: Record<string, ToolDefinition>;
+export { ast_grep_search, ast_grep_replace };
+export { ensureCliAvailable, getAstGrepPath, isCliAvailable, startBackgroundInit, } from './cli';
+export type { EnvironmentCheckResult } from './constants';
+export { checkEnvironment, formatEnvironmentCheck } from './constants';
+export { ensureAstGrepBinary, getCacheDir, getCachedBinaryPath, } from './downloader';
+export type { CliLanguage, CliMatch, SgResult } from './types';
+export { CLI_LANGUAGES } from './types';

package/dist/tools/ast-grep/tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const ast_grep_search: ToolDefinition;
+export declare const ast_grep_replace: ToolDefinition;

package/dist/tools/ast-grep/types.d.ts

@@ -0,0 +1,30 @@
+export declare const CLI_LANGUAGES: readonly ["bash", "c", "cpp", "csharp", "css", "elixir", "go", "haskell", "html", "java", "javascript", "json", "kotlin", "lua", "nix", "php", "python", "ruby", "rust", "scala", "solidity", "swift", "typescript", "tsx", "yaml"];
+export type CliLanguage = (typeof CLI_LANGUAGES)[number];
+export interface CliMatch {
+    file: string;
+    range: {
+        byteOffset: {
+            start: number;
+            end: number;
+        };
+        start: {
+            line: number;
+            column: number;
+        };
+        end: {
+            line: number;
+            column: number;
+        };
+    };
+    lines: string;
+    text: string;
+    replacement?: string;
+    language: string;
+}
+export interface SgResult {
+    matches: CliMatch[];
+    totalMatches: number;
+    truncated: boolean;
+    truncatedReason?: 'timeout' | 'max_output_bytes' | 'max_matches';
+    error?: string;
+}

package/dist/tools/ast-grep/utils.d.ts

@@ -0,0 +1,4 @@
+import type { CliLanguage, SgResult } from './types';
+export declare function formatSearchResult(result: SgResult): string;
+export declare function formatReplaceResult(result: SgResult, isDryRun: boolean): string;
+export declare function getEmptyResultHint(pattern: string, lang: CliLanguage): string | null;

package/dist/tools/background.d.ts

@@ -0,0 +1,13 @@
+import { type PluginInput, type ToolDefinition } from '@opencode-ai/plugin';
+import { type BackgroundTaskManager } from '../background';
+import type { PluginConfig } from '../config';
+import type { TmuxConfig } from '../config/schema';
+/**
+ * Creates background task management tools for the plugin.
+ * @param _ctx - Plugin input context
+ * @param manager - Background task manager for launching and tracking tasks
+ * @param _tmuxConfig - Optional tmux configuration for session management
+ * @param _pluginConfig - Optional plugin configuration for agent variants
+ * @returns Object containing background_task, background_output, and background_cancel tools
+ */
+export declare function createBackgroundTools(_ctx: PluginInput, manager: BackgroundTaskManager, _tmuxConfig?: TmuxConfig, _pluginConfig?: PluginConfig): Record<string, ToolDefinition>;

package/dist/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { ast_grep_replace, ast_grep_search } from './ast-grep';
+export { createBackgroundTools } from './background';
+export { lsp_diagnostics, lsp_find_references, lsp_goto_definition, lsp_rename, lspManager, setUserLspConfig, } from './lsp';

package/dist/tools/lsp/client.d.ts

@@ -0,0 +1,42 @@
+import type { Diagnostic, ResolvedServer } from './types';
+declare class LSPServerManager {
+    private static instance;
+    private clients;
+    private cleanupInterval;
+    private readonly IDLE_TIMEOUT;
+    private constructor();
+    private registerProcessCleanup;
+    static getInstance(): LSPServerManager;
+    private getKey;
+    private startCleanupTimer;
+    private cleanupIdleClients;
+    getClient(root: string, server: ResolvedServer): Promise<LSPClient>;
+    releaseClient(root: string, serverId: string): void;
+    isServerInitializing(root: string, serverId: string): boolean;
+    stopAll(): Promise<void>;
+}
+export declare const lspManager: LSPServerManager;
+export declare class LSPClient {
+    private root;
+    private server;
+    private proc;
+    private connection;
+    private openedFiles;
+    private stderrBuffer;
+    private processExited;
+    private diagnosticsStore;
+    constructor(root: string, server: ResolvedServer);
+    start(): Promise<void>;
+    private startStderrReading;
+    initialize(): Promise<void>;
+    openFile(filePath: string): Promise<void>;
+    definition(filePath: string, line: number, character: number): Promise<unknown>;
+    references(filePath: string, line: number, character: number, includeDeclaration?: boolean): Promise<unknown>;
+    diagnostics(filePath: string): Promise<{
+        items: Diagnostic[];
+    }>;
+    rename(filePath: string, line: number, character: number, newName: string): Promise<unknown>;
+    isAlive(): boolean;
+    stop(): Promise<void>;
+}
+export {};

package/dist/tools/lsp/config-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * User-provided LSP server config (from opencode.json lsp section).
+ * Fields are optional because user config may not include all properties.
+ */
+export interface UserLspConfig {
+    id: string;
+    command?: string[];
+    extensions?: string[];
+    disabled?: boolean;
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+}
+/**
+ * Set the user's lsp config from opencode.json.
+ * Called during plugin initialization.
+ */
+export declare function setUserLspConfig(config: Record<string, unknown> | undefined): void;
+/**
+ * Get the user's lsp config for a specific server ID.
+ */
+export declare function getUserLspConfig(serverId: string): UserLspConfig | undefined;
+/**
+ * Get all user-configured lsp servers.
+ */
+export declare function getAllUserLspConfigs(): Map<string, UserLspConfig>;
+/**
+ * Check if user has configured any lsp servers.
+ */
+export declare function hasUserLspConfig(): boolean;

package/dist/tools/lsp/config.d.ts

@@ -0,0 +1,4 @@
+import type { ServerLookupResult } from './types';
+export declare function findServerForExtension(ext: string): ServerLookupResult;
+export declare function getLanguageId(ext: string): string;
+export declare function isServerInstalled(command: string[]): boolean;

package/dist/tools/lsp/constants.d.ts

@@ -0,0 +1,24 @@
+import type { LSPServerConfig, RootFunction } from './types';
+export declare const SYMBOL_KIND_MAP: Record<number, string>;
+export declare const SEVERITY_MAP: Record<number, string>;
+export declare const DEFAULT_MAX_REFERENCES = 200;
+export declare const DEFAULT_MAX_DIAGNOSTICS = 200;
+/**
+ * NearestRoot helper - mirrors OpenCode core's NearestRoot function.
+ * Creates a RootFunction that walks up directories looking for root markers.
+ */
+export declare function NearestRoot(includePatterns: string[], excludePatterns?: string[]): RootFunction;
+/**
+ * Built-in LSP servers - mirrors OpenCode core LSPServer namespace.
+ * User configuration from opencode.json lsp section takes precedence and is
+ * merged on top of these: user settings override command/extensions/env, while
+ * root patterns are always preserved from built-in. Servers can be removed by
+ * setting `"disabled": true` in the user config.
+ */
+export declare const BUILTIN_SERVERS: Record<string, Omit<LSPServerConfig, 'id'>>;
+export declare const LSP_INSTALL_HINTS: Record<string, string>;
+/**
+ * Maps file extensions to LSP language IDs.
+ * Mirrors OpenCode core's LANGUAGE_EXTENSIONS constant.
+ */
+export declare const LANGUAGE_EXTENSIONS: Record<string, string>;

package/dist/tools/lsp/index.d.ts

@@ -0,0 +1,4 @@
+export { lspManager } from './client';
+export { getUserLspConfig, setUserLspConfig } from './config-store';
+export { lsp_diagnostics, lsp_find_references, lsp_goto_definition, lsp_rename, } from './tools';
+export type { Diagnostic, Location, LSPServerConfig, ResolvedServer, WorkspaceEdit, } from './types';

package/dist/tools/lsp/tools.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const lsp_goto_definition: ToolDefinition;
+export declare const lsp_find_references: ToolDefinition;
+export declare const lsp_diagnostics: ToolDefinition;
+export declare const lsp_rename: ToolDefinition;

package/dist/tools/lsp/types.d.ts

@@ -0,0 +1,35 @@
+import type { CreateFile, DeleteFile, Diagnostic, DocumentSymbol, Location, LocationLink, Position, Range, RenameFile, SymbolInformation as SymbolInfo, TextDocumentEdit, TextDocumentIdentifier, TextEdit, VersionedTextDocumentIdentifier, WorkspaceEdit } from 'vscode-languageserver-protocol';
+/**
+ * Root function type - mirrors OpenCode core's RootFunction.
+ * Returns the project root directory for a given file, or undefined if not applicable.
+ */
+export type RootFunction = (file: string) => string | undefined;
+export interface LSPServerConfig {
+    id: string;
+    command: string[];
+    extensions: string[];
+    root?: RootFunction;
+    disabled?: boolean;
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+}
+export interface ResolvedServer {
+    id: string;
+    command: string[];
+    extensions: string[];
+    root?: RootFunction;
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+}
+export type ServerLookupResult = {
+    status: 'found';
+    server: ResolvedServer;
+} | {
+    status: 'not_configured';
+    extension: string;
+} | {
+    status: 'not_installed';
+    server: ResolvedServer;
+    installHint: string;
+};
+export type { Position, Range, Location, LocationLink, Diagnostic, TextDocumentIdentifier, VersionedTextDocumentIdentifier, TextEdit, TextDocumentEdit, CreateFile, RenameFile, DeleteFile, WorkspaceEdit, SymbolInfo, DocumentSymbol, };

package/dist/tools/lsp/utils.d.ts

@@ -0,0 +1,34 @@
+import type { LSPClient } from './client';
+import type { Diagnostic, Location, LocationLink, ResolvedServer, ServerLookupResult, WorkspaceEdit } from './types';
+/**
+ * Find the project root for a specific LSP server using its root function.
+ * Mirrors OpenCode core's RootFunction approach.
+ *
+ * @param filePath - The file to find the root for
+ * @param server - The LSP server config with root function
+ * @returns The project root directory, or file's directory if no root function
+ */
+export declare function findServerProjectRoot(filePath: string, server: ResolvedServer): string;
+/**
+ * Legacy function for backward compatibility.
+ * @deprecated Use findServerProjectRoot with server-specific patterns instead.
+ */
+export declare function findWorkspaceRoot(filePath: string): string;
+export declare function uriToPath(uri: string): string;
+export declare function formatServerLookupError(result: Exclude<ServerLookupResult, {
+    status: 'found';
+}>): string;
+export declare function withLspClient<T>(filePath: string, fn: (client: LSPClient) => Promise<T>): Promise<T>;
+export declare function formatLocation(loc: Location | LocationLink): string;
+export declare function formatSymbolKind(kind: number): string;
+export declare function formatSeverity(severity: number | undefined): string;
+export declare function formatDiagnostic(diag: Diagnostic): string;
+export declare function filterDiagnosticsBySeverity(diagnostics: Diagnostic[], severityFilter?: 'error' | 'warning' | 'information' | 'hint' | 'all'): Diagnostic[];
+export interface ApplyResult {
+    success: boolean;
+    filesModified: string[];
+    totalEdits: number;
+    errors: string[];
+}
+export declare function applyWorkspaceEdit(edit: WorkspaceEdit | null): ApplyResult;
+export declare function formatApplyResult(result: ApplyResult): string;

package/dist/utils/agent-variant.d.ts

@@ -0,0 +1,47 @@
+import type { PluginConfig } from '../config';
+/**
+ * Normalizes an agent name by trimming whitespace and removing the optional @ prefix.
+ *
+ * @param agentName - The agent name to normalize (e.g., "@oracle" or "oracle")
+ * @returns The normalized agent name without @ prefix and trimmed of whitespace
+ *
+ * @example
+ * normalizeAgentName("@oracle") // returns "oracle"
+ * normalizeAgentName("  explore  ") // returns "explore"
+ */
+export declare function normalizeAgentName(agentName: string): string;
+/**
+ * Resolves the variant configuration for a specific agent.
+ *
+ * Looks up the agent's variant in the plugin configuration. Returns undefined if:
+ * - No config is provided
+ * - The agent has no variant configured
+ * - The variant is not a string
+ * - The variant is empty or whitespace-only
+ *
+ * @param config - The plugin configuration object
+ * @param agentName - The name of the agent (with or without @ prefix)
+ * @returns The trimmed variant string, or undefined if no valid variant is found
+ *
+ * @example
+ * resolveAgentVariant(config, "@oracle") // returns "high" if configured
+ */
+export declare function resolveAgentVariant(config: PluginConfig | undefined, agentName: string): string | undefined;
+/**
+ * Applies a variant to a request body if the body doesn't already have one.
+ *
+ * This function will NOT override an existing variant in the body. If no variant
+ * is provided or the body already has a variant, the original body is returned.
+ *
+ * @template T - The type of the body object, must have an optional variant property
+ * @param variant - The variant string to apply (or undefined)
+ * @param body - The request body object
+ * @returns The body with the variant applied (new object) or the original body unchanged
+ *
+ * @example
+ * applyAgentVariant("high", { agent: "oracle" }) // returns { agent: "oracle", variant: "high" }
+ * applyAgentVariant("high", { agent: "oracle", variant: "low" }) // returns original body with variant: "low"
+ */
+export declare function applyAgentVariant<T extends {
+    variant?: string;
+}>(variant: string | undefined, body: T): T;

package/dist/utils/env.d.ts

@@ -0,0 +1 @@
+export declare function getEnv(name: string): string | undefined;

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './agent-variant';
+export * from './env';
+export * from './internal-initiator';
+export { log } from './logger';
+export * from './polling';
+export * from './tmux';
+export { extractZip } from './zip-extractor';

package/dist/utils/internal-initiator.d.ts

@@ -0,0 +1,6 @@
+export declare const LITE_INTERNAL_INITIATOR_MARKER = "<!-- LITE_INTERNAL_INITIATOR -->";
+export declare function createInternalAgentTextPart(text: string): {
+    type: 'text';
+    text: string;
+};
+export declare function hasInternalInitiatorMarker(part: unknown): boolean;

package/dist/utils/logger.d.ts

@@ -0,0 +1 @@
+export declare function log(message: string, data?: unknown): void;

package/dist/utils/polling.d.ts

@@ -0,0 +1,21 @@
+export interface PollOptions {
+    pollInterval?: number;
+    maxPollTime?: number;
+    stableThreshold?: number;
+    signal?: AbortSignal;
+}
+export interface PollResult<T> {
+    success: boolean;
+    data?: T;
+    timedOut?: boolean;
+    aborted?: boolean;
+}
+/**
+ * Generic polling utility that waits for a condition to be met.
+ * Returns when the condition is satisfied or timeout/abort occurs.
+ */
+export declare function pollUntilStable<T>(fetchFn: () => Promise<T>, isStable: (current: T, previous: T | null, stableCount: number) => boolean, opts?: PollOptions): Promise<PollResult<T>>;
+/**
+ * Simple delay utility
+ */
+export declare function delay(ms: number): Promise<void>;

package/dist/utils/tmux.d.ts

@@ -0,0 +1,32 @@
+import type { TmuxConfig } from '../config/schema';
+/**
+ * Reset the server availability cache (useful when server might have started)
+ */
+export declare function resetServerCheck(): void;
+/**
+ * Get cached tmux path, initializing if needed
+ */
+export declare function getTmuxPath(): Promise<string | null>;
+/**
+ * Check if we're running inside tmux
+ */
+export declare function isInsideTmux(): boolean;
+export interface SpawnPaneResult {
+    success: boolean;
+    paneId?: string;
+}
+/**
+ * Spawn a new tmux pane running `opencode attach <serverUrl> --session <sessionId>`
+ * This connects the new TUI to the existing server so it receives streaming updates.
+ * After spawning, applies the configured layout to auto-rebalance all panes.
+ * Returns the pane ID so it can be closed later.
+ */
+export declare function spawnTmuxPane(sessionId: string, description: string, config: TmuxConfig, serverUrl: string): Promise<SpawnPaneResult>;
+/**
+ * Close a tmux pane by its ID and reapply layout to rebalance remaining panes
+ */
+export declare function closeTmuxPane(paneId: string): Promise<boolean>;
+/**
+ * Start background check for tmux availability
+ */
+export declare function startTmuxCheck(): void;

package/dist/utils/zip-extractor.d.ts

@@ -0,0 +1 @@
+export declare function extractZip(archivePath: string, destDir: string): Promise<void>;