oh-my-openidea 0.1.0

package/dist/mcp/arxiv.d.ts

@@ -0,0 +1,10 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * arXiv MCP via the Community arxiv-mcp-server (smithery).
+ * Provides paper search, PDF reading, and paper info retrieval.
+ * @see https://smithery.ai/server/@joshuarileydev/arxiv-mcp-server
+ *
+ * Falls back to remote hosted instance if available.
+ * No API key required — arXiv API is free.
+ */
+export declare const arxiv: RemoteMcpConfig;

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/google-scholar.d.ts

@@ -0,0 +1,10 @@
+import type { RemoteMcpConfig } from './types';
+/**
+ * Google Scholar search via the community google-scholar-mcp-server.
+ * Provides broad academic search coverage, useful for finding surveys and classics.
+ *
+ * Requires SERPAPI_KEY environment variable for the underlying SerpAPI service.
+ * If not set, this MCP should be disabled in config via disabled_mcps.
+ * @see https://serpapi.com/google-scholar-api
+ */
+export declare const google_scholar: 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,6 @@
+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[]): Record<string, McpConfig>;

package/dist/mcp/semantic-scholar.d.ts

@@ -0,0 +1,12 @@
+import type { RemoteMcpConfig, LocalMcpConfig } from './types';
+/**
+ * Semantic Scholar MCP.
+ * Searches papers, retrieves citation graphs and paper details via the free S2 API.
+ *
+ * Uses the community semantic-scholar-mcp-server via Smithery.
+ * Optionally set SEMANTIC_SCHOLAR_API_KEY for higher rate limits.
+ * @see https://www.semanticscholar.org/product/api
+ */
+type McpConfig = RemoteMcpConfig | LocalMcpConfig;
+export declare const semantic_scholar: McpConfig;
+export {};

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/research/connectors.d.ts

@@ -0,0 +1,6 @@
+import type { SourceRecord } from './types';
+export declare function ingestLocalSources(root: string, globs: string[]): Promise<SourceRecord[]>;
+export declare function ingestWebSources(queries: string[], maxResults?: number): Promise<{
+    sources: SourceRecord[];
+    warnings: string[];
+}>;

package/dist/research/defaults.d.ts

@@ -0,0 +1,2 @@
+import type { ResearchConfig } from './types';
+export declare const DEFAULT_RESEARCH_CONFIG: ResearchConfig;

package/dist/research/index.d.ts

@@ -0,0 +1,4 @@
+export { DEFAULT_RESEARCH_CONFIG } from './defaults';
+export * from './pipeline';
+export * from './store';
+export * from './types';

package/dist/research/pipeline.d.ts

@@ -0,0 +1,9 @@
+import type { CritiqueResearchOptions, ExportResearchOptions, ExportResult, IdeaBrief, IdeaScorecard, IdeateResearchOptions, IngestResearchOptions, IngestResult, InitResearchOptions, LandscapeMap, MapResearchOptions, PipelineRun, RankResearchOptions, RankResult, ResearchConfig, ResearchProject, RunResearchOptions } from './types';
+export declare function initResearchProject(root: string, options?: InitResearchOptions, researchConfig?: Partial<ResearchConfig>): ResearchProject;
+export declare function ingestResearchSources(root: string, options?: IngestResearchOptions, researchConfig?: Partial<ResearchConfig>): Promise<IngestResult>;
+export declare function mapResearchLandscape(root: string, options?: MapResearchOptions, researchConfig?: Partial<ResearchConfig>): LandscapeMap;
+export declare function ideateResearchIdeas(root: string, options?: IdeateResearchOptions, researchConfig?: Partial<ResearchConfig>): IdeaBrief[];
+export declare function critiqueResearchIdeas(root: string, options?: CritiqueResearchOptions, researchConfig?: Partial<ResearchConfig>): IdeaScorecard[];
+export declare function rankResearchIdeas(root: string, options?: RankResearchOptions, researchConfig?: Partial<ResearchConfig>): RankResult;
+export declare function exportResearchArtifacts(root: string, options?: ExportResearchOptions, researchConfig?: Partial<ResearchConfig>): ExportResult;
+export declare function runResearchPipeline(root: string, options?: RunResearchOptions, researchConfig?: Partial<ResearchConfig>): Promise<PipelineRun>;

package/dist/research/store.d.ts

