oh-my-openidea 0.1.0

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

@@ -0,0 +1,28 @@
+import type { CreateFile, DeleteFile, Diagnostic, DocumentSymbol, Location, LocationLink, Position, Range, RenameFile, SymbolInformation as SymbolInfo, TextDocumentEdit, TextDocumentIdentifier, TextEdit, VersionedTextDocumentIdentifier, WorkspaceEdit } from 'vscode-languageserver-protocol';
+export interface LSPServerConfig {
+    id: string;
+    command: string[];
+    extensions: string[];
+    disabled?: boolean;
+    env?: Record<string, string>;
+    initialization?: Record<string, unknown>;
+}
+export interface ResolvedServer {
+    id: string;
+    command: string[];
+    extensions: string[];
+    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,21 @@
+import type { LSPClient } from './client';
+import type { Diagnostic, Location, LocationLink, ServerLookupResult, WorkspaceEdit } from './types';
+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/tools/paper-reader/index.d.ts

@@ -0,0 +1,8 @@
+import { type ToolDefinition } from '@opencode-ai/plugin';
+/**
+ * Retrieve paper content from an arXiv ID or arXiv abstract URL.
+ * Uses arXiv's HTML rendering endpoint (available for most papers since ~2023)
+ * to extract structured text without requiring a PDF parser.
+ * Falls back to fetching the abstract page for older papers.
+ */
+export declare const paper_reader: ToolDefinition;

package/dist/tools/research.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@opencode-ai/plugin';
+import { type ResearchConfig } from '../research';
+export declare function createResearchTools(directory: string, researchConfig?: Partial<ResearchConfig>): Record<string, ToolDefinition>;

package/dist/tools/semantic-scholar/index.d.ts

@@ -0,0 +1,12 @@
+import { type ToolDefinition } from '@opencode-ai/plugin';
+/**
+ * Search Semantic Scholar for academic papers.
+ * Returns papers with citation counts, influential citation flags, and AI-generated TLDRs.
+ * Free API — no key required for basic access (rate limit: 100 req/5min).
+ * Set SEMANTIC_SCHOLAR_API_KEY env var for higher limits.
+ */
+export declare const semantic_scholar_search: ToolDefinition;
+/**
+ * Retrieve citation and reference graph for a paper via Semantic Scholar.
+ */
+export declare const citation_graph: ToolDefinition;

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,6 @@
+export * from './agent-variant';
+export * from './env';
+export { log } from './logger';
+export * from './polling';
+export * from './tmux';
+export { extractZip } from './zip-extractor';

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>;

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "oh-my-openidea",
+  "version": "0.1.0",
+  "description": "Multi-agent framework for CS/ML research idea generation — literature survey, hypothesis generation, novelty checking, methodology design, and paper outlining",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "oh-my-openidea": "./dist/cli/index.js"
+  },
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "ai",
+    "agents",
+    "research",
+    "llm",
+    "arxiv",
+    "semantic-scholar",
+    "research-ideas",
+    "hypothesis-generation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xiaozg/oh-my-openidea"
+  },
+  "bugs": {
+    "url": "https://github.com/xiaozg/oh-my-openidea/issues"
+  },
+  "homepage": "https://github.com/xiaozg/oh-my-openidea#readme",
+  "files": [
+    "dist",
+    "src/skills",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target bun --format esm && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm && tsc --emitDeclarationOnly",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "lint": "biome lint .",
+    "format": "biome format . --write",
+    "check": "biome check --write .",
+    "check:ci": "biome check .",
+    "dev": "bun run build && opencode",
+    "prepublishOnly": "bun run build",
+    "release:patch": "npm version patch && git push --follow-tags && npm publish",
+    "release:minor": "npm version minor && git push --follow-tags && npm publish",
+    "release:major": "npm version major && git push --follow-tags && npm publish"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@opencode-ai/plugin": "^1.2.6",
+    "@opencode-ai/sdk": "^1.2.6",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.4.2",
+    "bun-types": "1.3.9",
+    "typescript": "^5.9.3"
+  },
+  "trustedDependencies": [
+    "@ast-grep/cli"
+  ]
+}

package/src/skills/experiment-design/SKILL.md

