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

package/dist/skills/pubmed-weekly/pubmed_weekly.py

@@ -21,6 +21,21 @@ import argparse
 from datetime import datetime, timedelta
 from typing import List, Dict, Any
 
+MONTH_MAP = {
+    "Jan": 1,
+    "Feb": 2,
+    "Mar": 3,
+    "Apr": 4,
+    "May": 5,
+    "Jun": 6,
+    "Jul": 7,
+    "Aug": 8,
+    "Sep": 9,
+    "Oct": 10,
+    "Nov": 11,
+    "Dec": 12,
+}
+
 
 def calculate_week() -> str:
     """Calculate the past week's date range (Monday-Sunday).
@@ -46,6 +61,116 @@ def calculate_week() -> str:
     return f"{week_start}-{week_end}"
 
 
+def infer_year(month: int, day: int, hour: int, minute: int) -> int:
+    """Infer year for MMM DD HH:MM format.
+
+    Uses current year if date is not in the future.
+    Uses previous year if inferred date is in the future.
+
+    Args:
+        month: Month number (1-12)
+        day: Day of month
+        hour: Hour (0-23)
+        minute: Minute (0-59)
+
+    Returns:
+        Inferred year as integer
+    """
+    now = datetime.now()
+    date_this_year = datetime(now.year, month, day, hour, minute)
+
+    if date_this_year > now:
+        return now.year - 1
+    return now.year
+
+
+def parse_ftp_listing_to_dict(content: str) -> Dict[str, datetime]:
+    """Parse FTP directory listing into {filename: datetime} dict.
+
+    Supports multiple date formats with regex fallback chain:
+    1. Unix ls format - MMM DD HH:MM (current year)
+    2. Unix ls format - MMM DD  YYYY (older files)
+    3. ISO 8601 format - YYYY-MM-DD HH:MM
+    4. European format - DD-MMM-YYYY HH:MM
+
+    Args:
+        content: Raw FTP directory listing content
+
+    Returns:
+        Dictionary mapping filename to datetime object
+    """
+    file_dates = {}
+
+    for line in content.split("\n"):
+        line = line.strip()
+        if not line or line.startswith("total"):
+            continue
+
+        filename = None
+        file_date = None
+
+        match = re.match(
+            r"^\S+\s+\d+\s+\S+\s+\S+\s+\d+\s+(\w{3})\s+(\d{1,2})\s+(\d{2}:\d{2})\s+(.+)$",
+            line,
+        )
+        if match:
+            month_str, day_str, time_str, fn = match.groups()
+            month = MONTH_MAP.get(month_str)
+            if month:
+                day = int(day_str)
+                hour, minute = map(int, time_str.split(":"))
+                year = infer_year(month, day, hour, minute)
+                filename = fn
+                file_date = datetime(year, month, day, hour, minute)
+
+        if not file_date:
+            match = re.match(
+                r"^\S+\s+\d+\s+\S+\s+\S+\s+\d+\s+(\w{3})\s+(\d{1,2})\s+(\d{4})\s+(.+)$",
+                line,
+            )
+            if match:
+                month_str, day_str, year_str, fn = match.groups()
+                month = MONTH_MAP.get(month_str)
+                if month:
+                    year = int(year_str)
+                    day = int(day_str)
+                    filename = fn
+                    file_date = datetime(year, month, day)
+
+        if not file_date:
+            match = re.match(r"^(\d{4}-\d{2}-\d{2})\s+(\d{2}:\d{2})\s+(.+)$", line)
+            if match:
+                date_str, time_str, fn = match.groups()
+                datetime_str = f"{date_str} {time_str}"
+                try:
+                    file_date = datetime.strptime(datetime_str, "%Y-%m-%d %H:%M")
+                    filename = fn
+                except ValueError:
+                    pass
+
+        if not file_date:
+            match = re.match(
+                r"^(\d{1,2})-(\w{3})-(\d{4})\s+(\d{2}:\d{2})\s+(.+)$", line
+            )
+            if match:
+                day_str, month_str, year_str, time_str, fn = match.groups()
+                month = MONTH_MAP.get(month_str)
+                if month:
+                    day = int(day_str)
+                    year = int(year_str)
+                    hour, minute = map(int, time_str.split(":"))
+                    try:
+                        file_date = datetime(year, month, day, hour, minute)
+                        filename = fn
+                    except ValueError:
+                        pass
+
+        if filename and file_date and filename not in file_dates:
+            file_dates[filename] = file_date
+
+    return file_dates
+
+
 def parse_date_from_filename(filename: str) -> datetime | None:
     """Extract date from PubMed filename.
 
