opc-agent 4.1.0 → 4.1.2

package/src/mcp/servers/database-mcp.ts

@@ -1,72 +1,72 @@
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-// In-memory SQL-like database (no external deps)
-interface Table { columns: string[]; rows: any[][] }
-
-export function createDatabaseServer(): MCPServerConfig {
-  const tables = new Map<string, Table>();
-
-  return {
-    name: 'database',
-    version: '1.0.0',
-    tools: [
-      {
-        name: 'db_create_table',
-        description: 'Create a table with specified columns',
-        inputSchema: { type: 'object', properties: { table: { type: 'string' }, columns: { type: 'array', items: { type: 'string' } } }, required: ['table', 'columns'] },
-        handler: async (args: { table: string; columns: string[] }) => {
-          tables.set(args.table, { columns: args.columns, rows: [] });
-          return { created: args.table, columns: args.columns };
-        },
-      },
-      {
-        name: 'db_insert',
-        description: 'Insert a row into a table',
-        inputSchema: { type: 'object', properties: { table: { type: 'string' }, values: { type: 'object' } }, required: ['table', 'values'] },
-        handler: async (args: { table: string; values: Record<string, any> }) => {
-          const t = tables.get(args.table);
-          if (!t) throw new Error(`Table ${args.table} not found`);
-          const row = t.columns.map(c => args.values[c] ?? null);
-          t.rows.push(row);
-          return { inserted: true, rowIndex: t.rows.length - 1 };
-        },
-      },
-      {
-        name: 'db_query',
-        description: 'Query a table with optional where clause',
-        inputSchema: { type: 'object', properties: { table: { type: 'string' }, where: { type: 'object' }, limit: { type: 'number' } }, required: ['table'] },
-        handler: async (args: { table: string; where?: Record<string, any>; limit?: number }) => {
-          const t = tables.get(args.table);
-          if (!t) throw new Error(`Table ${args.table} not found`);
-          let results = t.rows.map(row => {
-            const obj: Record<string, any> = {};
-            t.columns.forEach((c, i) => obj[c] = row[i]);
-            return obj;
-          });
-          if (args.where) {
-            results = results.filter(row => Object.entries(args.where!).every(([k, v]) => row[k] === v));
-          }
-          if (args.limit) results = results.slice(0, args.limit);
-          return { rows: results, count: results.length };
-        },
-      },
-      {
-        name: 'db_list_tables',
-        description: 'List all tables',
-        inputSchema: { type: 'object', properties: {} },
-        handler: async () => {
-          return { tables: Array.from(tables.entries()).map(([name, t]) => ({ name, columns: t.columns, rowCount: t.rows.length })) };
-        },
-      },
-      {
-        name: 'db_drop_table',
-        description: 'Drop a table',
-        inputSchema: { type: 'object', properties: { table: { type: 'string' } }, required: ['table'] },
-        handler: async (args: { table: string }) => {
-          const existed = tables.delete(args.table);
-          return { dropped: existed };
-        },
-      },
-    ],
-  };
-}
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+// In-memory SQL-like database (no external deps)
+interface Table { columns: string[]; rows: any[][] }
+
+export function createDatabaseServer(): MCPServerConfig {
+  const tables = new Map<string, Table>();
+
+  return {
+    name: 'database',
+    version: '1.0.0',
+    tools: [
+      {
+        name: 'db_create_table',
+        description: 'Create a table with specified columns',
+        inputSchema: { type: 'object', properties: { table: { type: 'string' }, columns: { type: 'array', items: { type: 'string' } } }, required: ['table', 'columns'] },
+        handler: async (args: { table: string; columns: string[] }) => {
+          tables.set(args.table, { columns: args.columns, rows: [] });
+          return { created: args.table, columns: args.columns };
+        },
+      },
+      {
+        name: 'db_insert',
+        description: 'Insert a row into a table',
+        inputSchema: { type: 'object', properties: { table: { type: 'string' }, values: { type: 'object' } }, required: ['table', 'values'] },
+        handler: async (args: { table: string; values: Record<string, any> }) => {
+          const t = tables.get(args.table);
+          if (!t) throw new Error(`Table ${args.table} not found`);
+          const row = t.columns.map(c => args.values[c] ?? null);
+          t.rows.push(row);
+          return { inserted: true, rowIndex: t.rows.length - 1 };
+        },
+      },
+      {
+        name: 'db_query',
+        description: 'Query a table with optional where clause',
+        inputSchema: { type: 'object', properties: { table: { type: 'string' }, where: { type: 'object' }, limit: { type: 'number' } }, required: ['table'] },
+        handler: async (args: { table: string; where?: Record<string, any>; limit?: number }) => {
+          const t = tables.get(args.table);
+          if (!t) throw new Error(`Table ${args.table} not found`);
+          let results = t.rows.map(row => {
+            const obj: Record<string, any> = {};
+            t.columns.forEach((c, i) => obj[c] = row[i]);
+            return obj;
+          });
+          if (args.where) {
+            results = results.filter(row => Object.entries(args.where!).every(([k, v]) => row[k] === v));
+          }
+          if (args.limit) results = results.slice(0, args.limit);
+          return { rows: results, count: results.length };
+        },
+      },
+      {
+        name: 'db_list_tables',
+        description: 'List all tables',
+        inputSchema: { type: 'object', properties: {} },
+        handler: async () => {
+          return { tables: Array.from(tables.entries()).map(([name, t]) => ({ name, columns: t.columns, rowCount: t.rows.length })) };
+        },
+      },
+      {
+        name: 'db_drop_table',
+        description: 'Drop a table',
+        inputSchema: { type: 'object', properties: { table: { type: 'string' } }, required: ['table'] },
+        handler: async (args: { table: string }) => {
+          const existed = tables.delete(args.table);
+          return { dropped: existed };
+        },
+      },
+    ],
+  };
+}