@@ -0,0 +1,153 @@
+```skill
+---
+name: experiment-design
+description: Design a complete, publication-ready experimental plan for a validated research idea — including method, baselines, datasets, evaluation metrics, ablations, and compute estimate.
+---
+```
+
+# Experiment Design Skill
+
+This skill produces a **concrete, executable experimental plan** for a validated research idea. It is designed to run after `idea-critique` confirms an idea is worth pursuing (Overall ≥ 6/10).
+
+## When to Use
+
+Use this skill when:
+- A research idea has passed the critique quality gate
+- You need to specify exactly how to run experiments before writing any code
+- Preparing a research proposal, grant application, or lab presentation
+- Collaborating with team members who need a precise implementation spec
+
+## Prerequisites
+
+- Validated research idea (from `idea-critique` skill, status: `validated`)
+- Literature landscape map (to know what baselines exist)
+- Rough sense of compute available
+
+## Workflow
+
+### Step 1: Baseline Identification (Surveyor + Architect)
+
+Launch **@surveyor** to find the current state-of-the-art on the target benchmark(s).
+Specifically:
+- Find the top-performing methods from the last 2 years
+- Retrieve their code/checkpoint links
+- Identify what exact evaluation protocol they use
+
+Then launch **@architect** with:
+- The validated idea description
+- The baseline landscape from Surveyor
+
+### Step 2: Dataset Selection (Architect)
+
+For each candidate dataset, **@architect** evaluates:
+1. **Relevance**: Does it directly test the core claim?
+2. **Accessibility**: Is it publicly available? License?
+3. **Standard**: Is it used in related work (essential for comparison)?
+4. **Size**: Is it large enough to show statistical significance?
+
+Select:
+- 1–2 **primary datasets** (the ones the paper centers on)
+- 1–2 **secondary datasets** (for generalization / ablation)
+
+### Step 3: Metric Definition (Architect)
+
+Define evaluation metrics:
+- **Primary metric**: Used for the main table headline (must match related work's primary)
+- **Secondary metrics**: Complementary signals
+- **Statistical considerations**: Significance test, number of seeds, confidence intervals
+
+**Anti-patterns to avoid**:
+- Reporting only metrics where the method looks best
+- Using a non-standard metric without justification
+- No statistical significance testing for close results
+
+### Step 4: Ablation Plan (Architect)
+
+Design ablations that prove each claimed contribution independently.
+
+Rule: **Every claim in the paper must be supported by at least one ablation.**
+
+Template:
+```
+Ablation plan:
+1. Full model (proposed method) — baseline for ablation comparison
+2. Remove [component X] — tests that X is necessary
+3. Replace [component X] with [standard alternative] — tests that X is better than the obvious alternative
+4. Replace [component Y] with [simpler version] — tests sensitivity
+5. [Domain generalization]: apply to [different dataset] — tests claim of general applicability
+```
+
+### Step 5: Compute Estimate (Architect)
+
+For each experiment:
+- Model size and architecture
+- Training/inference hardware requirements
+- Estimated wall-clock time
+- Total GPU-hours
+
+Flag if total compute exceeds reasonable academic budget (>1000 GPU-hours on A100).
+
+### Step 6: Implementation Notes (Architect)
+
+Key decisions to document:
+- Framework (PyTorch version, key libraries)
+- Any non-obvious hyperparameter choices
+- Potential implementation traps (numerical stability, memory optimization)
+- Code structure recommendations
+
+### Step 7: Output and Save
+
+```markdown
+# Experimental Plan: [Idea Title]
+
+## Method Overview
+[2–3 sentences describing the approach precisely enough to implement]
+
+## Baselines
+| Method | Paper | Code | Why essential |
+|--------|-------|------|---------------|
+| ...    | ...   | ...  | ...           |
+
+## Datasets
+| Dataset | Task | Size | Primary/Secondary | License | URL |
+|---------|------|------|-------------------|---------|-----|
+| ...     | ...  | ...  | ...               | ...     | ... |
+
+## Evaluation Protocol
+- Primary metric: [name] — [definition and justification]  
+- Secondary metrics: [list]
+- Statistical test: [test name], [min N seeds], [CI level]
+
+## Ablation Plan
+1. ...
+2. ...
+(see Phase 4)
+
+## Compute Estimate
+| Experiment | Hardware | Time | GPU-Hours |
+|------------|----------|------|-----------|
+| Main training | 4× A100 | Xh | X |
+| Ablation | 2× A100 | Xh each | X total |
+| Total | | | X |
+
+## Implementation Notes
+- Framework: PyTorch X.X + HuggingFace Transformers X.X
+- Key dependencies: [list]
+- Critical decisions: [list non-obvious choices]
+
+## Expected Results
+Research hypothesis: [specific predicted improvement]
+Confidence: [High / Medium / Low]
+```
+
+Update the idea in `idea_store` (action: `update`):
+- Store the experimental plan in `methodology` field
+- Update status to `in_progress`
+
+## Quality Criteria
+
+- At least 3 baselines (including the most recent SOTA)
+- At least 3 ablations covering all claimed contributions
+- Primary dataset must be the same as related work (for fair comparison)
+- Compute estimate must be realistic (not "1 GPU, 1 hour")
+- Implementation notes must mention the training framework and key libraries

package/src/skills/hypothesis-generation/SKILL.md

@@ -0,0 +1,102 @@
+```skill
+---
+name: hypothesis-generation
+description: Generate, score, and rank novel CS/ML research hypotheses based on identified literature gaps. Produces 3–5 concrete, differentiated ideas with preliminary novelty assessments.
+---
+```
+
+# Hypothesis Generation Skill
+
+This skill takes a **literature landscape map** (from the literature-review skill or a direct description of the field) and generates **concrete, original research hypotheses** ranked by novelty and feasibility.
+
+## When to Use
+
+Use this skill when:
+- You have a gap analysis and want to convert it into testable research ideas
+- Brainstorming multiple research directions to compare before committing
+- Generating variations of an initial idea to find the strongest formulation
+
+## Prerequisites
+
+You should have:
+- A research topic or field description
+- Ideally: output from the `literature-review` skill (landscape map + gaps)
+
+If no prior literature review is available, the orchestrator will run a quick survey first.
+
+## Workflow
+
+### Step 1: Ingest Landscape
+
+Parse the provided landscape map or gap analysis. Extract:
+- The 3 most promising gaps (evidence-backed, non-trivial)
+- The dominant methodology paradigm in the field
+- Key open benchmarks or evaluation axes
+
+### Step 2: Generate Hypotheses (Self — Orchestrator)
+
+For each gap, generate 1–2 research hypotheses using this template:
+
+```
+**Hypothesis [N]**: [One-sentence claim]
+- **Problem**: [What is missing or broken]
+- **Proposed approach**: [Core idea in 2–3 sentences]
+- **Motivation**: [Why this might work — theoretical or empirical grounding]
+- **Distinguishing factor**: [What makes this different from existing work]
+- **Preliminary novelty confidence**: [High / Medium / Low] — [Reason]
+```
+
+**Diversity constraint**: Hypotheses must differ in at least one of: (a) methodology family (e.g., don't generate 5 fine-tuning ideas), (b) problem framing, (c) target application domain.
+
+### Step 3: Quick Deduplication (Surveyor)
+
+For each hypothesis, run a targeted arXiv search to check if an obvious direct solution exists.
+Use `arxiv_search` with the core claim as the query. This is a quick check — deep validation happens in the `idea-critique` skill.
+
+Example: For "hypothesis: sparse attention patterns can be learned from dense attention", search:
+`arxiv_search(query="learning sparse attention patterns", categories=["cs.LG"], max_results=10)`
+
+### Step 4: Score and Rank
+
+Score each surviving hypothesis on:
+| Criterion | Weight | Description |
+|-----------|--------|-------------|
+| Novelty | 40% | How differentiated from existing work |
+| Feasibility | 30% | Can be done in 6–12 months with standard compute |
+| Significance | 20% | Would matter if it worked |
+| Clarity | 10% | Is the claim testable and well-defined |
+
+Rank by weighted score. Present top 3–5.
+
+### Step 5: Output
+
+```markdown
+# Research Hypotheses: [Topic]
+
+Generated: [date]
+Based on: [literature source]
+
+## Ranked Hypotheses
+
+### 🥇 Hypothesis 1: [Title]
+**Score**: Novelty X/10 | Feasibility X/10 | Significance X/10 | Overall X/10
+**Problem**: ...
+**Approach**: ...
+**Why novel**: ...
+**Key risk**: ...
+**Recommended next step**: Run `idea-critique` skill to validate novelty
+
+### 🥈 Hypothesis 2: [Title]
+...
+```
+
+### Step 6: Save
+
+Save the top 3 hypotheses to the idea store using `idea_store` with action `save` (status: `draft`).
+
+## Quality Criteria
+
+- Each hypothesis must be **specific and testable** (not "explore X" but "propose method Y to improve Z by doing W")
+- Must cite at least one supporting gap from the previous literature review
+- No two hypotheses may address the same gap in the same way
+- Quick deduplication search is mandatory before ranking

package/src/skills/idea-critique/SKILL.md

@@ -0,0 +1,129 @@
+```skill
+---
+name: idea-critique
+description: Run adversarial multi-round critique on a research idea through @critic and @architect. Produces a full review report with scores, weaknesses, improvement suggestions, and a final verdict.
+---
+```
+
+# Idea Critique Skill
+
+This skill orchestrates a **rigorous adversarial review** of a research idea, mimicking the NeurIPS/ICML program committee process. It is a prerequisite before investing effort in experiment design or writing.
+
+## When to Use
+
+Use this skill when:
+- A research hypothesis needs novelty validation before proceeding
+- Preparing an idea for discussion with collaborators
+- Stress-testing assumptions before writing a paper proposal
+- Comparing multiple ideas to select the strongest one
+
+## Prerequisites
+
+You need at minimum:
+- The idea's **problem statement** (one clear sentence)
+- The **core proposed approach** (2–3 sentences)
+- The **research context** (field + related work references)
+
+## Workflow
+
+### Round 1: Novelty Check (Critic)
+
+Launch **@critic** with:
+- The full idea description
+- The list of related papers found during the literature survey
+
+**@critic's job**:
+1. Search arXiv and Semantic Scholar for papers that directly address this idea
+2. Identify degree of overlap: exact duplicate / partial overlap / related but different
+3. Report specific conflicting papers with their arXiv IDs
+
+**Overlap classification**:
+- **Exact** (≥90% overlap): Idea should be rejected or significantly reformulated
+- **High** (50–90%): Core claim is addressed; must differentiate further
+- **Moderate** (20–50%): Current work is related but the gap is real
+- **Low** (<20%): Genuinely novel direction
+
+### Round 2: Full Review (Critic)
+
+If novelty check passes (overlap < 50%), run the full NeurIPS-style review:
+
+```
+Scores (1–10):
+- Novelty:      X — [justification with paper citations]
+- Feasibility:  X — [compute/data requirements assessment]
+- Significance: X — [impact if successful]
+- Clarity:      X — [how well-defined is the contribution]
+- Overall:      X
+
+Weaknesses (must identify at least 3):
+1. ...
+2. ...
+3. ...
+
+Strengths (must identify at least 2):
+1. ...
+2. ...
+
+Concrete improvements:
+1. ...
+2. ...
+
+Verdict: ACCEPT / WEAK_ACCEPT / WEAK_REJECT / REJECT
+```
+
+**Advancement threshold**: Overall ≥ 6/10.
+
+### Round 3: Improvement (Orchestrator)
+
+If the verdict is WEAK_REJECT or the overall score is 5–6:
+1. Present @critic's weaknesses to the user
+2. Generate one improved version of the idea addressing the top 2 weaknesses
+3. Re-run the critique (only once — reject if still below threshold)
+
+### Round 4: Update Idea Store
+
+Update the idea in the idea store using `idea_store` with action `update`:
+- Set `critique_done: true`
+- Record the scores in `scores` field
+- Update `status` to `validated` if Overall ≥ 6, or `abandoned` if rejected
+- Save @critic's full review in `notes`
+
+### Output Format
+
+```markdown
+# Critique Report: [Idea Title]
+
+## Novelty Check
+[Overlap classification + conflicting papers found]
+
+## Review Scores
+| Dimension    | Score | Key Reason                          |
+|--------------|-------|-------------------------------------|
+| Novelty      | X/10  | ...                                 |
+| Feasibility  | X/10  | ...                                 |
+| Significance | X/10  | ...                                 |
+| Clarity      | X/10  | ...                                 |
+| Overall      | X/10  | ...                                 |
+
+## Weaknesses
+1. ...
+2. ...
+3. ...
+
+## Strengths
+1. ...
+2. ...
+
+## Improvements Applied
+[If a revised version was generated]
+
+## Verdict
+[ACCEPT / WEAK_ACCEPT / WEAK_REJECT / REJECT] — Proceed to `experiment-design`? [Yes / No]
+```
+
+## Quality Criteria
+
+- @critic must run at least 3 targeted searches (not just general queries)
+- Novelty must be verified with specific paper IDs, not general statements
+- At least 3 weaknesses must be identified even for strong ideas
+- The skill must produce a binary decision (proceed / don't proceed) at the end