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

package/dist/tools/parser/obo/types.d.ts

@@ -0,0 +1,166 @@
+export interface OBOHeader {
+    format_version?: string;
+    data_version?: string;
+    date?: string;
+    saved_by?: string;
+    auto_generated_by?: string;
+    import?: string | string[];
+    subsetdefs: OBOSubsetDef[];
+    synonymtypedefs: OBOSynonymTypeDef[];
+    default_namespace?: string;
+    ontology?: string;
+    idspace?: string;
+    remark?: string | string[];
+    property_values?: OBOPropertyValue[];
+    owl_axioms?: string;
+    [key: string]: any;
+}
+export interface OBOSubsetDef {
+    id: string;
+    name: string;
+}
+export interface OBOSynonymTypeDef {
+    id: string;
+    name: string;
+    scope?: string;
+}
+export interface OBOPropertyValue {
+    tag: string;
+    value: string;
+    xsd_type?: string;
+    qualifiers?: OBOSynonymTypeDef[];
+}
+export interface TermFrame {
+    frame_type: 'term';
+    id: string;
+    is_anonymous?: boolean;
+    name?: string;
+    namespace?: string;
+    alt_ids?: string[];
+    def?: string;
+    comment?: string;
+    subsets?: string[];
+    synonyms?: OBOSynonym[];
+    xrefs?: string[];
+    builtin?: boolean;
+    property_values?: OBOPropertyValue[];
+    is_a?: string[];
+    intersection_of?: string[];
+    union_of?: string[];
+    equivalent_to?: string[];
+    disjoint_from?: string[];
+    relationships?: OBORelationship[];
+    is_obsolete?: boolean;
+    replaced_by?: string;
+    consider?: string;
+    created_by?: string;
+    creation_date?: string;
+}
+export interface TypedefFrame {
+    frame_type: 'typedef';
+    id: string;
+    is_anonymous?: boolean;
+    name?: string;
+    namespace?: string;
+    alt_ids?: string[];
+    def?: string;
+    comment?: string;
+    subsets?: string[];
+    synonyms?: OBOSynonym[];
+    xrefs?: string[];
+    builtin?: boolean;
+    property_values?: OBOPropertyValue[];
+    domain?: string;
+    range?: string;
+    holds_over_chain?: string[];
+    is_anti_symmetric?: boolean;
+    is_cyclic?: boolean;
+    is_reflexive?: boolean;
+    is_symmetric?: boolean;
+    is_transitive?: boolean;
+    is_functional?: boolean;
+    is_inverse_functional?: boolean;
+    is_a?: string[];
+    intersection_of?: string[];
+    union_of?: string[];
+    equivalent_to?: string[];
+    disjoint_from?: string[];
+    inverse_of?: string;
+    transitive_over?: string;
+    equivalent_to_chain?: string[];
+    disjoint_over?: string;
+    relationships?: OBORelationship[];
+    is_obsolete?: boolean;
+    replaced_by?: string;
+    consider?: string;
+    created_by?: string;
+    creation_date?: string;
+    expand_assertion_to?: string;
+    expand_expression_to?: string;
+    is_metadata_tag?: boolean;
+    is_class_level?: boolean;
+}
+export interface InstanceFrame {
+    frame_type: 'instance';
+    id: string;
+    is_anonymous?: boolean;
+    name?: string;
+    namespace?: string;
+    alt_ids?: string[];
+    def?: string;
+    comment?: string;
+    subsets?: string[];
+    synonyms?: OBOSynonym[];
+    xrefs?: string[];
+    builtin?: boolean;
+    property_values?: OBOPropertyValue[];
+    instance_of?: string;
+    relationships?: OBORelationship[];
+    is_obsolete?: boolean;
+    replaced_by?: string;
+    consider?: string;
+    created_by?: string;
+    creation_date?: string;
+}
+export interface OBOSynonym {
+    text: string;
+    scope?: 'EXACT' | 'BROAD' | 'NARROW' | 'RELATED';
+    type?: string;
+    xrefs?: string[];
+}
+export interface OBORelationship {
+    type: string;
+    value: string;
+    qualifiers?: OBOSynonymTypeDef[];
+}
+export interface OBODocument {
+    header: OBOHeader;
+    frames: (TermFrame | TypedefFrame | InstanceFrame)[];
+}
+export interface CSVRow {
+    frame_type: string;
+    id: string;
+    name?: string;
+    namespace?: string;
+    def?: string;
+    synonyms?: string;
+    subsets?: string;
+    xrefs?: string;
+    relationships?: string;
+    comment?: string;
+    is_obsolete?: boolean;
+    created_by?: string;
+    creation_date?: string;
+    alt_ids?: string;
+    is_anonymous?: boolean;
+    parent?: string;
+    domain?: string;
+    range?: string;
+    instance_of?: string;
+}
+export interface ProcessingStats {
+    total: number;
+    terms: number;
+    typedefs: number;
+    instances: number;
+}

