@yeyuan98/opencode-bioresearcher-plugin 1.5.0-alpha.0 → 1.5.1

package/dist/db-tools/pool.js

@@ -1,49 +0,0 @@
-import * as mysql from 'mysql2/promise';
-let pool = null;
-let currentConfig = null;
-function createPoolConfig(config) {
-    return {
-        host: config.host,
-        port: config.port,
-        user: config.user,
-        password: config.password,
-        database: config.database,
-        charset: config.charset,
-        connectTimeout: config.connectionTimeout,
-        waitForConnections: true,
-        connectionLimit: 10,
-        queueLimit: 0,
-        namedPlaceholders: true,
-    };
-}
-export function getPool(config) {
-    if (pool && currentConfig && isSameConfig(currentConfig, config)) {
-        return pool;
-    }
-    if (pool) {
-        pool.end().catch(err => console.error('[db-tools] Previous pool cleanup failed:', err.message));
-    }
-    pool = mysql.createPool(createPoolConfig(config));
-    currentConfig = config;
-    return pool;
-}
-function isSameConfig(a, b) {
-    return (a.host === b.host &&
-        a.port === b.port &&
-        a.user === b.user &&
-        a.password === b.password &&
-        a.database === b.database);
-}
-export async function closePool() {
-    if (pool) {
-        await pool.end().catch(err => console.error('[db-tools] Pool close failed:', err.message));
-        pool = null;
-        currentConfig = null;
-    }
-}
-export function getPoolStatus() {
-    return {
-        initialized: pool !== null,
-        hasConfig: currentConfig !== null,
-    };
-}

package/dist/db-tools/tools/index.d.ts

@@ -1,27 +0,0 @@
-import { ToolContext } from '@opencode-ai/plugin/tool';
-import { z } from 'zod';
-export declare const dbQuery: {
-    description: string;
-    args: {
-        sql: z.ZodString;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    };
-    execute(args: {
-        sql: string;
-        params?: Record<string, any> | undefined;
-    }, context: ToolContext): Promise<string>;
-};
-export declare const dbListTables: {
-    description: string;
-    args: {};
-    execute(args: Record<string, never>, context: ToolContext): Promise<string>;
-};
-export declare const dbDescribeTable: {
-    description: string;
-    args: {
-        table_name: z.ZodString;
-    };
-    execute(args: {
-        table_name: string;
-    }, context: ToolContext): Promise<string>;
-};

package/dist/db-tools/tools/index.js

