@yeyuan98/opencode-bioresearcher-plugin 1.5.0 → 1.5.2-alpha.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;
-}

package/dist/skill/index.d.ts

@@ -1,3 +0,0 @@
-export { SkillTool } from "./tool";
-export { getAllSkills, getSkill, clearCache, SkillConflictError } from "./registry";
-export type { ExtendedSkill, ExtendedSkillFrontmatter, ParsedSkill } from "./types";

package/dist/skill/index.js

@@ -1,2 +0,0 @@
-export { SkillTool } from "./tool";
-export { getAllSkills, getSkill, clearCache, SkillConflictError } from "./registry";

package/dist/skill/registry.d.ts

@@ -1,11 +0,0 @@
-import { ExtendedSkill } from "./types";
-export declare class SkillConflictError extends Error {
-    skillName: string;
-    pluginLocation: string;
-    userLocation: string;
-    constructor(skillName: string, pluginLocation: string, userLocation: string);
-}
-export declare function loadPluginSkills(): Promise<ExtendedSkill[]>;
-export declare function getAllSkills(): Promise<ExtendedSkill[]>;
-export declare function getSkill(name: string): Promise<ExtendedSkill | undefined>;
-export declare function clearCache(): void;

package/dist/skill/registry.js

@@ -1,64 +0,0 @@
-import path from "path";
-import { fileURLToPath } from "url";
-import { parseSkillFrontmatter } from "./frontmatter";
-const SKILL_GLOB = new Bun.Glob("**/SKILL.md");
-export class SkillConflictError extends Error {
-    skillName;
-    pluginLocation;
-    userLocation;
-    constructor(skillName, pluginLocation, userLocation) {
-        super(`Skill name conflict: "${skillName}" is reserved by the plugin. ` +
-            `Please rename your skill at ${userLocation}.`);
-        this.skillName = skillName;
-        this.pluginLocation = pluginLocation;
-        this.userLocation = userLocation;
-        this.name = "SkillConflictError";
-    }
-}
-function getPluginSkillsDir() {
-    const currentDir = path.dirname(fileURLToPath(import.meta.url));
-    return path.join(currentDir, "..", "skills");
-}
-export async function loadPluginSkills() {
-    const skillsDir = getPluginSkillsDir();
-    const skills = [];
-    try {
-        for await (const match of SKILL_GLOB.scan({
-            cwd: skillsDir,
-            absolute: true,
-            onlyFiles: true,
-        })) {
-            const parsed = await parseSkillFrontmatter(match);
-            if (!parsed)
-                continue;
-            skills.push({
-                name: parsed.frontmatter.name,
-                description: parsed.frontmatter.description,
-                location: parsed.location,
-                content: parsed.content,
-                agent: parsed.frontmatter.agent,
-                allowedTools: parsed.frontmatter.allowedTools,
-                source: "plugin",
-            });
-        }
-    }
-    catch {
-        // Plugin skills directory may not exist
-    }
-    return skills;
-}
-let cachedSkills = null;
-export async function getAllSkills() {
-    if (cachedSkills)
-        return cachedSkills;
-    const pluginSkills = await loadPluginSkills();
-    cachedSkills = pluginSkills;
-    return pluginSkills;
-}
-export async function getSkill(name) {
-    const skills = await getAllSkills();
-    return skills.find((s) => s.name === name);
-}
-export function clearCache() {
-    cachedSkills = null;
-}

package/dist/skill/tool.d.ts

