@ryuenn3123/agentic-senior-core 2.5.22 → 3.0.0

package/scripts/mcp-server.mjs

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
 import { readFileSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
-import { dirname, resolve } from 'node:path';
+import { dirname, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
@@ -10,14 +11,19 @@ const REPOSITORY_ROOT = resolve(dirname(SCRIPT_FILE_PATH), '..');
 const PACKAGE_VERSION = JSON.parse(
   readFileSync(resolve(REPOSITORY_ROOT, 'package.json'), 'utf8')
 ).version;
+const STATE_DIRECTORY = resolve(REPOSITORY_ROOT, '.agent-context', 'state');
 const DEFAULT_PROTOCOL_VERSION = '2024-11-05';
+const DEFAULT_FETCH_TIMEOUT_MS = 15000;
+const DEFAULT_FETCH_MAX_CHARS = 6000;
+const MAX_FETCH_MAX_CHARS = 20000;
+const DEFAULT_TREND_WINDOW_DAYS = 90;
+const MAX_TREND_PACKAGES = 10;
 
 const TEST_SUITE_ARGS = {
-  full: ['--test', './tests/cli-smoke.test.mjs', './tests/llm-judge.test.mjs', './tests/enterprise-ops.test.mjs', './tests/skill-tier-gate.test.mjs'],
+  full: ['--test', './tests/cli-smoke.test.mjs', './tests/mcp-server.test.mjs', './tests/llm-judge.test.mjs', './tests/enterprise-ops.test.mjs'],
   cli: ['--test', './tests/cli-smoke.test.mjs'],
   enterprise: ['--test', './tests/enterprise-ops.test.mjs'],
   'llm-judge': ['--test', './tests/llm-judge.test.mjs'],
-  'skill-tier': ['--test', './tests/skill-tier-gate.test.mjs'],
 };
 
 const TOOL_DEFINITIONS = [
@@ -38,7 +44,7 @@ const TOOL_DEFINITIONS = [
       properties: {
         suite: {
           type: 'string',
-          enum: ['full', 'cli', 'enterprise', 'llm-judge', 'skill-tier'],
+          enum: ['full', 'cli', 'enterprise', 'llm-judge'],
           description: 'Target test suite. Defaults to full.',
         },
       },
@@ -63,6 +69,88 @@ const TOOL_DEFINITIONS = [
       additionalProperties: false,
     },
   },
+  {
+    name: 'research_fetch',
+    description: 'Fetch external documentation/news content and return query-focused excerpts with citation metadata.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: {
+          type: 'string',
+          description: 'Absolute HTTP/HTTPS URL to fetch.',
+        },
+        query: {
+          type: 'string',
+          description: 'Optional search query used to extract focused excerpts.',
+        },
+        maxChars: {
+          type: 'integer',
+          description: 'Maximum characters to return when query is not provided (default 6000, max 20000).',
+        },
+      },
+      required: ['url'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'trend_snapshot',
+    description: 'Generate ecosystem trend snapshot from npm registry metadata with source timestamps.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        packages: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Package names to inspect (max 10).',
+        },
+        windowDays: {
+          type: 'integer',
+          description: 'Release activity window in days (default 90).',
+        },
+      },
+      required: ['packages'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'state_read',
+    description: 'Read a file from .agent-context/state for cross-session continuity.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Path relative to .agent-context/state (for example memory-continuity-benchmark.json).',
+        },
+      },
+      required: ['path'],
+      additionalProperties: false,
+    },
+  },
+  {
+    name: 'state_write',
+    description: 'Write a file under .agent-context/state for cross-session continuity updates.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Path relative to .agent-context/state.',
+        },
+        content: {
+          type: 'string',
+          description: 'UTF-8 content to write.',
+        },
+        mode: {
+          type: 'string',
+          enum: ['overwrite', 'append'],
+          description: 'Write mode. Defaults to overwrite.',
+        },
+      },
+      required: ['path', 'content'],
+      additionalProperties: false,
+    },
+  },
 ];
 
 let incomingBuffer = Buffer.alloc(0);