@@ -1,191 +0,0 @@
-import { tool } from '@opencode-ai/plugin/tool';
-import { z } from 'zod';
-import { initializeBackend, getDefaultBackend } from '../backends';
-import { validateReadOnlyQuery, validateCollectionName } from '../core/validator';
-import { getConfigFromEnv } from '../core/base';
-async function ensureBackend() {
-    let backend = getDefaultBackend();
-    if (!backend) {
-        const config = getConfigFromEnv();
-        backend = await initializeBackend(config);
-    }
-    return backend;
-}
-export const dbQuery = tool({
-    description: `Execute a SELECT query on the database with named parameters.
-
-**Examples:**
-- Simple query: \`SELECT * FROM users LIMIT 10\`
-- With named params: \`SELECT * FROM users WHERE status = :status AND created_at > :date\`
-- Join query: \`SELECT u.name, o.total FROM users u JOIN orders o ON u.id = o.user_id\`
-- MongoDB query: \`SELECT * FROM users WHERE status = 'active' LIMIT 10\`
-
-**Parameters:**
-- Use named placeholders like \`:paramName\` for parameters
-- Pass parameter values in the \`params\` object: \`{ "status": "active", "date": "2024-01-01" }\`
-
-**Note:** Only SELECT statements are allowed (read-only access).
-
-**Backend Support:**
-- MySQL: Native SQL execution
-- MongoDB: SQL is translated to MongoDB queries automatically`,
-    args: {
-        sql: z.string().describe('SELECT SQL query to execute. Use named placeholders like :name for parameters.'),
-        params: z.record(z.string(), z.any()).optional().describe('Named parameters as key-value pairs (e.g., { "status": "active", "limit": 10 })'),
-    },
-    execute: async (args, _context) => {
-        try {
-            const backend = await ensureBackend();
-            const validation = validateReadOnlyQuery(args.sql, backend.type);
-            if (!validation.valid && validation.error) {
-                return JSON.stringify(validation.error, null, 2);
-            }
-            const result = await backend.executeQuery({
-                sql: args.sql,
-                params: args.params,
-            });
-            return JSON.stringify(result, null, 2);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return JSON.stringify({
-                success: false,
-                error: {
-                    code: 'BACKEND_ERROR',
-                    message: errorMessage,
-                },
-                metadata: { executionTimeMs: 0, backend: 'unknown' },
-            }, null, 2);
-        }
-    },
-});
-export const dbListTables = tool({
-    description: `List all tables/collections in the current database with metadata.
-
-**Returns:**
-- Table/collection names and types (TABLE, VIEW, COLLECTION, etc.)
-- For MySQL: Storage engine (InnoDB, MyISAM, etc.), row count, creation time
-- For MongoDB: Collection type information
-
-**Usage:** Call this first to discover what tables/collections are available before using dbDescribeTable or dbQuery.`,
-    args: {},
-    execute: async (_args, _context) => {
-        const startTime = Date.now();
-        try {
-            const backend = await ensureBackend();
-            const collections = await backend.listCollections();
-            const result = {
-                success: true,
-                data: {
-                    tables: collections,
-                    count: collections.length,
-                },
-                metadata: {
-                    executionTimeMs: Date.now() - startTime,
-                    backend: backend.type,
-                },
-            };
-            return JSON.stringify(result, null, 2);
-        }
-        catch (error) {
-            const backend = getDefaultBackend();
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return JSON.stringify({
-                success: false,
-                error: {
-                    code: 'LIST_TABLES_ERROR',
-                    message: errorMessage,
-                    hints: [
-                        'Check that the database server is running',
-                        'Verify your database credentials',
-                    ],
-                },
-                metadata: {
-                    executionTimeMs: Date.now() - startTime,
-                    backend: backend?.type || 'unknown',
-                },
-            }, null, 2);
-        }
-    },
-});
-export const dbDescribeTable = tool({
-    description: `Get the column/field schema for a specific table/collection.
-
-**Returns for each column/field:**
-- Field name
-- Data type (VARCHAR, INT, TEXT, DATETIME, etc. for MySQL; BSON types for MongoDB)
-- Nullable status
-- Key type (PRI for primary key, etc.)
-- Default value
-- Extra info (auto_increment, etc.)
-- Comments/description
-
-**Workflow:**
-1. Use \`dbListTables\` first to see available tables/collections
-2. Use this tool to understand the column/field structure
-3. Use \`dbQuery\` to query the data`,
-    args: {
-        table_name: z.string().describe('Name of the table/collection to describe. Use dbListTables to see available names.'),
-    },
-    execute: async (args, _context) => {
-        const startTime = Date.now();
-        try {
-            const backend = await ensureBackend();
-            const validation = validateCollectionName(args.table_name, backend.type);
-            if (!validation.valid && validation.error) {
-                return JSON.stringify(validation.error, null, 2);
-            }
-            const columns = await backend.describeCollection(args.table_name);
-            if (!columns || columns.length === 0) {
-                return JSON.stringify({
-                    success: false,
-                    error: {
-                        code: 'TABLE_NOT_FOUND',
-                        message: `Table/collection '${args.table_name}' not found in database`,
-                        hints: [
-                            'Use dbListTables to see available tables/collections',
-                            'Check the name for typos',
-                            'Make sure you are connected to the correct database',
-                        ],
-                    },
-                    metadata: {
-                        executionTimeMs: Date.now() - startTime,
-                        backend: backend.type,
-                    },
-                }, null, 2);
-            }
-            const result = {
-                success: true,
-                data: {
-                    table: args.table_name,
-                    columns,
-                    columnCount: columns.length,
-                },
-                metadata: {
-                    executionTimeMs: Date.now() - startTime,
-                    backend: backend.type,
-                },
-            };
-            return JSON.stringify(result, null, 2);
-        }
-        catch (error) {
-            const backend = getDefaultBackend();
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            return JSON.stringify({
-                success: false,
-                error: {
-                    code: 'DESCRIBE_TABLE_ERROR',
-                    message: errorMessage,
-                    hints: [
-                        'Use dbListTables to see available tables/collections',
-                        'Check the table name for typos',
-                    ],
-                },
-                metadata: {
-                    executionTimeMs: Date.now() - startTime,
-                    backend: backend?.type || 'unknown',
-                },
-            }, null, 2);
-        }
-    },
-});

package/dist/db-tools/types.d.ts