package/dist/tools/parser/obo/utils.d.ts

@@ -0,0 +1,21 @@
+import { TermFrame, TypedefFrame, InstanceFrame, CSVRow, OBOSynonym, OBORelationship, OBOSubsetDef, OBOSynonymTypeDef } from './types.js';
+export declare function stripComment(value: string): string;
+export declare function parseLine(line: string): {
+    tag: string | null;
+    value: string;
+} | null;
+export declare function parseQuotedString(value: string): string;
+export declare function parseXrefList(value: string): string[];
+export declare function parseSynonym(value: string): OBOSynonym;
+export declare function parseRelationship(input: string): OBORelationship;
+export declare function createEmptyTermFrame(): TermFrame;
+export declare function createEmptyTypedefFrame(): TypedefFrame;
+export declare function createEmptyInstanceFrame(): InstanceFrame;
+export declare function processTagValue(frame: TermFrame | TypedefFrame | InstanceFrame, tag: string, value: string): void;
+export declare function parsePropertyValue(value: string): any;
+export declare function parseHeader(lines: string[]): OBOSubsetDef[] | OBOSynonymTypeDef[];
+export declare function flattenSynonyms(synonyms?: OBOSynonym[]): string;
+export declare function flattenRelationships(relationships?: OBORelationship[]): string;
+export declare function flattenArray(arr?: string[]): string;
+export declare function frameToCSVRow(frame: TermFrame | TypedefFrame | InstanceFrame): CSVRow;
+export declare function generateCSV(rows: CSVRow[]): string;

package/dist/tools/parser/obo/utils.js

