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

package/README.md

@@ -75,8 +75,20 @@ Parse PubMed XML files to markdown or Excel format. Supports `.xml` and `.xml.gz
 Download pubmed article data from https://ftp.ncbi.nlm.nih.gov/pubmed/updatefiles/pubmed26n1340.xml.gz and parse to Excel format.
 ```
 
-Reference: [PubMed Download Data](https://pubmed.ncbi.nlm.nih.gov/download/).
-
+Reference: [PubMed Download Data](https://pubmed.ncbi.nlm.nih.gov/download/).
+
+### OBO Parser
+
+Parse OBO (Open Biological and Biomedical Ontology) files to CSV format. Handles Term, Typedef, and Instance frames.
+
+**Flatten complex ontologies into analysis-ready tables.**
+
+```text
+Parse go.obo file and convert to CSV using parse_obo_file tool.
+```
+
+Reference: [OBO Format](http://owlcollab.github.io/oboformat/doc/obo-syntax.html).
+
 ### JSON Tools
 
 Extract, validate, and infer JSON schemas from data.

package/dist/index.js

@@ -5,6 +5,7 @@ import { tableTools } from "./table-tools/index";
 import { dbTools } from "./db-tools/index";
 import { blockingTimer, calculator, jsonExtract, jsonValidate, jsonInfer } from "./misc-tools/index";
 import { parse_pubmed_articleSet } from "./parser-tools/pubmed";
+import { parse_obo_file } from "./parser-tools/obo";
 import { SkillTool } from "./skill-tools";
 export const BioResearcherPlugin = async () => {
     return {
@@ -23,7 +24,8 @@ export const BioResearcherPlugin = async () => {
             jsonExtract,
             jsonValidate,
             jsonInfer,
-            parse_pubmed_articleSet
+            parse_pubmed_articleSet,
+            parse_obo_file
         }
     };
 };

package/dist/parser-tools/obo/index.d.ts

@@ -0,0 +1,2 @@
+export { parse_obo_file } from './obo.js';
+export * from './types.js';

package/dist/parser-tools/obo/index.js

@@ -0,0 +1,2 @@
+export { parse_obo_file } from './obo.js';
+export * from './types.js';

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

@@ -0,0 +1,17 @@
+import { ToolContext } from '@opencode-ai/plugin/tool';
+import { z } from 'zod';
+export declare const parse_obo_file: {
+    description: string;
+    args: {
+        filePath: z.ZodString;
+        outputFileName: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+        outputDir: z.ZodOptional<z.ZodString>;
+        verbose: z.ZodDefault<z.ZodBoolean>;
+    };
+    execute(args: {
+        filePath: string;
+        outputFileName: string;
+        verbose: boolean;
+        outputDir?: string | undefined;
+    }, context: ToolContext): Promise<string>;
+};

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

@@ -0,0 +1,216 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { z } from 'zod';
+import { parseLine, createEmptyTermFrame, createEmptyTypedefFrame, createEmptyInstanceFrame, processTagValue, frameToCSVRow, generateCSV } from './utils.js';
+function formatError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return JSON.stringify({ error: message }, null, 2);
+}
+function resolvePath(filePath, basePath) {
+    if (!basePath) {
+        return filePath;
+    }
+    if (filePath.startsWith('./') || filePath.startsWith('../')) {
+        return resolve(basePath, filePath);
+    }
+    if (filePath.startsWith('/') || /^[A-Za-z]:/.test(filePath)) {
+        return filePath;
+    }
+    return resolve(basePath, filePath);
+}
+function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+function parseOBOFile(content) {
+    const lines = content.split('\n');
+    const header = {
+        subsetdefs: [],
+        synonymtypedefs: []
+    };
+    const frames = [];
+    let currentFrame = null;
+    let inHeader = true;
+    let termCount = 0;
+    let typedefCount = 0;
+    let instanceCount = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith('!')) {
+            continue;
+        }
+        if (trimmed === '[Term]') {
+            inHeader = false;
+            if (currentFrame) {
+                frames.push(currentFrame);
+            }
+            currentFrame = createEmptyTermFrame();
+            termCount++;
+        }
+        else if (trimmed === '[Typedef]') {
+            inHeader = false;
+            if (currentFrame) {
+                frames.push(currentFrame);
+            }
+            currentFrame = createEmptyTypedefFrame();
+            typedefCount++;
+        }
+        else if (trimmed === '[Instance]') {
+            inHeader = false;
+            if (currentFrame) {
+                frames.push(currentFrame);
+            }
+            currentFrame = createEmptyInstanceFrame();
+            instanceCount++;
+        }
+        else if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+            if (currentFrame) {
+                frames.push(currentFrame);
+                currentFrame = null;
+            }
+        }
+        else if (inHeader) {
+            const parsed = parseLine(line);
+            if (parsed) {
+                const { tag, value } = parsed;
+                switch (tag) {
+                    case 'format-version':
+                        header.format_version = value;
+                        break;
+                    case 'data-version':
+                        header.data_version = value;
+                        break;
+                    case 'date':
+                        header.date = value;
+                        break;
+                    case 'saved-by':
+                        header.saved_by = value;
+                        break;
+                    case 'auto-generated-by':
+                        header.auto_generated_by = value;
+                        break;
+                    case 'import':
+                        if (!header.import)
+                            header.import = [];
+                        if (Array.isArray(header.import)) {
+                            header.import.push(value);
+                        }
+                        else {
+                            header.import = [header.import, value];
+                        }
+                        break;
+                    case 'default-namespace':
+                        header.default_namespace = value;
+                        break;
+                    case 'ontology':
+                        header.ontology = value;
+                        break;
+                    case 'remark':
+                        if (!header.remark)
+                            header.remark = [];
+                        if (Array.isArray(header.remark)) {
+                            header.remark.push(value);
+                        }
+                        else {
+                            header.remark = [header.remark, value];
+                        }
+                        break;
+                    case 'property_value':
+                        if (!header.property_values)
+                            header.property_values = [];
+                        header.property_values.push({ tag: '', value });
+                        break;
+                    case 'owl-axioms':
+                        header.owl_axioms = value;
+                        break;
+                }
+            }
+        }
+        else if (currentFrame) {
+            const parsed = parseLine(line);
+            if (parsed && parsed.tag) {
+                processTagValue(currentFrame, parsed.tag, parsed.value);
+            }
+        }
+    }
+    if (currentFrame) {
+        frames.push(currentFrame);
+    }
+    const stats = {
+        total: termCount + typedefCount + instanceCount,
+        terms: termCount,
+        typedefs: typedefCount,
+        instances: instanceCount
+    };
+    return { document: { header, frames }, stats };
+}
+export const parse_obo_file = tool({
+    description: 'Parse OBO (Open Biological and Biomedical Ontology) files and convert to CSV format. Handles Term, Typedef, and Instance frames with proper escaping and comment handling.',
+    args: {
+        filePath: z.string()
+            .describe('Path to OBO file (.obo)'),
+        outputFileName: z.string()
+            .optional()
+            .default('obo_output.csv')
+            .describe('Custom output CSV file name (default: obo_output.csv)'),
+        outputDir: z.string()
+            .optional()
+            .describe('Custom output directory (default: ./tmp/opencode/<sessionId>/)'),
+        verbose: z.boolean()
+            .default(false)
+            .describe('Enable verbose logging for debugging')
+    },
+    execute: async (args, context) => {
+        const verbose = args.verbose ?? false;
+        try {
+            const { filePath, outputFileName = 'obo_output.csv', outputDir } = args;
+            if (verbose)
+                console.log('Starting OBO file parsing...');
+            const resolvedPath = resolvePath(outputDir || './tmp/opencode', context.directory);
+            ensureDir(resolvedPath);
+            if (verbose)
+                console.log(`Output directory: ${resolvedPath}`);
+            if (verbose)
+                console.log(`Reading file: ${filePath}`);
+            const fileContent = readFileSync(filePath, 'utf-8');
+            if (verbose)
+                console.log('Parsing OBO document...');
+            const { document, stats } = parseOBOFile(fileContent);
+            if (verbose) {
+                console.log(`Parsing complete:`);
+                console.log(`  Total frames: ${stats.total}`);
+                console.log(`  Terms: ${stats.terms}`);
+                console.log(`  Typedefs: ${stats.typedefs}`);
+                console.log(`  Instances: ${stats.instances}`);
+            }
+            const csvRows = [];
+            if (verbose)
+                console.log('Flattening frames to CSV rows...');
+            for (const frame of document.frames) {
+                csvRows.push(frameToCSVRow(frame));
+            }
+            if (verbose)
+                console.log(`Converted ${csvRows.length} frames to CSV rows`);
+            const csvContent = generateCSV(csvRows);
+            const outputPath = join(resolvedPath, outputFileName);
+            writeFileSync(outputPath, csvContent, 'utf-8');
+            if (verbose)
+                console.log(`Wrote CSV file: ${outputPath}`);
+            return JSON.stringify({
+                success: true,
+                filePath: outputPath,
+                stats: stats,
+                message: `Successfully parsed ${stats.total} frames (${stats.terms} terms, ${stats.typedefs} typedefs, ${stats.instances} instances) to ${outputPath}`
+            });
+        }
+        catch (error) {
+            if (verbose)
+                console.error(`Error: ${error.message}`);
+            return formatError(error);
+        }
+    }
+});

package/dist/parser-tools/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/parser-tools/obo/types.js

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

package/dist/parser-tools/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/parser-tools/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/package.json

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