@@ -1,94 +0,0 @@
-import type { RowDataPacket } from 'mysql2/promise';
-export interface DbConfig {
-    host: string;
-    port: number;
-    user: string;
-    password: string;
-    database: string;
-    charset?: string;
-    connectionTimeout?: number;
-}
-export interface QueryOptions {
-    sql: string;
-    params?: Record<string, unknown> | unknown[];
-}
-export interface FieldInfo {
-    name: string;
-    type: string;
-    nullable: boolean;
-    key: string | null;
-    default: unknown;
-    extra: string | null;
-}
-export interface StructuredError {
-    code: string;
-    message: string;
-    details?: string;
-    hints?: string[];
-}
-export interface ToolResponse<T> {
-    success: boolean;
-    data?: T;
-    error?: StructuredError;
-    metadata?: {
-        executionTimeMs: number;
-        [key: string]: unknown;
-    };
-}
-export interface QueryResultData {
-    rows: RowDataPacket[];
-    rowCount: number;
-    fields: FieldInfo[];
-}
-export interface QueryResult extends ToolResponse<QueryResultData> {
-    success: true;
-    data: QueryResultData;
-}
-export interface QueryError extends ToolResponse<never> {
-    success: false;
-    error: StructuredError;
-}
-export type QueryResponse = QueryResult | QueryError;
-export interface TableInfo {
-    tableName: string;
-    tableType: string;
-    engine: string | null;
-    rowCount: number | null;
-    createdAt: string | null;
-    comment: string | null;
-}
-export interface TablesResultData {
-    tables: TableInfo[];
-    count: number;
-}
-export interface ColumnSchema {
-    field: string;
-    type: string;
-    nullable: boolean;
-    key: string | null;
-    defaultValue: unknown;
-    extra: string | null;
-    comment: string | null;
-}
-export interface SchemaResultData {
-    table: string;
-    columns: ColumnSchema[];
-    columnCount: number;
-}
-export type MySQLError = Error & {
-    code?: string;
-    errno?: number;
-    sql?: string;
-    sqlState?: string;
-};
-export declare const DEFAULT_CONFIG: Partial<DbConfig>;
-export declare const ERROR_HINTS: {
-    readonly CONNECTION: readonly ["Check that the database server is running", "Verify DB_HOST and DB_PORT environment variables", "Ensure network connectivity to the database"];
-    readonly AUTH: readonly ["Verify DB_USER and DB_PASSWORD environment variables", "Check that the user has permissions for the database"];
-    readonly UNKNOWN_TABLE: readonly ["Use dbListTables to see available tables", "Check the table name for typos"];
-    readonly UNKNOWN_COLUMN: readonly ["Use dbDescribeTable to see available columns", "Check the column name for typos"];
-    readonly SYNTAX: readonly ["Check your SQL syntax", "Ensure all identifiers are properly quoted if needed"];
-    readonly GENERIC: readonly ["Check your query syntax", "Use dbListTables to see available tables", "Use dbDescribeTable to check column names"];
-};
-export declare function isQueryResult(response: QueryResponse): response is QueryResult;
-export declare function isQueryError(response: QueryResponse): response is QueryError;

package/dist/db-tools/types.js

@@ -1,40 +0,0 @@
-export const DEFAULT_CONFIG = {
-    host: 'localhost',
-    port: 3306,
-    charset: 'utf8mb4',
-    connectionTimeout: 10000,
-};
-export const ERROR_HINTS = {
-    CONNECTION: [
-        'Check that the database server is running',
-        'Verify DB_HOST and DB_PORT environment variables',
-        'Ensure network connectivity to the database',
-    ],
-    AUTH: [
-        'Verify DB_USER and DB_PASSWORD environment variables',
-        'Check that the user has permissions for the database',
-    ],
-    UNKNOWN_TABLE: [
-        'Use dbListTables to see available tables',
-        'Check the table name for typos',
-    ],
-    UNKNOWN_COLUMN: [
-        'Use dbDescribeTable to see available columns',
-        'Check the column name for typos',
-    ],
-    SYNTAX: [
-        'Check your SQL syntax',
-        'Ensure all identifiers are properly quoted if needed',
-    ],
-    GENERIC: [
-        'Check your query syntax',
-        'Use dbListTables to see available tables',
-        'Use dbDescribeTable to check column names',
-    ],
-};
-export function isQueryResult(response) {
-    return response.success === true;
-}
-export function isQueryError(response) {
-    return response.success === false;
-}

package/dist/misc-tools/json-tools.d.ts