package/src/mcp/servers/datetime-mcp.ts

@@ -1,69 +1,69 @@
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-const TIMEZONE_OFFSETS: Record<string, number> = {
-  'UTC': 0, 'GMT': 0, 'EST': -5, 'EDT': -4, 'CST': -6, 'CDT': -5,
-  'MST': -7, 'MDT': -6, 'PST': -8, 'PDT': -7, 'JST': 9, 'KST': 9,
-  'CST8': 8, 'IST': 5.5, 'CET': 1, 'CEST': 2, 'AEST': 10, 'AEDT': 11,
-  'Asia/Shanghai': 8, 'Asia/Tokyo': 9, 'America/New_York': -4,
-  'America/Los_Angeles': -7, 'Europe/London': 1, 'Europe/Berlin': 2,
-};
-
-export function createDateTimeServer(): MCPServerConfig {
-  return {
-    name: 'datetime',
-    version: '1.0.0',
-    tools: [
-      {
-        name: 'dt_now',
-        description: 'Get current date/time in a timezone',
-        inputSchema: { type: 'object', properties: { timezone: { type: 'string', default: 'UTC' }, format: { type: 'string', enum: ['iso', 'unix', 'human'], default: 'iso' } } },
-        handler: async (args: { timezone?: string; format?: string }) => {
-          const offset = TIMEZONE_OFFSETS[args.timezone || 'UTC'] ?? 0;
-          const now = new Date(Date.now() + offset * 3600000);
-          const fmt = args.format || 'iso';
-          return {
-            iso: now.toISOString(),
-            unix: Math.floor(now.getTime() / 1000),
-            human: now.toUTCString(),
-            timezone: args.timezone || 'UTC',
-            offset,
-          };
-        },
-      },
-      {
-        name: 'dt_diff',
-        description: 'Calculate difference between two dates',
-        inputSchema: { type: 'object', properties: { from: { type: 'string' }, to: { type: 'string' }, unit: { type: 'string', enum: ['days', 'hours', 'minutes', 'seconds'], default: 'days' } }, required: ['from', 'to'] },
-        handler: async (args: { from: string; to: string; unit?: string }) => {
-          const d1 = new Date(args.from).getTime();
-          const d2 = new Date(args.to).getTime();
-          const diffMs = d2 - d1;
-          const divisors: Record<string, number> = { seconds: 1000, minutes: 60000, hours: 3600000, days: 86400000 };
-          const unit = args.unit || 'days';
-          return { from: args.from, to: args.to, difference: diffMs / divisors[unit], unit };
-        },
-      },
-      {
-        name: 'dt_add',
-        description: 'Add duration to a date',
-        inputSchema: { type: 'object', properties: { date: { type: 'string' }, amount: { type: 'number' }, unit: { type: 'string', enum: ['days', 'hours', 'minutes', 'seconds'] } }, required: ['date', 'amount', 'unit'] },
-        handler: async (args: { date: string; amount: number; unit: string }) => {
-          const d = new Date(args.date);
-          const ms: Record<string, number> = { seconds: 1000, minutes: 60000, hours: 3600000, days: 86400000 };
-          const result = new Date(d.getTime() + args.amount * ms[args.unit]);
-          return { original: args.date, result: result.toISOString(), added: `${args.amount} ${args.unit}` };
-        },
-      },
-      {
-        name: 'dt_parse',
-        description: 'Parse a date string and return components',
-        inputSchema: { type: 'object', properties: { date: { type: 'string' } }, required: ['date'] },
-        handler: async (args: { date: string }) => {
-          const d = new Date(args.date);
-          if (isNaN(d.getTime())) throw new Error('Invalid date');
-          return { iso: d.toISOString(), year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate(), dayOfWeek: d.toLocaleDateString('en', { weekday: 'long' }), unix: Math.floor(d.getTime() / 1000) };
-        },
-      },
-    ],
-  };
-}
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+const TIMEZONE_OFFSETS: Record<string, number> = {
+  'UTC': 0, 'GMT': 0, 'EST': -5, 'EDT': -4, 'CST': -6, 'CDT': -5,
+  'MST': -7, 'MDT': -6, 'PST': -8, 'PDT': -7, 'JST': 9, 'KST': 9,
+  'CST8': 8, 'IST': 5.5, 'CET': 1, 'CEST': 2, 'AEST': 10, 'AEDT': 11,
+  'Asia/Shanghai': 8, 'Asia/Tokyo': 9, 'America/New_York': -4,
+  'America/Los_Angeles': -7, 'Europe/London': 1, 'Europe/Berlin': 2,
+};
+
+export function createDateTimeServer(): MCPServerConfig {
+  return {
+    name: 'datetime',
+    version: '1.0.0',
+    tools: [
+      {
+        name: 'dt_now',
+        description: 'Get current date/time in a timezone',
+        inputSchema: { type: 'object', properties: { timezone: { type: 'string', default: 'UTC' }, format: { type: 'string', enum: ['iso', 'unix', 'human'], default: 'iso' } } },
+        handler: async (args: { timezone?: string; format?: string }) => {
+          const offset = TIMEZONE_OFFSETS[args.timezone || 'UTC'] ?? 0;
+          const now = new Date(Date.now() + offset * 3600000);
+          const fmt = args.format || 'iso';
+          return {
+            iso: now.toISOString(),
+            unix: Math.floor(now.getTime() / 1000),
+            human: now.toUTCString(),
+            timezone: args.timezone || 'UTC',
+            offset,
+          };
+        },
+      },
+      {
+        name: 'dt_diff',
+        description: 'Calculate difference between two dates',
+        inputSchema: { type: 'object', properties: { from: { type: 'string' }, to: { type: 'string' }, unit: { type: 'string', enum: ['days', 'hours', 'minutes', 'seconds'], default: 'days' } }, required: ['from', 'to'] },
+        handler: async (args: { from: string; to: string; unit?: string }) => {
+          const d1 = new Date(args.from).getTime();
+          const d2 = new Date(args.to).getTime();
+          const diffMs = d2 - d1;
+          const divisors: Record<string, number> = { seconds: 1000, minutes: 60000, hours: 3600000, days: 86400000 };
+          const unit = args.unit || 'days';
+          return { from: args.from, to: args.to, difference: diffMs / divisors[unit], unit };
+        },
+      },
+      {
+        name: 'dt_add',
+        description: 'Add duration to a date',
+        inputSchema: { type: 'object', properties: { date: { type: 'string' }, amount: { type: 'number' }, unit: { type: 'string', enum: ['days', 'hours', 'minutes', 'seconds'] } }, required: ['date', 'amount', 'unit'] },
+        handler: async (args: { date: string; amount: number; unit: string }) => {
+          const d = new Date(args.date);
+          const ms: Record<string, number> = { seconds: 1000, minutes: 60000, hours: 3600000, days: 86400000 };
+          const result = new Date(d.getTime() + args.amount * ms[args.unit]);
+          return { original: args.date, result: result.toISOString(), added: `${args.amount} ${args.unit}` };
+        },
+      },
+      {
+        name: 'dt_parse',
+        description: 'Parse a date string and return components',
+        inputSchema: { type: 'object', properties: { date: { type: 'string' } }, required: ['date'] },
+        handler: async (args: { date: string }) => {
+          const d = new Date(args.date);
+          if (isNaN(d.getTime())) throw new Error('Invalid date');
+          return { iso: d.toISOString(), year: d.getFullYear(), month: d.getMonth() + 1, day: d.getDate(), dayOfWeek: d.toLocaleDateString('en', { weekday: 'long' }), unix: Math.floor(d.getTime() / 1000) };
+        },
+      },
+    ],
+  };
+}