@@ -0,0 +1,31 @@
+import type { IdeaBrief, IdeaScorecard, LandscapeMap, PipelineRun, ResearchProject, SourceRecord } from './types';
+export declare function hashContent(value: string): string;
+export declare function getResearchDir(root: string): string;
+export declare function getResearchProjectPath(root: string): string;
+export declare function getResearchSourcesPath(root: string): string;
+export declare function getResearchLandscapePath(root: string): string;
+export declare function getResearchLandscapeJsonPath(root: string): string;
+export declare function getResearchIdeasDir(root: string): string;
+export declare function getResearchIdeaIndexPath(root: string): string;
+export declare function getResearchEvaluationsDir(root: string): string;
+export declare function getResearchRunsDir(root: string): string;
+export declare function getResearchExportsDir(root: string): string;
+export declare function ensureResearchWorkspace(root: string): void;
+export declare function writeJson(filePath: string, value: unknown): void;
+export declare function writeText(filePath: string, content: string): void;
+export declare function readJson<T>(filePath: string): T | null;
+export declare function readJsonLines<T>(filePath: string): T[];
+export declare function writeJsonLines(filePath: string, values: unknown[]): void;
+export declare function readResearchProject(root: string): ResearchProject | null;
+export declare function writeResearchProject(root: string, project: ResearchProject): void;
+export declare function readSourceRecords(root: string): SourceRecord[];
+export declare function writeSourceRecords(root: string, sources: SourceRecord[]): void;
+export declare function writeLandscape(root: string, landscape: LandscapeMap): void;
+export declare function readLandscape(root: string): LandscapeMap | null;
+export declare function writeLandscapeMarkdown(root: string, content: string): void;
+export declare function writeIdeaBrief(root: string, idea: IdeaBrief, content: string): void;
+export declare function readIdeaIndex(root: string): IdeaBrief[];
+export declare function writeIdeaIndex(root: string, ideas: IdeaBrief[]): void;
+export declare function writeIdeaScorecard(root: string, scorecard: IdeaScorecard): void;
+export declare function readIdeaScorecards(root: string): IdeaScorecard[];
+export declare function writeRun(root: string, run: PipelineRun): string;

package/dist/research/text.d.ts

@@ -0,0 +1,8 @@
+export declare function normalizeWhitespace(value: string): string;
+export declare function splitSentences(value: string): string[];
+export declare function summarizeText(value: string, maxSentences?: number): string;
+export declare function extractTitleFromContent(content: string, fallback: string): string;
+export declare function extractKeywords(content: string, limit?: number): string[];
+export declare function slugify(value: string): string;
+export declare function truncate(value: string, maxLength: number): string;
+export declare function collectTaggedSentences(content: string, markers: readonly string[], limit?: number): string[];

package/dist/research/types.d.ts