@@ -1,33 +0,0 @@
-import { ToolContext } from '@opencode-ai/plugin/tool';
-export declare const jsonValidate: {
-    description: string;
-    args: {
-        data: any;
-        schema: any;
-        version: any;
-    };
-    execute(args: {
-        [x: string]: any;
-    }, context: ToolContext): Promise<string>;
-};
-export declare const jsonExtract: {
-    description: string;
-    args: {
-        content: any;
-        path: any;
-    };
-    execute(args: {
-        [x: string]: any;
-    }, context: ToolContext): Promise<string>;
-};
-export declare const jsonInferSchema: {
-    description: string;
-    args: {
-        data: any;
-        title: any;
-        strict: any;
-    };
-    execute(args: {
-        [x: string]: any;
-    }, context: ToolContext): Promise<string>;
-};

package/dist/misc-tools/json-tools.js

@@ -1,187 +0,0 @@
-import { tool } from '@opencode-ai/plugin/tool';
-const zod = require('zod');
-function getFromJSONSchema() {
-    if (zod.fromJSONSchema) {
-        return zod.fromJSONSchema;
-    }
-    const v4classic = require('zod/v4/classic/external.js');
-    if (v4classic.fromJSONSchema) {
-        return v4classic.fromJSONSchema;
-    }
-    throw new Error('fromJSONSchema not available in zod package');
-}
-const fromJSONSchema = getFromJSONSchema();
-export const jsonValidate = tool({
-    description: `Validate JSON data against a JSON Schema.
-Returns validation result with detailed error paths and messages.
-Supports JSON Schema draft-04, draft-07, draft-2020-12, and OpenAPI 3.0.`,
-    args: {
-        data: z.any().describe("JSON data to validate (object, array, or primitive)"),
-        schema: z.any().describe("JSON Schema object to validate against"),
-        version: z.enum(["draft-04", "draft-07", "draft-2020-12", "openapi-3.0"])
-            .optional()
-            .default("draft-2020-12")
-            .describe("JSON Schema version (default: draft-2020-12)")
-    },
-    execute: async (args) => {
-        try {
-            const zodSchema = z.fromJSONSchema(args.schema, {
-                defaultTarget: args.version
-            });
-            const result = zodSchema.safeParse(args.data);
-            if (result.success) {
-                return JSON.stringify({
-                    valid: true,
-                    data: result.data
-                }, null, 2);
-            }
-            else {
-                const errors = result.error.issues.map((issue) => ({
-                    path: issue.path.join('.') || '(root)',
-                    message: issue.message,
-                    code: issue.code
-                }));
-                return JSON.stringify({
-                    valid: false,
-                    errors,
-                    errorCount: errors.length
-                }, null, 2);
-            }
-        }
-        catch (e) {
-            return JSON.stringify({
-                valid: false,
-                schemaError: e instanceof Error ? e.message : 'Unknown schema error'
-            }, null, 2);
-        }
-    }
-});
-export const jsonExtract = tool({
-    description: `Extract JSON from markdown or text content.
-Handles code blocks (\`\`\`json) and raw {...} or [...] patterns.
-Returns extracted JSON or error with details.`,
-    args: {
-        content: z.string().describe("Markdown or text content containing JSON"),
-        path: z.string().optional()
-            .describe("JSONPath to extract nested value (e.g., 'data.items.0')")
-    },
-    execute: async (args) => {
-        let jsonStr = null;
-        const codeBlockMatch = args.content.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
-        if (codeBlockMatch) {
-            jsonStr = codeBlockMatch[1].trim();
-        }
-        if (!jsonStr) {
-            const objStart = args.content.indexOf('{');
-            const arrStart = args.content.indexOf('[');
-            if (objStart !== -1 || arrStart !== -1) {
-                const startChar = objStart !== -1 && (arrStart === -1 || objStart < arrStart) ? '{' : '[';
-                const endChar = startChar === '{' ? '}' : ']';
-                const startIndex = args.content.indexOf(startChar);
-                let depth = 0;
-                let endIndex = -1;
-                for (let i = startIndex; i < args.content.length; i++) {
-                    if (args.content[i] === startChar)
-                        depth++;
-                    if (args.content[i] === endChar)
-                        depth--;
-                    if (depth === 0) {
-                        endIndex = i + 1;
-                        break;
-                    }
-                }
-                if (endIndex !== -1) {
-                    jsonStr = args.content.slice(startIndex, endIndex);
-                }
-            }
-        }
-        if (!jsonStr) {
-            return JSON.stringify({
-                success: false,
-                error: "No JSON found in content"
-            }, null, 2);
-        }
-        try {
-            let data = JSON.parse(jsonStr);
-            if (args.path) {
-                const parts = args.path.split('.');
-                for (const part of parts) {
-                    if (data === null || data === undefined) {
-                        return JSON.stringify({
-                            success: false,
-                            error: `Path '${args.path}' not found (null/undefined at '${part}')`
-                        }, null, 2);
-                    }
-                    data = data[part];
-                }
-            }
-            return JSON.stringify({
-                success: true,
-                data
-            }, null, 2);
-        }
-        catch (e) {
-            return JSON.stringify({
-                success: false,
-                error: `Invalid JSON: ${e instanceof Error ? e.message : 'Unknown error'}`,
-                extractedText: jsonStr.length > 200 ? jsonStr.slice(0, 200) + '...' : jsonStr
-            }, null, 2);
-        }
-    }
-});
-export const jsonInferSchema = tool({
-    description: `Infer a JSON Schema from example JSON data.
-Useful for creating schemas from sample data.`,
-    args: {
-        data: z.any().describe("Example JSON data to infer schema from"),
-        title: z.string().optional().describe("Optional schema title"),
-        strict: z.boolean().optional().default(false)
-            .describe("If true, set additionalProperties: false for objects")
-    },
-    execute: async (args) => {
-        function inferType(value, strict) {
-            if (value === null)
-                return { type: "null" };
-            if (typeof value === "string")
-                return { type: "string" };
-            if (typeof value === "boolean")
-                return { type: "boolean" };
-            if (typeof value === "number") {
-                return Number.isInteger(value) ? { type: "integer" } : { type: "number" };
-            }
-            if (Array.isArray(value)) {
-                if (value.length === 0) {
-                    return { type: "array", items: {} };
-                }
-                return { type: "array", items: inferType(value[0], strict) };
-            }
-            if (typeof value === "object" && value !== null) {
-                const obj = value;
-                const properties = {};
-                const required = [];
-                for (const [key, val] of Object.entries(obj)) {
-                    properties[key] = inferType(val, strict);
-                    required.push(key);
-                }
-                const schema = {
-                    type: "object",
-                    properties,
-                    required
-                };
-                if (strict) {
-                    schema.additionalProperties = false;
-                }
-                return schema;
-            }
-            return {};
-        }
-        const schema = {
-            $schema: "https://json-schema.org/draft/2020-12/schema",
-            ...inferType(args.data, args.strict ?? false)
-        };
-        if (args.title) {
-            schema.title = args.title;
-        }
-        return JSON.stringify(schema, null, 2);
-    }
-});