package/src/mcp/servers/filesystem.ts

@@ -1,66 +1,66 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-export function createFilesystemServer(rootDir: string = process.cwd()): MCPServerConfig {
-  const resolve = (p: string) => {
-    const resolved = path.resolve(rootDir, p);
-    if (!resolved.startsWith(path.resolve(rootDir))) throw new Error('Path traversal not allowed');
-    return resolved;
-  };
-
-  return {
-    name: 'filesystem',
-    version: '1.0.0',
-    tools: [
-      {
-        name: 'fs_read',
-        description: 'Read file contents as UTF-8 text',
-        inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'File path relative to root' } }, required: ['path'] },
-        handler: async (args: { path: string }) => {
-          return { content: fs.readFileSync(resolve(args.path), 'utf-8') };
-        },
-      },
-      {
-        name: 'fs_write',
-        description: 'Write content to a file (creates directories as needed)',
-        inputSchema: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'] },
-        handler: async (args: { path: string; content: string }) => {
-          const target = resolve(args.path);
-          fs.mkdirSync(path.dirname(target), { recursive: true });
-          fs.writeFileSync(target, args.content, 'utf-8');
-          return { written: target };
-        },
-      },
-      {
-        name: 'fs_list',
-        description: 'List files and directories',
-        inputSchema: { type: 'object', properties: { path: { type: 'string', default: '.' }, recursive: { type: 'boolean', default: false } }, required: [] },
-        handler: async (args: { path?: string; recursive?: boolean }) => {
-          const dir = resolve(args.path || '.');
-          const entries = fs.readdirSync(dir, { withFileTypes: true });
-          const result = entries.map(e => ({ name: e.name, type: e.isDirectory() ? 'directory' : 'file' }));
-          return { entries: result };
-        },
-      },
-      {
-        name: 'fs_stat',
-        description: 'Get file/directory metadata',
-        inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
-        handler: async (args: { path: string }) => {
-          const stat = fs.statSync(resolve(args.path));
-          return { size: stat.size, isFile: stat.isFile(), isDirectory: stat.isDirectory(), modified: stat.mtime.toISOString() };
-        },
-      },
-      {
-        name: 'fs_delete',
-        description: 'Delete a file',
-        inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
-        handler: async (args: { path: string }) => {
-          fs.unlinkSync(resolve(args.path));
-          return { deleted: true };
-        },
-      },
-    ],
-  };
-}
+import * as fs from 'fs';
+import * as path from 'path';
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+export function createFilesystemServer(rootDir: string = process.cwd()): MCPServerConfig {
+  const resolve = (p: string) => {
+    const resolved = path.resolve(rootDir, p);
+    if (!resolved.startsWith(path.resolve(rootDir))) throw new Error('Path traversal not allowed');
+    return resolved;
+  };
+
+  return {
+    name: 'filesystem',
+    version: '1.0.0',
+    tools: [
+      {
+        name: 'fs_read',
+        description: 'Read file contents as UTF-8 text',
+        inputSchema: { type: 'object', properties: { path: { type: 'string', description: 'File path relative to root' } }, required: ['path'] },
+        handler: async (args: { path: string }) => {
+          return { content: fs.readFileSync(resolve(args.path), 'utf-8') };
+        },
+      },
+      {
+        name: 'fs_write',
+        description: 'Write content to a file (creates directories as needed)',
+        inputSchema: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'] },
+        handler: async (args: { path: string; content: string }) => {
+          const target = resolve(args.path);
+          fs.mkdirSync(path.dirname(target), { recursive: true });
+          fs.writeFileSync(target, args.content, 'utf-8');
+          return { written: target };
+        },
+      },
+      {
+        name: 'fs_list',
+        description: 'List files and directories',
+        inputSchema: { type: 'object', properties: { path: { type: 'string', default: '.' }, recursive: { type: 'boolean', default: false } }, required: [] },
+        handler: async (args: { path?: string; recursive?: boolean }) => {
+          const dir = resolve(args.path || '.');
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          const result = entries.map(e => ({ name: e.name, type: e.isDirectory() ? 'directory' : 'file' }));
+          return { entries: result };
+        },
+      },
+      {
+        name: 'fs_stat',
+        description: 'Get file/directory metadata',
+        inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+        handler: async (args: { path: string }) => {
+          const stat = fs.statSync(resolve(args.path));
+          return { size: stat.size, isFile: stat.isFile(), isDirectory: stat.isDirectory(), modified: stat.mtime.toISOString() };
+        },
+      },
+      {
+        name: 'fs_delete',
+        description: 'Delete a file',
+        inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+        handler: async (args: { path: string }) => {
+          fs.unlinkSync(resolve(args.path));
+          return { deleted: true };
+        },
+      },
+    ],
+  };
+}