@@ -0,0 +1,194 @@
+export declare const RESEARCH_STAGE_NAMES: readonly ["init", "ingest", "map", "ideate", "critique", "rank", "export"];
+export type ResearchStageName = (typeof RESEARCH_STAGE_NAMES)[number];
+export type ResearchBehaviorPreset = 'research' | 'code-research' | 'legacy-coding';
+export interface ResearchWorkspaceConfig {
+    title: string;
+    objective: string;
+    constraints: string[];
+    audience: string;
+    successCriteria: string[];
+}
+export interface ResearchSourcesConfig {
+    connectors: string[];
+    localGlobs: string[];
+    webQueries: string[];
+    citationPolicy: 'required' | 'optional';
+    refreshBehavior: 'append' | 'replace';
+}
+export interface ResearchPipelineConfig {
+    enabledStages: ResearchStageName[];
+    ideaCount: number;
+    critiquePasses: number;
+    promotionThreshold: number;
+    topK: number;
+}
+export interface ResearchScoringConfig {
+    novelty: number;
+    feasibility: number;
+    impact: number;
+    evidenceCoverage: number;
+    strategicFit: number;
+}
+export interface ResearchTemplatesConfig {
+    ideaBrief: string;
+    scorecard: string;
+    exportFormat: 'markdown' | 'json' | 'both';
+}
+export interface ResearchConfig {
+    behaviorPreset: ResearchBehaviorPreset;
+    codeTools: boolean;
+    workspace: ResearchWorkspaceConfig;
+    sources: ResearchSourcesConfig;
+    pipeline: ResearchPipelineConfig;
+    scoring: ResearchScoringConfig;
+    templates: ResearchTemplatesConfig;
+}
+export interface ResearchProject {
+    version: 1;
+    createdAt: string;
+    updatedAt: string;
+    workspace: ResearchWorkspaceConfig;
+    sources: ResearchSourcesConfig;
+    pipeline: ResearchPipelineConfig;
+    scoring: ResearchScoringConfig;
+    templates: ResearchTemplatesConfig;
+}
+export interface SourceRecord {
+    id: string;
+    sourceType: 'local' | 'web';
+    connector: string;
+    title: string;
+    citation: string;
+    capturedAt: string;
+    summary: string;
+    excerpt: string;
+    content: string;
+    tags: string[];
+    checksum: string;
+    path?: string;
+    url?: string;
+    query?: string;
+    publishedAt?: string;
+}
+export interface LandscapeTheme {
+    name: string;
+    keywords: string[];
+    summary: string;
+    sourceIds: string[];
+}
+export interface LandscapeGap {
+    title: string;
+    description: string;
+    sourceIds: string[];
+}
+export interface LandscapeTension {
+    title: string;
+    description: string;
+    sourceIds: string[];
+}
+export interface LandscapeOpportunity {
+    title: string;
+    rationale: string;
+    sourceIds: string[];
+}
+export interface LandscapeMap {
+    generatedAt: string;
+    summary: string;
+    sourceIds: string[];
+    themes: LandscapeTheme[];
+    gaps: LandscapeGap[];
+    tensions: LandscapeTension[];
+    opportunities: LandscapeOpportunity[];
+}
+export interface IdeaBrief {
+    id: string;
+    slug: string;
+    title: string;
+    createdAt: string;
+    problem: string;
+    motivation: string;
+    hypothesis: string;
+    approach: string;
+    evaluationPlan: string;
+    risks: string[];
+    noveltyClaim: string;
+    citations: string[];
+    sourceIds: string[];
+}
+export interface IdeaScorecard {
+    ideaId: string;
+    generatedAt: string;
+    novelty: number;
+    feasibility: number;
+    impact: number;
+    evidenceCoverage: number;
+    strategicFit: number;
+    total: number;
+    strengths: string[];
+    risks: string[];
+    verdict: 'promote' | 'revise' | 'hold';
+}
+export interface RankedIdea {
+    ideaId: string;
+    title: string;
+    total: number;
+    verdict: IdeaScorecard['verdict'];
+}
+export interface PipelineRun {
+    id: string;
+    createdAt: string;
+    stages: ResearchStageName[];
+    counts: {
+        sources: number;
+        themes: number;
+        ideas: number;
+        evaluations: number;
+    };
+    outputs: Record<string, string>;
+    ranking: RankedIdea[];
+    warnings: string[];
+}
+export interface InitResearchOptions {
+    title?: string;
+    objective?: string;
+    audience?: string;
+    constraints?: string[];
+    successCriteria?: string[];
+    localGlobs?: string[];
+    webQueries?: string[];
+}
+export interface IngestResearchOptions {
+    localGlobs?: string[];
+    webQueries?: string[];
+    maxWebResults?: number;
+}
+export interface MapResearchOptions {
+    maxThemes?: number;
+}
+export interface IdeateResearchOptions {
+    count?: number;
+}
+export interface CritiqueResearchOptions {
+    ideaIds?: string[];
+}
+export interface RankResearchOptions {
+    topK?: number;
+}
+export interface ExportResearchOptions {
+    format?: 'markdown' | 'json' | 'both';
+    topK?: number;
+    name?: string;
+}
+export interface RunResearchOptions extends InitResearchOptions, IngestResearchOptions, MapResearchOptions, IdeateResearchOptions, RankResearchOptions, ExportResearchOptions {
+    stages?: ResearchStageName[];
+}
+export interface IngestResult {
+    sources: SourceRecord[];
+    warnings: string[];
+}
+export interface RankResult {
+    ranking: RankedIdea[];
+}
+export interface ExportResult {
+    files: string[];
+}

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

@@ -0,0 +1,7 @@
+import { type ToolDefinition } from '@opencode-ai/plugin';
+/**
+ * Search arXiv preprints via the public arXiv API.
+ * No API key required. Returns paper metadata including arXiv IDs,
+ * titles, authors, abstracts, categories, and PDF links.
+ */
+export declare const arxiv_search: ToolDefinition;

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/google-scholar/index.d.ts

@@ -0,0 +1,8 @@
+import { type ToolDefinition } from '@opencode-ai/plugin';
+/**
+ * Search Google Scholar via the SerpAPI service.
+ * Requires SERPAPI_KEY environment variable.
+ * Useful for finding survey papers, highly-cited classics, and
+ * broad academic coverage not well indexed on arXiv/Semantic Scholar.
+ */
+export declare const google_scholar_search: ToolDefinition;

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