@@ -117,6 +205,287 @@ function buildCommandOutput(commandLabel, commandArguments, exitCode, stdoutCont
   ].join('\n\n');
 }
 
+function buildJsonResult(payload, isError = false) {
+  return {
+    content: [
+      {
+        type: 'text',
+        text: JSON.stringify(payload, null, 2),
+      },
+    ],
+    isError,
+  };
+}
+
+function normalizePlainText(rawText) {
+  return rawText
+    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
+    .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&amp;/gi, '&')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function extractQuerySnippets(textContent, queryText) {
+  const normalizedQuery = String(queryText || '').trim().toLowerCase();
+  if (!normalizedQuery) {
+    return [];
+  }
+
+  const normalizedContent = String(textContent || '');
+  const normalizedLowerContent = normalizedContent.toLowerCase();
+  const snippets = [];
+  let searchStartIndex = 0;
+
+  while (snippets.length < 5) {
+    const matchedIndex = normalizedLowerContent.indexOf(normalizedQuery, searchStartIndex);
+    if (matchedIndex === -1) {
+      break;
+    }
+
+    const contextRadius = 180;
+    const snippetStart = Math.max(0, matchedIndex - contextRadius);
+    const snippetEnd = Math.min(normalizedContent.length, matchedIndex + normalizedQuery.length + contextRadius);
+    const prefix = snippetStart > 0 ? '...' : '';
+    const suffix = snippetEnd < normalizedContent.length ? '...' : '';
+    snippets.push(`${prefix}${normalizedContent.slice(snippetStart, snippetEnd).trim()}${suffix}`);
+    searchStartIndex = matchedIndex + normalizedQuery.length;
+  }
+
+  return snippets;
+}
+
+async function fetchWithTimeout(targetUrl, timeoutMs) {
+  const fetchController = new AbortController();
+  const timeoutHandle = setTimeout(() => fetchController.abort(), timeoutMs);
+
+  try {
+    return await fetch(targetUrl, {
+      signal: fetchController.signal,
+      headers: {
+        'User-Agent': `agentic-senior-core/${PACKAGE_VERSION}`,
+      },
+    });
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+
+async function runResearchFetchTool(toolArguments = {}) {
+  const targetUrl = String(toolArguments.url || '').trim();
+  const queryText = typeof toolArguments.query === 'string' ? toolArguments.query.trim() : '';
+  const maxCharsInput = Number(toolArguments.maxChars);
+  const maxChars = Number.isFinite(maxCharsInput)
+    ? Math.max(200, Math.min(MAX_FETCH_MAX_CHARS, Math.floor(maxCharsInput)))
+    : DEFAULT_FETCH_MAX_CHARS;
+
+  if (!/^https?:\/\//i.test(targetUrl)) {
+    return buildJsonResult({
+      error: 'Invalid url. Provide absolute HTTP/HTTPS URL.',
+      input: targetUrl,
+    }, true);
+  }
+
+  try {
+    const startedAt = new Date().toISOString();
+    const fetchResponse = await fetchWithTimeout(targetUrl, DEFAULT_FETCH_TIMEOUT_MS);
+    const rawBody = await fetchResponse.text();
+    const plainTextBody = normalizePlainText(rawBody);
+    const querySnippets = queryText ? extractQuerySnippets(plainTextBody, queryText) : [];
+    const selectedContent = querySnippets.length > 0
+      ? querySnippets.join('\n\n')
+      : plainTextBody.slice(0, maxChars);
+
+    return buildJsonResult({
+      source: {
+        url: targetUrl,
+        status: fetchResponse.status,
+        ok: fetchResponse.ok,
+        fetchedAt: new Date().toISOString(),
+        requestedAt: startedAt,
+        contentType: fetchResponse.headers.get('content-type') || null,
+      },
+      query: queryText || null,
+      excerptCount: querySnippets.length,
+      truncated: !queryText && plainTextBody.length > selectedContent.length,
+      content: selectedContent,
+    }, !fetchResponse.ok);
+  } catch (error) {
+    return buildJsonResult({
+      error: error instanceof Error ? error.message : String(error),
+      source: targetUrl,
+    }, true);
+  }
+}
+
+async function runTrendSnapshotTool(toolArguments = {}) {
+  const packageInputs = Array.isArray(toolArguments.packages)
+    ? toolArguments.packages.filter((packageName) => typeof packageName === 'string' && packageName.trim().length > 0)
+    : [];
+  const packageNames = Array.from(new Set(packageInputs.map((packageName) => packageName.trim()))).slice(0, MAX_TREND_PACKAGES);
+  const windowDaysInput = Number(toolArguments.windowDays);
+  const windowDays = Number.isFinite(windowDaysInput)
+    ? Math.max(1, Math.min(3650, Math.floor(windowDaysInput)))
+    : DEFAULT_TREND_WINDOW_DAYS;
+
+  if (packageNames.length === 0) {
+    return buildJsonResult({
+      error: 'packages[] must include at least one package name.',
+    }, true);
+  }
+
+  const nowTimestamp = Date.now();
+  const windowStartTimestamp = nowTimestamp - (windowDays * 24 * 60 * 60 * 1000);
+  const packageReports = [];
+
+  for (const packageName of packageNames) {
+    const registryUrl = `https://registry.npmjs.org/${encodeURIComponent(packageName)}`;
+
+    try {
+      const response = await fetchWithTimeout(registryUrl, DEFAULT_FETCH_TIMEOUT_MS);
+      if (!response.ok) {
+        packageReports.push({
+          package: packageName,
+          source: registryUrl,
+          status: response.status,
+          error: `Registry request failed with HTTP ${response.status}`,
+        });
+        continue;
+      }
+
+      const registryPayload = await response.json();
+      const latestVersion = registryPayload?.['dist-tags']?.latest || null;
+      const releaseTimes = Object.entries(registryPayload?.time || {})
+        .filter(([versionName, publishedAt]) => {
+          if (versionName === 'created' || versionName === 'modified') {
+            return false;
+          }
+
+          return typeof publishedAt === 'string' && Number.isFinite(Date.parse(publishedAt));
+        })
+        .map(([versionName, publishedAt]) => ({
+          version: versionName,
+          publishedAt,
+          publishedAtMs: Date.parse(publishedAt),
+        }))
+        .sort((leftEntry, rightEntry) => rightEntry.publishedAtMs - leftEntry.publishedAtMs);
+
+      const releasesInWindow = releaseTimes.filter((releaseEntry) => releaseEntry.publishedAtMs >= windowStartTimestamp);
+      const latestPublishedAt = latestVersion && typeof registryPayload?.time?.[latestVersion] === 'string'
+        ? registryPayload.time[latestVersion]
+        : registryPayload?.time?.modified || null;
+
+      packageReports.push({
+        package: packageName,
+        source: registryUrl,
+        latestVersion,
+        latestPublishedAt,
+        releasesInWindow: releasesInWindow.length,
+        recentReleases: releasesInWindow.slice(0, 5).map((releaseEntry) => ({
+          version: releaseEntry.version,
+          publishedAt: releaseEntry.publishedAt,
+        })),
+      });
+    } catch (error) {
+      packageReports.push({
+        package: packageName,
+        source: registryUrl,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  const errorCount = packageReports.filter((packageReport) => typeof packageReport.error === 'string').length;
+
+  return buildJsonResult({
+    generatedAt: new Date().toISOString(),
+    windowDays,
+    packageCount: packageNames.length,
+    errorCount,
+    packages: packageReports,
+    citation: {
+      source: 'npm registry public API',
+      fetchedAt: new Date().toISOString(),
+    },
+  }, errorCount > 0);
+}
+
+function resolveStatePath(relativeStatePath) {
+  const normalizedRelativePath = String(relativeStatePath || '').replace(/\\/g, '/').replace(/^\/+/, '').trim();
+  if (!normalizedRelativePath) {
+    throw new Error('path is required and must be relative to .agent-context/state');
+  }
+
+  const resolvedStatePath = resolve(STATE_DIRECTORY, normalizedRelativePath);
+  const stateRootPrefix = `${STATE_DIRECTORY}${sep}`;
+  if (resolvedStatePath !== STATE_DIRECTORY && !resolvedStatePath.startsWith(stateRootPrefix)) {
+    throw new Error('path traversal is not allowed outside .agent-context/state');
+  }
+
+  return {
+    normalizedRelativePath,
+    resolvedStatePath,
+  };
+}
+
+async function runStateReadTool(toolArguments = {}) {
+  try {
+    const { normalizedRelativePath, resolvedStatePath } = resolveStatePath(toolArguments.path);
+    const fileContent = await readFile(resolvedStatePath, 'utf8');
+
+    return buildJsonResult({
+      path: normalizedRelativePath,
+      readAt: new Date().toISOString(),
+      bytes: Buffer.byteLength(fileContent, 'utf8'),
+      content: fileContent,
+    });
+  } catch (error) {
+    return buildJsonResult({
+      error: error instanceof Error ? error.message : String(error),
+      path: toolArguments.path || null,
+    }, true);
+  }
+}
+
+async function runStateWriteTool(toolArguments = {}) {
+  const writeMode = toolArguments.mode === 'append' ? 'append' : 'overwrite';
+  const contentToWrite = typeof toolArguments.content === 'string' ? toolArguments.content : '';
+
+  if (typeof toolArguments.content !== 'string') {
+    return buildJsonResult({
+      error: 'content must be a string.',
+    }, true);
+  }
+
+  try {
+    const { normalizedRelativePath, resolvedStatePath } = resolveStatePath(toolArguments.path);
+    await mkdir(dirname(resolvedStatePath), { recursive: true });
+
+    if (writeMode === 'append') {
+      await writeFile(resolvedStatePath, contentToWrite, { encoding: 'utf8', flag: 'a' });
+    } else {
+      await writeFile(resolvedStatePath, contentToWrite, 'utf8');
+    }
+
+    return buildJsonResult({
+      path: normalizedRelativePath,
+      wroteAt: new Date().toISOString(),
+      mode: writeMode,
+      bytesWritten: Buffer.byteLength(contentToWrite, 'utf8'),
+    });
+  } catch (error) {
+    return buildJsonResult({
+      error: error instanceof Error ? error.message : String(error),
+      path: toolArguments.path || null,
+      mode: writeMode,
+    }, true);
+  }
+}
+
 function runNodeCommand(commandLabel, commandArguments) {
   return new Promise((resolveResult) => {
     const childProcess = spawn(process.execPath, commandArguments, {
@@ -190,6 +559,22 @@ async function executeToolCall(toolName, toolArguments = {}) {
     return runNodeCommand('forbidden_content_check', ['./scripts/forbidden-content-check.mjs']);
   }
 
+  if (toolName === 'research_fetch') {
+    return runResearchFetchTool(toolArguments);
+  }
+
+  if (toolName === 'trend_snapshot') {
+    return runTrendSnapshotTool(toolArguments);
+  }
+
+  if (toolName === 'state_read') {
+    return runStateReadTool(toolArguments);
+  }
+
+  if (toolName === 'state_write') {
+    return runStateWriteTool(toolArguments);
+  }
+
   return {
     content: [
       {
@@ -274,7 +659,6 @@ function processIncomingBuffer() {
   
   // Try to parse as line-delimited JSON first (modern MCP standard)
   let parseMode = 'line-delimited';
-  let contentToProcess = fullContent;
   
   // Check if Content-Length header is present (LSP-style for backward compatibility)
   if (fullContent.includes('Content-Length:')) {