package/src/mcp/servers/github-mcp.ts

@@ -1,58 +1,58 @@
-import type { MCPServerConfig } from '../../protocols/mcp/types';
-
-export function createGitHubServer(token?: string): MCPServerConfig {
-  const headers: Record<string, string> = {
-    'Accept': 'application/vnd.github.v3+json',
-    'User-Agent': 'opc-mcp-github/1.0',
-  };
-  if (token) headers['Authorization'] = `Bearer ${token}`;
-
-  const ghFetch = async (path: string, opts: any = {}) => {
-    const res = await fetch(`https://api.github.com${path}`, { ...opts, headers: { ...headers, ...opts.headers } });
-    if (!res.ok) throw new Error(`GitHub API ${res.status}: ${await res.text()}`);
-    return res.json();
-  };
-
-  return {
-    name: 'github',
-    version: '1.0.0',
-    tools: [
-      {
-        name: 'github_get_repo',
-        description: 'Get repository information',
-        inputSchema: { type: 'object', properties: { owner: { type: 'string' }, repo: { type: 'string' } }, required: ['owner', 'repo'] },
-        handler: async (args: { owner: string; repo: string }) => ghFetch(`/repos/${args.owner}/${args.repo}`),
-      },
-      {
-        name: 'github_list_issues',
-        description: 'List repository issues',
-        inputSchema: { type: 'object', properties: { owner: { type: 'string' }, repo: { type: 'string' }, state: { type: 'string', enum: ['open', 'closed', 'all'], default: 'open' } }, required: ['owner', 'repo'] },
-        handler: async (args: { owner: string; repo: string; state?: string }) => ghFetch(`/repos/${args.owner}/${args.repo}/issues?state=${args.state || 'open'}`),
-      },
-      {
-        name: 'github_create_issue',
-        description: 'Create a new issue',
-        inputSchema: { type: 'object', properties: { owner: { type: 'string' }, repo: { type: 'string' }, title: { type: 'string' }, body: { type: 'string' } }, required: ['owner', 'repo', 'title'] },
-        handler: async (args: { owner: string; repo: string; title: string; body?: string }) =>
-          ghFetch(`/repos/${args.owner}/${args.repo}/issues`, { method: 'POST', body: JSON.stringify({ title: args.title, body: args.body }), headers: { 'Content-Type': 'application/json' } }),
-      },
-      {
-        name: 'github_search_repos',
-        description: 'Search GitHub repositories',
-        inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
-        handler: async (args: { query: string }) => ghFetch(`/search/repositories?q=${encodeURIComponent(args.query)}`),
-      },
-      {
-        name: 'github_get_file',
-        description: 'Get file contents from a repository',
-        inputSchema: { type: 'object', properties: { owner: { type: 'string' }, repo: { type: 'string' }, path: { type: 'string' }, ref: { type: 'string' } }, required: ['owner', 'repo', 'path'] },
-        handler: async (args: { owner: string; repo: string; path: string; ref?: string }) => {
-          const q = args.ref ? `?ref=${args.ref}` : '';
-          const data: any = await ghFetch(`/repos/${args.owner}/${args.repo}/contents/${args.path}${q}`);
-          if (data.content) data.decoded = Buffer.from(data.content, 'base64').toString('utf-8');
-          return data;
-        },
-      },
-    ],
-  };
-}
+import type { MCPServerConfig } from '../../protocols/mcp/types';
+
+export function createGitHubServer(token?: string): MCPServerConfig {
+  const headers: Record<string, string> = {
+    'Accept': 'application/vnd.github.v3+json',
+    'User-Agent': 'opc-mcp-github/1.0',
+  };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  const ghFetch = async (path: string, opts: any = {}) => {
+    const res = await fetch(`https://api.github.com${path}`, { ...opts, headers: { ...headers, ...opts.headers } });
+    if (!res.ok) throw new Error(`GitHub API ${res.status}: ${await res.text()}`);
+    return res.json();
+  };
+
+  return {
+    name: 'github',
+    version: '1.0.0',
+    tools: [
+      {
+        name: 'github_get_repo',
+        description: 'Get repository information',
+        inputSchema: { type: 'object', properties: { owner: { type: 'string' }, repo: { type: 'string' } }, required: ['owner', 'repo'] },
+        handler: async (args: { owner: string; repo: string }) => ghFetch(`/repos/${args.owner}/${args.repo}`),
+      },
+      {
+        name: 'github_list_issues',
+        description: 'List repository issues',
+        inputSchema: { type: 'object', properties: { owner: { type: 'string' }, repo: { type: 'string' }, state: { type: 'string', enum: ['open', 'closed', 'all'], default: 'open' } }, required: ['owner', 'repo'] },
+        handler: async (args: { owner: string; repo: string; state?: string }) => ghFetch(`/repos/${args.owner}/${args.repo}/issues?state=${args.state || 'open'}`),
+      },
+      {
+        name: 'github_create_issue',
+        description: 'Create a new issue',
+        inputSchema: { type: 'object', properties: { owner: { type: 'string' }, repo: { type: 'string' }, title: { type: 'string' }, body: { type: 'string' } }, required: ['owner', 'repo', 'title'] },
+        handler: async (args: { owner: string; repo: string; title: string; body?: string }) =>
+          ghFetch(`/repos/${args.owner}/${args.repo}/issues`, { method: 'POST', body: JSON.stringify({ title: args.title, body: args.body }), headers: { 'Content-Type': 'application/json' } }),
+      },
+      {
+        name: 'github_search_repos',
+        description: 'Search GitHub repositories',
+        inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
+        handler: async (args: { query: string }) => ghFetch(`/search/repositories?q=${encodeURIComponent(args.query)}`),
+      },
+      {
+        name: 'github_get_file',
+        description: 'Get file contents from a repository',
+        inputSchema: { type: 'object', properties: { owner: { type: 'string' }, repo: { type: 'string' }, path: { type: 'string' }, ref: { type: 'string' } }, required: ['owner', 'repo', 'path'] },
+        handler: async (args: { owner: string; repo: string; path: string; ref?: string }) => {
+          const q = args.ref ? `?ref=${args.ref}` : '';
+          const data: any = await ghFetch(`/repos/${args.owner}/${args.repo}/contents/${args.path}${q}`);
+          if (data.content) data.decoded = Buffer.from(data.content, 'base64').toString('utf-8');
+          return data;
+        },
+      },
+    ],
+  };
+}