@@ -147,37 +272,13 @@ def filter_files_by_date(week_name: str, file_list: List[str]) -> List[str]:
         with urllib.request.urlopen(url) as response:
             content = response.read().decode("utf-8", errors="ignore")
 
-        # Parse file listings with dates
-        # NCBI FTP format uses ISO date: "2026-01-30 14:02"
-        file_dates = {}
-
-        for filename in file_list:
-            # Find the line containing this file
-            # Pattern: filename followed by non-digits, then date YYYY-MM-DD HH:MM
-            pattern = re.escape(filename)
-            match = re.search(
-                rf"({pattern})[^0-9]*(\d{{4}}-\d{{2}}-\d{{2}})\s+(\d{{2}}:\d{{2}})",
-                content,
-            )
-
-            if match:
-                date_str = match.group(2)
-                time_str = match.group(3)
-                try:
-                    # Parse date in ISO format: "2026-01-30 14:02"
-                    file_date = datetime.strptime(
-                        f"{date_str} {time_str}", "%Y-%m-%d %H:%M"
-                    )
-
-                    file_dates[filename] = file_date
-                except ValueError:
-                    continue
+        file_dates = parse_ftp_listing_to_dict(content)
 
-        # Filter files within date range
+        # Filter files within date range AND in provided file_list
         filtered_files = [
-            filename
-            for filename, file_date in file_dates.items()
-            if start_date <= file_date <= end_date
+            f
+            for f in file_list
+            if f in file_dates and start_date <= file_dates[f] <= end_date
         ]
 
         return sorted(filtered_files)

package/dist/{db-tools → tools/db}/backends/mysql/translator.js

@@ -40,28 +40,28 @@ export function mapMySQLColumnsToSchema(rows) {
         comment: row.Comment || row.COLUMN_COMMENT || row.comment || null,
     }));
 }
-export const LIST_TABLES_SQL = `
-  SELECT 
-    TABLE_NAME,
-    TABLE_TYPE,
-    ENGINE,
-    TABLE_ROWS,
-    CREATE_TIME,
-    TABLE_COMMENT
-  FROM information_schema.TABLES 
-  WHERE TABLE_SCHEMA = DATABASE()
-  ORDER BY TABLE_NAME
+export const LIST_TABLES_SQL = `
+  SELECT 
+    TABLE_NAME,
+    TABLE_TYPE,
+    ENGINE,
+    TABLE_ROWS,
+    CREATE_TIME,
+    TABLE_COMMENT
+  FROM information_schema.TABLES 
+  WHERE TABLE_SCHEMA = DATABASE()
+  ORDER BY TABLE_NAME
 `;
-export const DESCRIBE_TABLE_SQL = `
-  SELECT 
-    COLUMN_NAME as Field,
-    COLUMN_TYPE as Type,
-    IS_NULLABLE as \`Null\`,
-    COLUMN_KEY as \`Key\`,
-    COLUMN_DEFAULT as \`Default\`,
-    EXTRA as Extra,
-    COLUMN_COMMENT as Comment
-  FROM information_schema.COLUMNS 
-  WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
-  ORDER BY ORDINAL_POSITION
+export const DESCRIBE_TABLE_SQL = `
+  SELECT 
+    COLUMN_NAME as Field,
+    COLUMN_TYPE as Type,
+    IS_NULLABLE as \`Null\`,
+    COLUMN_KEY as \`Key\`,
+    COLUMN_DEFAULT as \`Default\`,
+    EXTRA as Extra,
+    COLUMN_COMMENT as Comment
+  FROM information_schema.COLUMNS 
+  WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
+  ORDER BY ORDINAL_POSITION
 `;

