@sitrozyi/repomix-semantic-compressor 0.1.2

package/src/imports.mjs

@@ -0,0 +1,228 @@
+import path from 'node:path';
+import { parse } from '@babel/parser';
+import traversePkg from '@babel/traverse';
+
+const traverse = traversePkg.default || traversePkg;
+
+/**
+ * Extracts import and require paths from source code using AST parsing with regex fallback.
+ * @param {string} code
+ * @returns {string[]}
+ */
+export function extractImports(code) {
+  const importedPaths = new Set();
+  try {
+    const ast = parse(code, {
+      sourceType: 'unambiguous',
+      errorRecovery: true,
+      plugins: [
+        'jsx',
+        'typescript',
+        ['decorators', { decoratorsBeforeExport: true }],
+        'decoratorAutoAccessors',
+        'explicitResourceManagement',
+        'classProperties',
+        'classPrivateProperties',
+        'classPrivateMethods',
+        'classStaticBlock',
+        'dynamicImport',
+        'exportDefaultFrom',
+        'importAttributes'
+      ]
+    });
+
+    traverse(ast, {
+      ImportDeclaration(importPath) {
+        if (importPath.node.source && importPath.node.source.value) {
+          importedPaths.add(importPath.node.source.value);
+        }
+      },
+      ExportNamedDeclaration(exportPath) {
+        if (exportPath.node.source && exportPath.node.source.value) {
+          importedPaths.add(exportPath.node.source.value);
+        }
+      },
+      ExportAllDeclaration(exportPath) {
+        if (exportPath.node.source && exportPath.node.source.value) {
+          importedPaths.add(exportPath.node.source.value);
+        }
+      },
+      CallExpression(callPath) {
+        const callee = callPath.node.callee;
+        if (callee.type === 'Identifier' && callee.name === 'require') {
+          const arg = callPath.node.arguments[0];
+          if (arg && arg.type === 'StringLiteral') {
+            importedPaths.add(arg.value);
+          }
+        }
+        if (callee.type === 'Import') {
+          const arg = callPath.node.arguments[0];
+          if (arg && arg.type === 'StringLiteral') {
+            importedPaths.add(arg.value);
+          }
+        }
+      }
+    });
+
+    return Array.from(importedPaths);
+  } catch {
+    const importRegex = /(?:import\s+(?:[^\n\r;]+?from\s+)?['"]([^'"]+)['"]|export\s+[^\n\r;]+?from\s+['"]([^'"]+)['"]|require\s*\(\s*['"]([^'"]+)['"]\s*\)|from\s+([.\w]+)\s+import|import\s+([.\w]+))/g;
+    let match;
+    while ((match = importRegex.exec(code)) !== null) {
+      const p = match[1] || match[2] || match[3] || match[4] || match[5];
+      if (p) importedPaths.add(p);
+    }
+    return Array.from(importedPaths);
+  }
+}
+
+const RESOLVABLE_EXTENSIONS = [
+  '',
+  '.ts',
+  '.tsx',
+  '.d.ts',
+  '.js',
+  '.jsx',
+  '.mjs',
+  '.cjs',
+  '.mts',
+  '.cts',
+  '.json',
+  '.py',
+  '/__init__.py',
+  '.go',
+  '/index.ts',
+  '/index.tsx',
+  '/index.d.ts',
+  '/index.js',
+  '/index.jsx',
+  '/index.mjs',
+  '/index.json'
+];
+
+/**
+ * Resolves relative, aliased, subpath, and monorepo workspace package imports.
+ * @param {string} fromFilePath
+ * @param {string} importPath
+ * @param {{ path: string }[]} allFiles
+ * @returns {string|null}
+ */
+export function resolveLocalImportPath(fromFilePath, importPath, allFiles) {
+  const fileMap = new Map();
+  for (const f of allFiles) {
+    const normalized = path.normalize(f.path).replace(/\\/g, '/');
+    fileMap.set(normalized, f.path);
+    fileMap.set(normalized.toLowerCase(), f.path);
+  }
+
+  const normalizedFromFile = path.normalize(fromFilePath).replace(/\\/g, '/');
+  const candidateBases = [];
+
+  if (importPath.startsWith('.')) {
+    const currentDir = path.dirname(normalizedFromFile);
+    candidateBases.push(path.normalize(path.join(currentDir, importPath)).replace(/\\/g, '/'));
+  } else if (importPath.startsWith('@/') || importPath.startsWith('~/')) {
+    const subPath = importPath.slice(2);
+    candidateBases.push(path.normalize(subPath).replace(/\\/g, '/'));
+    candidateBases.push(path.normalize(path.join('src', subPath)).replace(/\\/g, '/'));
+  } else if (importPath.startsWith('#')) {
+    const subPath = importPath.slice(1);
+    candidateBases.push(path.normalize(subPath).replace(/\\/g, '/'));
+    candidateBases.push(path.normalize(path.join('src', subPath)).replace(/\\/g, '/'));
+  } else {
+    candidateBases.push(path.normalize(importPath).replace(/\\/g, '/'));
+    candidateBases.push(path.normalize(path.join('src', importPath)).replace(/\\/g, '/'));
+    candidateBases.push(path.normalize(path.join('packages', importPath)).replace(/\\/g, '/'));
+  }
+
+  for (const base of candidateBases) {
+    for (const ext of RESOLVABLE_EXTENSIONS) {
+      const candidate = `${base}${ext}`;
+      if (fileMap.has(candidate)) {
+        return fileMap.get(candidate);
+      }
+      const lower = candidate.toLowerCase();
+      if (fileMap.has(lower)) {
+        return fileMap.get(lower);
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Summarizes top-level exports for out-of-scope non-focused files using AST analysis.
+ * @param {string} code
+ * @returns {string}
+ */
+export function summarizeExports(code) {
+  const exports = new Set();
+  try {
+    const ast = parse(code, {
+      sourceType: 'unambiguous',
+      errorRecovery: true,
+      plugins: [
+        'jsx',
+        'typescript',
+        ['decorators', { decoratorsBeforeExport: true }],
+        'decoratorAutoAccessors',
+        'explicitResourceManagement',
+        'classProperties',
+        'classPrivateProperties',
+        'classPrivateMethods',
+        'classStaticBlock',
+        'dynamicImport',
+        'exportDefaultFrom',
+        'importAttributes'
+      ]
+    });
+
+    traverse(ast, {
+      ExportNamedDeclaration(exportPath) {
+        if (exportPath.node.declaration) {
+          const decl = exportPath.node.declaration;
+          if (decl.id && decl.id.name) {
+            exports.add(decl.id.name);
+          } else if (decl.declarations && Array.isArray(decl.declarations)) {
+            for (const d of decl.declarations) {
+              if (d.id && d.id.type === 'Identifier') {
+                exports.add(d.id.name);
+              }
+            }
+          }
+        }
+        if (exportPath.node.specifiers && Array.isArray(exportPath.node.specifiers)) {
+          for (const spec of exportPath.node.specifiers) {
+            if (spec.exported && spec.exported.name) {
+              exports.add(spec.exported.name);
+            }
+          }
+        }
+      },
+      ExportDefaultDeclaration(exportPath) {
+        const decl = exportPath.node.declaration;
+        if (decl.id && decl.id.name) {
+          exports.add(`default (${decl.id.name})`);
+        } else {
+          exports.add('default');
+        }
+      }
+    });
+
+    if (exports.size > 0) {
+      return `// Exported signatures: ${Array.from(exports).join(', ')}\n// [Non-focused implementation omitted]`;
+    }
+  } catch {
+    const exportRegex = /export\s+(?:default\s+)?(?:async\s+)?(?:function\*?|class|const|let|var|interface|type|enum)\s+([a-zA-Z0-9_$]+)/g;
+    let m;
+    while ((m = exportRegex.exec(code)) !== null) {
+      exports.add(m[1]);
+    }
+    if (exports.size > 0) {
+      return `// Exported signatures: ${Array.from(exports).join(', ')}\n// [Non-focused implementation omitted]`;
+    }
+  }
+
+  return `// [Non-focused implementation omitted]`;
+}

package/src/mcp.mjs

@@ -0,0 +1,223 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { extractFiles, compressRepository, findDefaultInputFile } from './core.mjs';
+
+export function sanitizeInputPath(targetPath, baseDir = process.cwd()) {
+  const resolvedBase = path.resolve(baseDir);
+  const resolvedTarget = path.resolve(baseDir, targetPath);
+  const rel = path.relative(resolvedBase, resolvedTarget);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new Error('Access denied: Path traversal detected outside root directory.');
+  }
+  return resolvedTarget;
+}
+
+function errorResult(message) {
+  return {
+    content: [{ type: 'text', text: `Error: ${message}` }],
+    isError: true
+  };
+}
+
+function resolveInput(args = {}) {
+  const inputFile = args.input
+    ? sanitizeInputPath(args.input)
+    : findDefaultInputFile(false, '.', true);
+  if (!fs.existsSync(inputFile)) {
+    throw new Error(`Repomix file not found: ${inputFile}`);
+  }
+  const rawContent = fs.readFileSync(inputFile, 'utf-8');
+  return { inputFile, rawContent };
+}
+
+/**
+ * Creates and configures the Repomix Compressor MCP Server instance.
+ * @returns {Server}
+ */
+export function createMCPServer() {
+  const server = new Server(
+    {
+      name: 'repomix-semantic-compressor',
+      version: '1.0.0'
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: 'get_repo_skeleton',
+          description: 'Retrieve the compressed semantic skeleton of the repository. Optionally pass a focus path to retain full implementation for relevant modules.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              focus: {
+                type: 'string',
+                description: 'Path pattern or module name to retain full implementation (e.g. "src/auth")'
+              },
+              input: {
+                type: 'string',
+                description: 'Path to repomix output file (auto-detected if omitted)'
+              },
+              maxPreserveLines: {
+                type: 'number',
+                description: 'Max lines to preserve full function bodies (default: 8)'
+              }
+            }
+          }
+        },
+        {
+          name: 'get_file_implementation',
+          description: 'Retrieve the uncompressed source code for a specific file from the repository artifact.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              path: {
+                type: 'string',
+                description: 'File path to retrieve'
+              },
+              input: {
+                type: 'string',
+                description: 'Path to repomix output file (auto-detected if omitted)'
+              }
+            },
+            required: ['path']
+          }
+        },
+        {
+          name: 'compress_repomix_file',
+          description: 'Compress a repomix file and write the result to a specified output path.',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              input: {
+                type: 'string',
+                description: 'Input repomix file path'
+              },
+              output: {
+                type: 'string',
+                description: 'Output optimized markdown path (default: repomix-optimized.md)'
+              },
+              focus: {
+                type: 'string',
+                description: 'Focus pattern for targeted full retention'
+              },
+              maxPreserveLines: {
+                type: 'number',
+                description: 'Max lines to preserve full function bodies (default: 8)'
+              }
+            }
+          }
+        }
+      ]
+    };
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args = {} } = request.params;
+
+    try {
+      if (name === 'get_repo_skeleton') {
+        let inputFile, rawContent;
+        try {
+          ({ inputFile, rawContent } = resolveInput(args));
+        } catch (err) {
+          return errorResult(err.message);
+        }
+        const files = extractFiles(rawContent, inputFile);
+        const skeleton = await compressRepository(files, {
+          focus: args.focus || null,
+          maxPreserveLines: args.maxPreserveLines || 8
+        });
+        return {
+          content: [{ type: 'text', text: skeleton }]
+        };
+      }
+
+      if (name === 'get_file_implementation') {
+        let inputFile, rawContent;
+        try {
+          ({ inputFile, rawContent } = resolveInput(args));
+        } catch (err) {
+          return errorResult(err.message);
+        }
+        const files = extractFiles(rawContent, inputFile);
+        const targetPath = args.path;
+        const normTarget = path.normalize(targetPath).replace(/\\/g, '/').replace(/^\.\//, '');
+
+        // Exact matching to prevent ambiguous resolution and path traversal
+        const matched = files.find((f) => {
+          const norm = path.normalize(f.path).replace(/\\/g, '/').replace(/^\.\//, '');
+          return norm === normTarget;
+        });
+
+        if (!matched) {
+          return {
+            content: [{ type: 'text', text: `Error: File '${targetPath}' not found in repository artifact.` }],
+            isError: true
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `### File: ${matched.path}\n\`\`\`\`\n${matched.content}\n\`\`\`\``
+            }
+          ]
+        };
+      }
+
+      if (name === 'compress_repomix_file') {
+        let inputFile, outputFile, rawContent;
+        try {
+          ({ inputFile, rawContent } = resolveInput(args));
+          outputFile = sanitizeInputPath(args.output || 'repomix-optimized.md');
+        } catch (err) {
+          return errorResult(err.message);
+        }
+        const files = extractFiles(rawContent, inputFile);
+        const result = await compressRepository(files, {
+          focus: args.focus || null,
+          maxPreserveLines: args.maxPreserveLines || 8
+        });
+        fs.writeFileSync(outputFile, result, 'utf-8');
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Successfully compressed ${files.length} files to ${outputFile}`
+            }
+          ]
+        };
+      }
+
+      return {
+        content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+        isError: true
+      };
+    } catch (err) {
+      return {
+        content: [{ type: 'text', text: `Tool execution failed: ${err.message}` }],
+        isError: true
+      };
+    }
+  });
+
+  return server;
+}
+
+export async function startMCPServer() {
+  const server = createMCPServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('Repomix Semantic Compressor MCP Server running on stdio');
+}