@@ -0,0 +1,3 @@
+import type { CountResult, GrepOptions, GrepResult } from './types';
+export declare function runRg(options: GrepOptions): Promise<GrepResult>;
+export declare function runRgCount(options: Omit<GrepOptions, 'context'>): Promise<CountResult[]>;

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

@@ -0,0 +1,18 @@
+export type GrepBackend = 'rg' | 'grep';
+interface ResolvedCli {
+    path: string;
+    backend: GrepBackend;
+}
+export declare function getDataDir(): string;
+export declare function resolveGrepCli(): ResolvedCli;
+export declare function resolveGrepCliWithAutoInstall(): Promise<ResolvedCli>;
+export declare const DEFAULT_MAX_DEPTH = 20;
+export declare const DEFAULT_MAX_FILESIZE = "10M";
+export declare const DEFAULT_MAX_COUNT = 500;
+export declare const DEFAULT_MAX_COLUMNS = 1000;
+export declare const DEFAULT_CONTEXT = 2;
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+export declare const DEFAULT_MAX_OUTPUT_BYTES: number;
+export declare const RG_SAFETY_FLAGS: readonly ["--no-follow", "--color=never", "--no-heading", "--line-number", "--with-filename"];
+export declare const GREP_SAFETY_FLAGS: readonly ["-n", "-H", "--color=never"];
+export {};

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

@@ -0,0 +1,3 @@
+export declare function findFileRecursive(dir: string, filename: string): string | null;
+export declare function downloadAndInstallRipgrep(): Promise<string>;
+export declare function getInstalledRipgrepPath(): string | null;

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

@@ -0,0 +1,5 @@
+export { runRg, runRgCount } from './cli';
+export { resolveGrepCli, resolveGrepCliWithAutoInstall } from './constants';
+export { downloadAndInstallRipgrep, getInstalledRipgrepPath, } from './downloader';
+export { grep } from './tools';
+export type { CountResult, GrepMatch, GrepOptions, GrepResult } from './types';

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

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

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

@@ -0,0 +1,35 @@
+export interface GrepMatch {
+    file: string;
+    line: number;
+    text: string;
+}
+export interface GrepResult {
+    matches: GrepMatch[];
+    totalMatches: number;
+    filesSearched: number;
+    truncated: boolean;
+    error?: string;
+}
+export interface CountResult {
+    file: string;
+    count: number;
+}
+export interface GrepOptions {
+    pattern: string;
+    paths?: string[];
+    globs?: string[];
+    excludeGlobs?: string[];
+    context?: number;
+    caseSensitive?: boolean;
+    wholeWord?: boolean;
+    fixedStrings?: boolean;
+    multiline?: boolean;
+    hidden?: boolean;
+    noIgnore?: boolean;
+    fileType?: string[];
+    maxDepth?: number;
+    maxFilesize?: string;
+    maxCount?: number;
+    maxColumns?: number;
+    timeout?: number;
+}

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

@@ -0,0 +1,2 @@
+import type { GrepResult } from './types';
+export declare function formatGrepResult(result: GrepResult): string;

package/dist/tools/idea-store/index.d.ts

@@ -0,0 +1,7 @@
+import { type ToolDefinition } from '@opencode-ai/plugin';
+/**
+ * Persistent local store for research ideas.
+ * Stores ideas with metadata (scores, status, related papers, methodology notes).
+ * Ideas are persisted to ~/.config/opencode/oh-my-openidea/ideas.json.
+ */
+export declare const idea_store: ToolDefinition;

package/dist/tools/index.d.ts

@@ -0,0 +1,6 @@
+export { arxiv_search } from './arxiv';
+export { createBackgroundTools } from './background';
+export { citation_graph, semantic_scholar_search } from './semantic-scholar';
+export { google_scholar_search } from './google-scholar';
+export { idea_store } from './idea-store';
+export { paper_reader } from './paper-reader';

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.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,8 @@
+import type { LSPServerConfig } 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;
+export declare const BUILTIN_SERVERS: Record<string, Omit<LSPServerConfig, 'id'>>;
+export declare const LSP_INSTALL_HINTS: Record<string, string>;
+export declare const EXT_TO_LANG: Record<string, string>;

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

@@ -0,0 +1,3 @@
+export { lspManager } from './client';
+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;