@@ -0,0 +1,411 @@
+export function stripComment(value) {
+    const exclamationIndex = value.indexOf('!');
+    if (exclamationIndex === -1)
+        return value.trim();
+    return value.substring(0, exclamationIndex).trim();
+}
+export function parseLine(line) {
+    if (!line || line.trim().startsWith('!'))
+        return null;
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1)
+        return null;
+    const tag = line.substring(0, colonIndex).trim();
+    const value = line.substring(colonIndex + 1).trim();
+    return { tag, value };
+}
+export function parseQuotedString(value) {
+    if (value.startsWith('"') && value.endsWith('"')) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+export function parseXrefList(value) {
+    const stripped = stripComment(value);
+    if (stripped.startsWith('[') && stripped.endsWith(']')) {
+        const content = stripped.slice(1, -1).trim();
+        if (!content)
+            return [];
+        return content.split(',').map(x => x.trim()).filter(x => x.length > 0);
+    }
+    return [stripped];
+}
+export function parseSynonym(value) {
+    const stripped = stripComment(value);
+    let text = stripped;
+    let scope;
+    let type;
+    let xrefs;
+    const quotedMatch = stripped.match(/^"([^"]+)"/);
+    if (quotedMatch) {
+        text = quotedMatch[1];
+    }
+    else {
+        text = stripped;
+    }
+    const parts = text.split(/\s+/).filter(p => p.length > 0);
+    const scopeIndex = parts.findIndex(p => p === 'EXACT' || p === 'BROAD' || p === 'NARROW' || p === 'RELATED');
+    if (scopeIndex !== -1) {
+        scope = parts[scopeIndex];
+        parts.splice(scopeIndex, 1);
+    }
+    if (parts.length > 1 && !parts[1].startsWith('[')) {
+        type = parts[1];
+    }
+    const xrefMatch = stripped.match(/\[([^\]]+)\]/);
+    if (xrefMatch) {
+        const xrefContent = xrefMatch[1].trim();
+        xrefs = xrefContent.split(',').map(x => x.trim()).filter(x => x.length > 0);
+    }
+    return { text, scope, type, xrefs };
+}
+export function parseRelationship(input) {
+    const stripped = stripComment(input);
+    const parts = stripped.split(/\s+/).filter(p => p.length > 0);
+    if (parts.length < 2) {
+        return { type: '', value: stripped };
+    }
+    const type = parts[0];
+    const relValue = parts.slice(1).join(' ');
+    return { type, value: relValue };
+}
+export function createEmptyTermFrame() {
+    return {
+        frame_type: 'term',
+        id: ''
+    };
+}
+export function createEmptyTypedefFrame() {
+    return {
+        frame_type: 'typedef',
+        id: ''
+    };
+}
+export function createEmptyInstanceFrame() {
+    return {
+        frame_type: 'instance',
+        id: ''
+    };
+}
+export function processTagValue(frame, tag, value) {
+    const stripped = stripComment(value);
+    const unquoted = parseQuotedString(stripped);
+    switch (tag) {
+        case 'id':
+            frame.id = stripped;
+            break;
+        case 'name':
+            frame.name = unquoted;
+            break;
+        case 'namespace':
+            frame.namespace = stripped;
+            break;
+        case 'alt_id':
+            if (!frame.alt_ids)
+                frame.alt_ids = [];
+            frame.alt_ids.push(stripped);
+            break;
+        case 'def':
+            frame.def = unquoted;
+            break;
+        case 'comment':
+            frame.comment = unquoted;
+            break;
+        case 'subset':
+            if (!frame.subsets)
+                frame.subsets = [];
+            frame.subsets.push(stripped);
+            break;
+        case 'synonym':
+            if (!frame.synonyms)
+                frame.synonyms = [];
+            frame.synonyms.push(parseSynonym(value));
+            break;
+        case 'xref':
+            if (!frame.xrefs)
+                frame.xrefs = [];
+            frame.xrefs.push(...parseXrefList(value));
+            break;
+        case 'builtin':
+            frame.builtin = stripped.toLowerCase() === 'true';
+            break;
+        case 'is_a':
+            if ('is_a' in frame) {
+                if (!frame.is_a)
+                    frame.is_a = [];
+                frame.is_a.push(stripped);
+            }
+            break;
+        case 'intersection_of':
+            if ('intersection_of' in frame) {
+                if (!frame.intersection_of)
+                    frame.intersection_of = [];
+                frame.intersection_of.push(stripped);
+            }
+            break;
+        case 'union_of':
+            if ('union_of' in frame) {
+                if (!frame.union_of)
+                    frame.union_of = [];
+                frame.union_of.push(stripped);
+            }
+            break;
+        case 'equivalent_to':
+            if ('equivalent_to' in frame) {
+                if (!frame.equivalent_to)
+                    frame.equivalent_to = [];
+                frame.equivalent_to.push(stripped);
+            }
+            break;
+        case 'disjoint_from':
+            if ('disjoint_from' in frame) {
+                if (!frame.disjoint_from)
+                    frame.disjoint_from = [];
+                frame.disjoint_from.push(stripped);
+            }
+            break;
+        case 'relationship':
+            if (!frame.relationships)
+                frame.relationships = [];
+            frame.relationships.push(parseRelationship(value));
+            break;
+        case 'is_obsolete':
+            frame.is_obsolete = stripped.toLowerCase() === 'true';
+            break;
+        case 'replaced_by':
+            frame.replaced_by = stripped;
+            break;
+        case 'consider':
+            frame.consider = stripped;
+            break;
+        case 'created_by':
+            frame.created_by = stripped;
+            break;
+        case 'creation_date':
+            frame.creation_date = stripped;
+            break;
+        case 'is_anonymous':
+            frame.is_anonymous = stripped.toLowerCase() === 'true';
+            break;
+        case 'property_value':
+            if (!frame.property_values)
+                frame.property_values = [];
+            frame.property_values.push(parsePropertyValue(value));
+            break;
+        case 'domain':
+            if ('domain' in frame)
+                frame.domain = stripped;
+            break;
+        case 'range':
+            if ('range' in frame)
+                frame.range = stripped;
+            break;
+        case 'holds_over_chain':
+            if ('holds_over_chain' in frame)
+                frame.holds_over_chain = [];
+            frame.holds_over_chain?.push(stripped);
+            break;
+        case 'is_anti_symmetric':
+            if ('is_anti_symmetric' in frame)
+                frame.is_anti_symmetric = stripped.toLowerCase() === 'true';
+            break;
+        case 'is_cyclic':
+            if ('is_cyclic' in frame)
+                frame.is_cyclic = stripped.toLowerCase() === 'true';
+            break;
+        case 'is_reflexive':
+            if ('is_reflexive' in frame)
+                frame.is_reflexive = stripped.toLowerCase() === 'true';
+            break;
+        case 'is_symmetric':
+            if ('is_symmetric' in frame)
+                frame.is_symmetric = stripped.toLowerCase() === 'true';
+            break;
+        case 'is_transitive':
+            if ('is_transitive' in frame)
+                frame.is_transitive = stripped.toLowerCase() === 'true';
+            break;
+        case 'is_functional':
+            if ('is_functional' in frame)
+                frame.is_functional = stripped.toLowerCase() === 'true';
+            break;
+        case 'is_inverse_functional':
+            if ('is_inverse_functional' in frame)
+                frame.is_inverse_functional = stripped.toLowerCase() === 'true';
+            break;
+        case 'inverse_of':
+            if ('inverse_of' in frame)
+                frame.inverse_of = stripped;
+            break;
+        case 'transitive_over':
+            if ('transitive_over' in frame)
+                frame.transitive_over = stripped;
+            break;
+        case 'equivalent_to_chain':
+            if ('equivalent_to_chain' in frame)
+                frame.equivalent_to_chain = [];
+            frame.equivalent_to_chain?.push(stripped);
+            break;
+        case 'disjoint_over':
+            if ('disjoint_over' in frame)
+                frame.disjoint_over = stripped;
+            break;
+        case 'expand_assertion_to':
+            if ('expand_assertion_to' in frame)
+                frame.expand_assertion_to = unquoted;
+            break;
+        case 'expand_expression_to':
+            if ('expand_expression_to' in frame)
+                frame.expand_expression_to = unquoted;
+            break;
+        case 'is_metadata_tag':
+            if ('is_metadata_tag' in frame)
+                frame.is_metadata_tag = stripped.toLowerCase() === 'true';
+            break;
+        case 'is_class_level':
+            if ('is_class_level' in frame)
+                frame.is_class_level = stripped.toLowerCase() === 'true';
+            break;
+        case 'instance_of':
+            if ('instance_of' in frame)
+                frame.instance_of = stripped;
+            break;
+        default:
+            break;
+    }
+}
+export function parsePropertyValue(value) {
+    const stripped = stripComment(value);
+    const parts = stripped.split(/\s+/);
+    if (parts.length < 1) {
+        return { tag: '', value: '' };
+    }
+    const tag = parts[0];
+    const remaining = parts.slice(1).join(' ');
+    if (remaining.startsWith('"')) {
+        const match = remaining.match(/^"([^"]*)"\s*(.*)$/);
+        if (match) {
+            return {
+                tag,
+                value: match[1],
+                xsd_type: match[2]?.trim() || undefined
+            };
+        }
+    }
+    return { tag, value: remaining };
+}
+export function parseHeader(lines) {
+    const subsetdefs = [];
+    const synonymtypedefs = [];
+    for (const line of lines) {
+        const parsed = parseLine(line);
+        if (!parsed)
+            continue;
+        const { tag, value } = parsed;
+        if (tag === 'subsetdef') {
+            const parts = value.split(/\s+/);
+            const id = parts[0];
+            const nameMatch = value.match(/"([^"]+)"/);
+            const name = nameMatch ? nameMatch[1] : parts[1];
+            subsetdefs.push({ id, name });
+        }
+        else if (tag === 'synonymtypedef') {
+            const parts = value.split(/\s+/);
+            const id = parts[0];
+            const nameMatch = value.match(/"([^"]+)"/);
+            const name = nameMatch ? nameMatch[1] : parts[1];
+            const scope = parts.find(p => p === 'EXACT' || p === 'BROAD' || p === 'NARROW' || p === 'RELATED');
+            synonymtypedefs.push({ id, name, scope });
+        }
+    }
+    return [...subsetdefs, ...synonymtypedefs];
+}
+export function flattenSynonyms(synonyms) {
+    if (!synonyms || synonyms.length === 0)
+        return '';
+    const json = synonyms.map(s => {
+        const obj = { v: s.text };
+        if (s.scope)
+            obj.s = s.scope;
+        if (s.type)
+            obj.t = s.type;
+        if (s.xrefs && s.xrefs.length > 0)
+            obj.x = s.xrefs;
+        return JSON.stringify(obj);
+    });
+    return JSON.stringify(json);
+}
+export function flattenRelationships(relationships) {
+    if (!relationships || relationships.length === 0)
+        return '';
+    const json = relationships.map(r => {
+        const obj = { v: r.value };
+        if (r.qualifiers && r.qualifiers.length > 0)
+            obj.q = r.qualifiers;
+        return JSON.stringify({ t: r.type, ...obj });
+    });
+    return JSON.stringify(json);
+}
+export function flattenArray(arr) {
+    if (!arr || arr.length === 0)
+        return '';
+    return JSON.stringify(arr);
+}
+export function frameToCSVRow(frame) {
+    const row = {
+        frame_type: frame.frame_type,
+        id: frame.id,
+        name: frame.name,
+        namespace: frame.namespace,
+        def: frame.def,
+        comment: frame.comment,
+        is_obsolete: frame.is_obsolete,
+        created_by: frame.created_by,
+        creation_date: frame.creation_date,
+        alt_ids: flattenArray(frame.alt_ids),
+        is_anonymous: frame.is_anonymous,
+        synonyms: flattenSynonyms(frame.synonyms),
+        subsets: flattenArray(frame.subsets),
+        xrefs: flattenArray(frame.xrefs),
+        relationships: flattenRelationships(frame.relationships)
+    };
+    if (frame.frame_type === 'term' && 'is_a' in frame) {
+        const term = frame;
+        row.parent = term.is_a?.[0];
+    }
+    else if (frame.frame_type === 'typedef' && 'domain' in frame) {
+        const typedef = frame;
+        row.domain = typedef.domain;
+        row.range = typedef.range;
+    }
+    else if (frame.frame_type === 'instance' && 'instance_of' in frame) {
+        const instance = frame;
+        row.instance_of = instance.instance_of;
+    }
+    return row;
+}
+export function generateCSV(rows) {
+    if (rows.length === 0)
+        return '';
+    const headers = [
+        'frame_type', 'id', 'name', 'namespace', 'def', 'comment',
+        'is_obsolete', 'created_by', 'creation_date', 'alt_ids', 'is_anonymous',
+        'synonyms', 'subsets', 'xrefs', 'relationships', 'parent', 'domain', 'range', 'instance_of'
+    ];
+    const headerRow = headers.join(',');
+    const dataRows = rows.map(row => {
+        return headers.map(header => {
+            const value = row[header];
+            if (value === undefined || value === null || value === '')
+                return '';
+            if (typeof value === 'boolean')
+                return value ? 'true' : 'false';
+            if (typeof value === 'string') {
+                const escaped = value.replace(/"/g, '""');
+                return `"${escaped}"`;
+            }
+            return '';
+        }).join(',');
+    });
+    return [headerRow, ...dataRows].join('\n');
+}

package/dist/tools/parser/pubmed/types.js

@@ -0,0 +1 @@
+export {};

package/dist/{skill-tools → tools/skill}/registry.js

@@ -29,7 +29,7 @@ export class SkillConflictError extends Error {
 }
 function getPluginSkillsDir() {
     const currentDir = path.dirname(fileURLToPath(import.meta.url));
-    return path.join(currentDir, "..", "skills");
+    return path.join(currentDir, "..", "..", "..", "skills");
 }
 async function loadSkillsFromDir(dir, source) {
     if (!existsSync(dir))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeyuan98/opencode-bioresearcher-plugin",
-  "version": "1.5.0-alpha.0",
+  "version": "1.5.1",
   "description": "OpenCode plugin that adds a bioresearcher agent",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -1,13 +0,0 @@
-import * as mysql from 'mysql2/promise';
-import type { DbConfig, QueryResponse } from './types';
-type QueryParams = Record<string, unknown> | unknown[];
-interface ExecuteQueryOptions {
-    sql: string;
-    params?: QueryParams;
-}
-export declare function getConfigFromEnv(): DbConfig;
-export declare function validateConfig(config: DbConfig): void;
-export declare function executeQuery(options: ExecuteQueryOptions): Promise<QueryResponse>;
-export declare function executeRawQuery<T extends mysql.RowDataPacket[]>(sql: string, params?: QueryParams): Promise<[T, mysql.FieldPacket[]]>;
-export { getPool } from './pool';
-export { closePool } from './pool';

package/dist/db-tools/executor.js

@@ -1,54 +0,0 @@
-import { DEFAULT_CONFIG as defaultConfig } from './types';
-import { formatQueryResult, formatQueryError } from './utils';
-import { getPool } from './pool';
-export function getConfigFromEnv() {
-    const envConfig = {
-        host: process.env.DB_HOST || defaultConfig.host,
-        port: parseInt(process.env.DB_PORT || '', 10) || defaultConfig.port,
-        user: process.env.DB_USER || '',
-        password: process.env.DB_PASSWORD || '',
-        database: process.env.DB_DATABASE || '',
-        charset: process.env.DB_CHARSET || defaultConfig.charset,
-        connectionTimeout: parseInt(process.env.DB_CONNECTION_TIMEOUT || '', 10) || defaultConfig.connectionTimeout,
-    };
-    return envConfig;
-}
-export function validateConfig(config) {
-    const missing = [];
-    if (!config.user)
-        missing.push('DB_USER');
-    if (!config.database)
-        missing.push('DB_DATABASE');
-    if (missing.length > 0) {
-        throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
-    }
-    if (config.port < 1 || config.port > 65535) {
-        throw new Error(`Invalid port number: ${config.port}. Must be between 1 and 65535.`);
-    }
-}
-export async function executeQuery(options) {
-    const startTime = Date.now();
-    try {
-        const config = getConfigFromEnv();
-        validateConfig(config);
-        const pool = getPool(config);
-        const params = options.params ?? [];
-        const [rows, fields] = await pool.query(options.sql, params);
-        const executionTimeMs = Date.now() - startTime;
-        return formatQueryResult(rows, fields, executionTimeMs);
-    }
-    catch (error) {
-        const executionTimeMs = Date.now() - startTime;
-        return formatQueryError(error, executionTimeMs);
-    }
-}
-export async function executeRawQuery(sql, params) {
-    const config = getConfigFromEnv();
-    validateConfig(config);
-    const pool = getPool(config);
-    const queryParams = params ?? [];
-    const result = await pool.query(sql, queryParams);
-    return result;
-}
-export { getPool } from './pool';
-export { closePool } from './pool';

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

@@ -1,8 +0,0 @@
-import * as mysql from 'mysql2/promise';
-import type { DbConfig } from './types';
-export declare function getPool(config: DbConfig): mysql.Pool;
-export declare function closePool(): Promise<void>;
-export declare function getPoolStatus(): {
-    initialized: boolean;
-    hasConfig: boolean;
-};