package/dist/{db-tools → tools/db}/tools.js

@@ -13,17 +13,17 @@ async function getOrCreateBackend() {
     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\`
-
-**Parameters:**
-- Use named placeholders like \`:paramName\` for parameters
-- Pass parameter values in the \`params\` object: \`{ "status": "active", "date": "2024-01-01" }\`
-
+    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\`
+
+**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).`,
     args: {
         sql: z.string().describe('SELECT SQL query to execute. Use named placeholders like :name for parameters.'),
@@ -48,15 +48,15 @@ export const dbQuery = tool({
     },
 });
 export const dbListTables = tool({
-    description: `List all tables/collections in the current database with metadata.
-
-**Returns:**
-- Table/collection names and types (TABLE, VIEW, COLLECTION)
-- Storage engine (InnoDB, MyISAM, etc.) for MySQL
-- Approximate row count
-- Creation time (MySQL only)
-- Table comments
-
+    description: `List all tables/collections in the current database with metadata.
+
+**Returns:**
+- Table/collection names and types (TABLE, VIEW, COLLECTION)
+- Storage engine (InnoDB, MyISAM, etc.) for MySQL
+- Approximate row count
+- Creation time (MySQL only)
+- Table comments
+
 **Usage:** Call this first to discover what tables are available before using dbDescribeTable or dbQuery.`,
     args: {},
     execute: async (_args, _context) => {
@@ -72,20 +72,20 @@ export const dbListTables = tool({
     },
 });
 export const dbDescribeTable = tool({
-    description: `Get the column schema for a specific table/collection.
-
-**Returns for each column/field:**
-- Field name
-- Data type (VARCHAR, INT, TEXT, DATETIME, etc.)
-- Nullable status
-- Key type (PRI for primary key, UNI for unique, MUL for multiple)
-- Default value
-- Extra info (auto_increment, etc.)
-- Column comments
-
-**Workflow:**
-1. Use \`dbListTables\` first to see available tables/collections
-2. Use this tool to understand the column/field structure
+    description: `Get the column schema for a specific table/collection.
+
+**Returns for each column/field:**
+- Field name
+- Data type (VARCHAR, INT, TEXT, DATETIME, etc.)
+- Nullable status
+- Key type (PRI for primary key, UNI for unique, MUL for multiple)
+- Default value
+- Extra info (auto_increment, etc.)
+- Column comments
+
+**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 tables.'),

package/dist/{misc-tools → tools/misc}/json-validate.js

@@ -89,10 +89,8 @@ export const jsonValidate = tool({
         let parsedData;
         let parsedSchema;
         let schemaString = args.schema;
-        const isWindowsPath = /^[A-Za-z]:[/\\]/.test(args.schema);
-        const isUnixPath = /^\//.test(args.schema);
-        const isRelativePath = /^\.{1,2}(\/|\\)/.test(args.schema);
-        if (isWindowsPath || isUnixPath || isRelativePath) {
+        const looksLikeInlineJson = /^\s*[\[{]/.test(args.schema);
+        if (!looksLikeInlineJson) {
             const resolvedPath = path.isAbsolute(args.schema)
                 ? args.schema
                 : path.join(context.directory, args.schema);
@@ -110,7 +108,8 @@ export const jsonValidate = tool({
                         hints: [
                             'Check the file path for typos',
                             'Ensure file exists and is accessible',
-                            'Use a relative path from the project directory'
+                            'Use a relative path from the project directory',
+                            'Or provide schema as inline JSON string (starting with { or [)'
                         ]
                     }
                 }, null, 2);

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

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

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

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

package/dist/tools/parser/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/tools/parser/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);
+        }
+    }
+});