@@ -1,9 +0,0 @@
-export declare const SkillTool: {
-    description: string;
-    args: {
-        name: import("zod").ZodString;
-    };
-    execute(args: {
-        name: string;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
-};

package/dist/skill/tool.js

@@ -1,115 +0,0 @@
-import path from "path";
-import { pathToFileURL } from "url";
-import { tool } from "@opencode-ai/plugin";
-import { getAllSkills, getSkill } from "./registry";
-function formatDescription(skills) {
-    if (skills.length === 0) {
-        return "Load a specialized skill that provides domain-specific instructions and workflows. No skills are currently available.";
-    }
-    return [
-        "Load a specialized skill that provides domain-specific instructions and workflows.",
-        "",
-        "When you recognize that a task matches one of the available skills listed below, use this tool to load the full skill instructions.",
-        "",
-        "The skill will inject detailed instructions, workflows, and access to bundled resources (scripts, references, templates) into the conversation context.",
-        "",
-        'Tool output includes a `<skill_content name="...">` block with the loaded content.',
-        "",
-        "The following skills provide specialized sets of instructions for particular tasks:",
-        "",
-        "<available_skills>",
-        ...skills.flatMap((skill) => [
-            `  <skill>`,
-            `    <name>${skill.name}</name>`,
-            `    <description>${skill.description}</description>`,
-            skill.agent ? `    <restricted_to_agent>${skill.agent}</restricted_to_agent>` : null,
-            `    <location>${pathToFileURL(skill.location).href}</location>`,
-            `  </skill>`,
-        ].filter(Boolean)),
-        "</available_skills>",
-    ].join("\n");
-}
-async function listSkillFiles(dir, signal) {
-    const limit = 10;
-    const files = [];
-    const glob = new Bun.Glob("*");
-    try {
-        for await (const file of glob.scan({ cwd: dir, onlyFiles: true })) {
-            if (file === "SKILL.md")
-                continue;
-            files.push(path.resolve(dir, file));
-            if (files.length >= limit)
-                break;
-        }
-    }
-    catch {
-        // Directory may not exist
-    }
-    return files.map((f) => `<file>${f}</file>`).join("\n");
-}
-export const SkillTool = tool({
-    description: "", // Set dynamically below
-    args: {
-        name: tool.schema.string().describe("The name of the skill from available_skills"),
-    },
-    async execute(params, ctx) {
-        const skills = await getAllSkills();
-        const skill = await getSkill(params.name);
-        if (!skill) {
-            const available = skills.map((s) => s.name).join(", ");
-            throw new Error(`Skill "${params.name}" not found. Available skills: ${available || "none"}`);
-        }
-        // Agent routing enforcement
-        if (skill.agent && ctx.agent !== skill.agent) {
-            throw new Error(`Skill "${skill.name}" is restricted to agent "${skill.agent}". Current agent: "${ctx.agent || "unknown"}".`);
-        }
-        await ctx.ask({
-            permission: "skill",
-            patterns: [params.name],
-            always: [params.name],
-            metadata: {},
-        });
-        const dir = path.dirname(skill.location);
-        const base = pathToFileURL(dir).href;
-        const files = await listSkillFiles(dir, ctx.abort);
-        const allowedToolsSection = skill.allowedTools
-            ? [
-                "",
-                "<allowed_tools>",
-                "This skill is designed to work with the following tools:",
-                ...skill.allowedTools.map((t) => `  - ${t}`),
-                "</allowed_tools>",
-            ].join("\n")
-            : "";
-        ctx.metadata({
-            title: `Loaded skill: ${skill.name}`,
-            metadata: {
-                name: skill.name,
-                dir,
-                allowedTools: skill.allowedTools,
-                agent: skill.agent,
-            },
-        });
-        return [
-            `<skill_content name="${skill.name}">`,
-            `# Skill: ${skill.name}`,
-            "",
-            skill.content.trim(),
-            "",
-            `Base directory for this skill: ${base}`,
-            "Relative paths in this skill (e.g., scripts/, reference/) are relative to this base directory.",
-            "Note: file list is sampled.",
-            "",
-            "<skill_files>",
-            files,
-            "</skill_files>",
-            allowedToolsSection,
-            "</skill_content>",
-        ].join("\n");
-    },
-});
-// Set description dynamically based on available skills
-getAllSkills().then((skills) => {
-    ;
-    SkillTool.description = formatDescription(skills);
-});

package/dist/skill/types.d.ts

@@ -1,22 +0,0 @@
-import z from "zod";
-export declare const ExtendedSkillFrontmatter: z.ZodObject<{
-    name: z.ZodString;
-    description: z.ZodString;
-    agent: z.ZodOptional<z.ZodString>;
-    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export type ExtendedSkillFrontmatter = z.infer<typeof ExtendedSkillFrontmatter>;
-export interface ExtendedSkill {
-    name: string;
-    description: string;
-    location: string;
-    content: string;
-    agent?: string;
-    allowedTools?: string[];
-    source: "plugin";
-}
-export interface ParsedSkill {
-    frontmatter: ExtendedSkillFrontmatter;
-    content: string;
-    location: string;
-}

package/dist/skill/types.js

@@ -1,7 +0,0 @@
-import z from "zod";
-export const ExtendedSkillFrontmatter = z.object({
-    name: z.string(),
-    description: z.string(),
-    agent: z.string().optional(),
-    allowedTools: z.array(z.string()).optional(),
-});