package/dist/skill/frontmatter.d.ts

@@ -1,2 +0,0 @@
-import { ParsedSkill } from "./types";
-export declare function parseSkillFrontmatter(filePath: string): Promise<ParsedSkill | null>;

package/dist/skill/frontmatter.js

@@ -1,65 +0,0 @@
-import { ExtendedSkillFrontmatter } from "./types";
-const FRONTMATTER_REGEX = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
-export async function parseSkillFrontmatter(filePath) {
-    const file = Bun.file(filePath);
-    const content = await file.text().catch(() => null);
-    if (!content)
-        return null;
-    const match = content.match(FRONTMATTER_REGEX);
-    if (!match)
-        return null;
-    const [, frontmatterYaml, body] = match;
-    let data;
-    try {
-        data = parseSimpleYaml(frontmatterYaml);
-    }
-    catch {
-        return null;
-    }
-    const parsed = ExtendedSkillFrontmatter.safeParse(data);
-    if (!parsed.success)
-        return null;
-    return {
-        frontmatter: parsed.data,
-        content: body.trim(),
-        location: filePath,
-    };
-}
-function parseSimpleYaml(yaml) {
-    const result = {};
-    let currentKey = "";
-    let currentArray = null;
-    for (const line of yaml.split("\n")) {
-        const trimmed = line.trimEnd();
-        if (!trimmed)
-            continue;
-        if (trimmed.startsWith("  - ")) {
-            if (currentArray !== null) {
-                currentArray.push(trimmed.slice(4));
-            }
-            continue;
-        }
-        if (currentArray !== null && currentKey) {
-            result[currentKey] = currentArray;
-            currentArray = null;
-        }
-        const colonIndex = trimmed.indexOf(":");
-        if (colonIndex === -1)
-            continue;
-        const key = trimmed.slice(0, colonIndex).trim();
-        const value = trimmed.slice(colonIndex + 1).trim();
-        if (value === "") {
-            currentKey = key;
-            currentArray = [];
-        }
-        else {
-            result[key] = value;
-            currentKey = "";
-            currentArray = null;
-        }
-    }
-    if (currentArray !== null && currentKey) {
-        result[currentKey] = currentArray;
-    }
-    return result;
-}