@aria_asi/cli 0.2.0

package/src/auto-mcp.ts

@@ -0,0 +1,1172 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { basename, dirname, extname, join, relative, resolve } from 'path';
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export interface ToolParameter {
+  name: string;
+  type: string;
+  required: boolean;
+  description: string;
+}
+
+export interface ToolCandidate {
+  name: string;
+  description: string;
+  source:
+    | 'express-route'
+    | 'next-api'
+    | 'cli-script'
+    | 'exported-function'
+    | 'fastapi-route';
+  filePath: string;
+  parameters: ToolParameter[];
+  httpMethod?: string;
+  routePath?: string;
+}
+
+export interface McpGenerationResult {
+  serverPath: string;
+  toolCount: number;
+  tools: string[];
+}
+
+interface RouteMatch {
+  method: string;
+  path: string;
+  filePath: string;
+  handlerBody: string;
+  jsdoc: string;
+}
+
+interface FunctionMatch {
+  name: string;
+  filePath: string;
+  params: ToolParameter[];
+  jsdoc: string;
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function readFileSafe(p: string): string {
+  try {
+    return readFileSync(p, 'utf-8');
+  } catch {
+    return '';
+  }
+}
+
+function walkDir(dir: string, extensions: string[]): string[] {
+  const results: string[] = [];
+  if (!existsSync(dir)) return results;
+  try {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory() && entry !== 'node_modules' && !entry.startsWith('.')) {
+        results.push(...walkDir(fullPath, extensions));
+      } else if (stat.isFile()) {
+        const ext = extname(entry).toLowerCase();
+        if (extensions.includes(ext)) {
+          results.push(fullPath);
+        }
+      }
+    }
+  } catch {
+    // Permission errors, etc.
+  }
+  return results;
+}
+
+function extractJSDoc(source: string, beforeLineIdx: number): string {
+  const lines = source.split('\n');
+  const docLines: string[] = [];
+  let i = beforeLineIdx - 1;
+  while (i >= 0 && lines[i].trim().startsWith('*')) {
+    const cleaned = lines[i].replace(/^\s*\*\s?/, '').trim();
+    if (cleaned && cleaned !== '/' && !cleaned.startsWith('@')) {
+      docLines.unshift(cleaned);
+    }
+    i--;
+  }
+  if (i >= 0 && lines[i].trim().startsWith('/**')) {
+    return docLines.join(' ');
+  }
+  return '';
+}
+
+function getJsDocForLine(source: string, lineIdx: number): string {
+  return extractJSDoc(source, lineIdx);
+}
+
+function snakeCase(str: string): string {
+  return str
+    .replace(/([A-Z])/g, '_$1')
+    .toLowerCase()
+    .replace(/^_/, '')
+    .replace(/[^a-z0-9_]+/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '');
+}
+
+function inferTsTypeFromValue(val: string): string {
+  if (/^\d+$/.test(val)) return 'number';
+  if (/^(true|false)$/.test(val)) return 'boolean';
+  return 'string';
+}
+
+function paramFromTsSignature(param: string): ToolParameter {
+  const parts = param.trim().split(':');
+  const name = parts[0].trim().replace(/^\?/, '');
+  const required = !param.trim().includes('?');
+  let type = 'string';
+  let description = '';
+
+  if (parts.length > 1) {
+    const rawType = parts.slice(1).join(':').trim().split('=')[0].trim();
+    if (
+      rawType === 'string' ||
+      rawType === 'number' ||
+      rawType === 'boolean' ||
+      rawType === 'string[]' ||
+      rawType === 'number[]'
+    ) {
+      type = rawType;
+    }
+  }
+
+  description = type === 'number' ? `Numeric value for ${name}` : `Value for ${name}`;
+  return { name, type, required: required && !param.trim().startsWith('?'), description };
+}
+
+function sanitizeToolName(raw: string): string {
+  return snakeCase(raw)
+    .replace(/^get_/, 'get_')
+    .replace(/[^a-z0-9_]/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_|_$/g, '')
+    .substring(0, 64);
+}
+
+// ─── Express route detection ──────────────────────────────────────────────────
+
+function detectExpressRoutes(projectPath: string): ToolCandidate[] {
+  const candidates: ToolCandidate[] = [];
+  const allTsFiles = walkDir(join(projectPath, 'src'), ['.ts', '.tsx', '.js']);
+  const allFiles = [
+    ...allTsFiles,
+    ...walkDir(projectPath, ['.ts', '.tsx', '.js']),
+  ];
+
+  const pkgJsonPath = join(projectPath, 'package.json');
+  let isExpressProject = false;
+
+  if (existsSync(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+      isExpressProject = 'express' in allDeps;
+    } catch {
+      // ignore
+    }
+  }
+
+  const routeFiles = allFiles.filter(
+    (f) =>
+      f.includes('/routes/') ||
+      f.includes('/routers/') ||
+      f.includes('router') ||
+      (isExpressProject && f.endsWith('.ts')),
+  );
+
+  for (const filePath of routeFiles) {
+    const content = readFileSafe(filePath);
+    if (!content) continue;
+
+    const routePatterns: RouteMatch[] = [];
+
+    // app.<method>(path, ...handler)
+    const methodRegex =
+      /(?:app|router)\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+    let m: RegExpExecArray | null;
+    while ((m = methodRegex.exec(content)) !== null) {
+      routePatterns.push({
+        method: m[1].toLowerCase(),
+        path: m[2],
+        filePath,
+        handlerBody: content.substring(m.index, content.indexOf('\n', m.index + 200) || m.index + 200),
+        jsdoc: getJsDocForLine(content, content.substring(0, m.index).split('\n').length - 1),
+      });
+    }
+
+    // router.route('/path').get(...)
+    const routeRegex =
+      /(?:app|router)\s*\.\s*route\s*\(\s*['"`]([^'"`]+)['"`]\)\s*\.\s*(get|post|put|patch|delete)\s*\(/gi;
+    while ((m = routeRegex.exec(content)) !== null) {
+      routePatterns.push({
+        method: m[2].toLowerCase(),
+        path: m[1],
+        filePath,
+        handlerBody: content.substring(m.index, content.indexOf('\n', m.index + 200) || m.index + 200),
+        jsdoc: getJsDocForLine(content, content.substring(0, m.index).split('\n').length - 1),
+      });
+    }
+
+    for (const r of routePatterns) {
+      const params = extractRouteParams(r.path, r.handlerBody, r.jsdoc);
+      const toolName = generateRouteToolName(r.method, r.path, basename(filePath));
+
+      candidates.push({
+        name: toolName,
+        description: r.jsdoc || `${r.method.toUpperCase()} ${r.path}`,
+        source: 'express-route',
+        filePath,
+        parameters: params,
+        httpMethod: r.method,
+        routePath: r.path,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+function extractRouteParams(
+  routePath: string,
+  handlerBody: string,
+  jsdoc: string,
+): ToolParameter[] {
+  const params: ToolParameter[] = [];
+
+  // Extract :param from route
+  const pathParams = routePath.match(/:(\w+)/g);
+  if (pathParams) {
+    for (const p of pathParams) {
+      const name = p.substring(1);
+      params.push({ name, type: 'string', required: true, description: `Route parameter: ${name}` });
+    }
+  }
+
+  // Extract req.query.X from handler body
+  const queryRegex = /req\s*\.\s*query\s*\.\s*(\w+)/g;
+  let m: RegExpExecArray | null;
+  while ((m = queryRegex.exec(handlerBody)) !== null) {
+    if (!params.find((p) => p.name === m![1])) {
+      params.push({
+        name: m[1],
+        type: 'string',
+        required: false,
+        description: `Query parameter: ${m[1]}`,
+      });
+    }
+  }
+
+  // Extract req.body.X from handler body
+  const bodyRegex = /req\s*\.\s*body\s*\.\s*(\w+)/g;
+  while ((m = bodyRegex.exec(handlerBody)) !== null) {
+    if (!params.find((p) => p.name === m![1])) {
+      params.push({
+        name: m[1],
+        type: 'string',
+        required: false,
+        description: `Request body field: ${m[1]}`,
+      });
+    }
+  }
+
+  return params;
+}
+
+function generateRouteToolName(method: string, routePath: string, fileName: string): string {
+  const parts = routePath.split('/').filter(Boolean);
+  const resource = parts.find((p) => !p.startsWith(':') && !p.startsWith('['));
+  const baseName = resource || basename(fileName, extname(fileName));
+
+  const prefixMap: Record<string, string> = {
+    get: 'get',
+    post: 'create',
+    put: 'update',
+    patch: 'update',
+    delete: 'delete',
+  };
+
+  const prefix = prefixMap[method] || method;
+  const hasIdParam = parts.some((p) => p.startsWith(':') || p.startsWith('['));
+
+  if (hasIdParam) {
+    return sanitizeToolName(`${prefix}_${baseName}`);
+  }
+  if (method === 'get') {
+    return sanitizeToolName(`list_${baseName}`);
+  }
+  return sanitizeToolName(`${prefix}_${baseName}`);
+}
+
+// ─── Next.js API route detection ──────────────────────────────────────────────
+
+function detectNextApiRoutes(projectPath: string): ToolCandidate[] {
+  const candidates: ToolCandidate[] = [];
+  const appApiDir = join(projectPath, 'app', 'api');
+  const pagesApiDir = join(projectPath, 'pages', 'api');
+
+  // App Router: app/api/**/route.ts
+  const appRoutes = walkDir(appApiDir, ['.ts', '.tsx']);
+  // Pages Router: pages/api/**/*.ts
+  const pagesRoutes = walkDir(pagesApiDir, ['.ts', '.tsx']);
+
+  const allRouteFiles = [...new Set([...appRoutes, ...pagesRoutes])];
+
+  for (const filePath of allRouteFiles) {
+    const content = readFileSafe(filePath);
+    if (!content) continue;
+
+    const isAppRouter = filePath.includes('/app/api/');
+    const relativePath = isAppRouter
+      ? relative(join(projectPath, 'app', 'api'), filePath).replace(/\/route\.(ts|tsx)$/, '')
+      : relative(join(projectPath, 'pages', 'api'), filePath).replace(/\.(ts|tsx)$/, '');
+
+    const segments = relativePath.split('/').filter(Boolean);
+    const patterns: RouteMatch[] = [];
+
+    if (isAppRouter) {
+      // App Router: export async function GET/POST/PUT/PATCH/DELETE
+      const methodExportRegex =
+        /export\s+async\s+function\s+(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*\(/gi;
+      let m: RegExpExecArray | null;
+      while ((m = methodExportRegex.exec(content)) !== null) {
+        const method = m[1].toLowerCase();
+        const lineIdx = content.substring(0, m.index).split('\n').length - 1;
+        patterns.push({
+          method,
+          path: `/${segments.join('/')}`,
+          filePath,
+          handlerBody: content.substring(
+            m.index,
+            content.indexOf('\n', m.index + 500) || m.index + 500,
+          ),
+          jsdoc: getJsDocForLine(content, lineIdx),
+        });
+      }
+    } else {
+      // Pages Router: export default function handler(req, res)
+      const handlerRegex = /export\s+default\s+(?:async\s+)?function\s+\w*\s*\(/gi;
+      let m: RegExpExecArray | null;
+      while ((m = handlerRegex.exec(content)) !== null) {
+        const handlerBody = content.substring(
+          m.index,
+          content.indexOf('\n', m.index + 1000) || m.index + 1000,
+        );
+        // Detect method from req.method branching
+        const methods = detectPagesMethods(handlerBody);
+        for (const method of methods) {
+          patterns.push({
+            method,
+            path: `/${segments.join('/')}`,
+            filePath,
+            handlerBody,
+            jsdoc: getJsDocForLine(content, content.substring(0, m.index).split('\n').length - 1),
+          });
+        }
+      }
+    }
+
+    for (const r of patterns) {
+      const params = extractNextParams(segments, r.handlerBody, r.jsdoc);
+      const fullPath = buildNextPath(segments);
+      const toolName = generateRouteToolName(r.method, fullPath, basename(filePath));
+
+      candidates.push({
+        name: toolName,
+        description: r.jsdoc || `${r.method.toUpperCase()} /api/${segments.join('/')}`,
+        source: 'next-api',
+        filePath,
+        parameters: params,
+        httpMethod: r.method,
+        routePath: `/api/${segments.join('/')}`,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+function detectPagesMethods(handlerBody: string): string[] {
+  const methods: string[] = [];
+  if (/req\.method\s*===?\s*['"]GET['"]/i.test(handlerBody) || handlerBody.includes('switch')) {
+    methods.push('get');
+  }
+  if (/req\.method\s*===?\s*['"]POST['"]/i.test(handlerBody)) methods.push('post');
+  if (/req\.method\s*===?\s*['"]PUT['"]/i.test(handlerBody)) methods.push('put');
+  if (/req\.method\s*===?\s*['"]PATCH['"]/i.test(handlerBody)) methods.push('patch');
+  if (/req\.method\s*===?\s*['"]DELETE['"]/i.test(handlerBody)) methods.push('delete');
+
+  if (methods.length === 0) {
+    methods.push('get');
+  }
+  return methods;
+}
+
+function extractNextParams(
+  segments: string[],
+  handlerBody: string,
+  _jsdoc: string,
+): ToolParameter[] {
+  const params: ToolParameter[] = [];
+
+  for (const seg of segments) {
+    // [...slug] or [param] or [[...param]]
+    const paramMatch = seg.match(/^\[(?:\.{3})?(\w+)\]$/);
+    if (paramMatch) {
+      const name = paramMatch[1];
+      const type = name.endsWith('Id') || name.endsWith('ID') || name.endsWith('id')
+        ? 'string'
+        : 'string';
+      params.push({
+        name: sanatizeParamName(name),
+        type,
+        required: !seg.startsWith('[['),
+        description: `Route parameter: ${name}`,
+      });
+    }
+  }
+
+  return params;
+}
+
+function sanatizeParamName(name: string): string {
+  return name === 'id' || name === 'ID' || name === 'Id' ? 'id' : snakeCase(name);
+}
+
+function buildNextPath(segments: string[]): string {
+  return '/' + segments.map((s) => (s.startsWith('[') ? `:${s.replace(/[\[\]]/g, '')}` : s)).join('/');
+}
+
+// ─── CLI script detection ─────────────────────────────────────────────────────
+
+function detectCliScripts(projectPath: string): ToolCandidate[] {
+  const candidates: ToolCandidate[] = [];
+  const pkgJsonPath = join(projectPath, 'package.json');
+
+  // Parse package.json bin field
+  if (existsSync(pkgJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+      if (pkg.bin) {
+        const bins = typeof pkg.bin === 'string' ? { [pkg.name]: pkg.bin } : pkg.bin;
+        for (const [binName, binPath] of Object.entries(bins) as [string, string][]) {
+          const fullPath = resolve(projectPath, binPath);
+          if (existsSync(fullPath)) {
+            const content = readFileSafe(fullPath);
+            const params = extractCliParams(content);
+            const description =
+              getJsDocForLine(content, 0) || `${binName} CLI command`;
+            candidates.push({
+              name: sanitizeToolName(`run_${binName}`),
+              description:
+                pkg.description || description,
+              source: 'cli-script',
+              filePath: fullPath,
+              parameters: params,
+            });
+          }
+        }
+      }
+
+      // Parse scripts field too
+      if (pkg.scripts) {
+        for (const [scriptName, scriptCmd] of Object.entries(pkg.scripts) as [string, string][]) {
+          const params = extractScriptParams(scriptCmd);
+          candidates.push({
+            name: sanitizeToolName(`run_${scriptName}`),
+            description: `Run npm script: ${scriptName} — ${scriptCmd}`,
+            source: 'cli-script',
+            filePath: pkgJsonPath,
+            parameters: params,
+          });
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // Scan bin/ and scripts/ directories
+  for (const dir of ['bin', 'scripts']) {
+    const dirPath = join(projectPath, dir);
+    if (!existsSync(dirPath)) continue;
+
+    const scriptFiles = walkDir(dirPath, ['.ts', '.js', '.sh', '.mjs', '.cjs']);
+    for (const filePath of scriptFiles) {
+      const fname = basename(filePath, extname(filePath));
+      const content = readFileSafe(filePath);
+      const params = extractCliParams(content);
+
+      candidates.push({
+        name: sanitizeToolName(`run_${fname}`),
+        description: `CLI script: ${fname}`,
+        source: 'cli-script',
+        filePath,
+        parameters: params,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+function extractCliParams(content: string): ToolParameter[] {
+  const params: ToolParameter[] = [];
+  // commander/yargs style: .option('--name <type>', 'desc')
+  const optionRegex = /\.(?:option|requiredOption)\s*\(\s*['"](--?\w+)\s*(?:<(\w+)>)?['"],\s*['"]([^'"]*)['"]/g;
+  let m: RegExpExecArray | null;
+  while ((m = optionRegex.exec(content)) !== null) {
+    const flag = m[1].replace(/^--?/, '');
+    const type = m[2] || 'string';
+    params.push({
+      name: flag,
+      type: type === 'number' ? 'number' : 'string',
+      required: content.includes('requiredOption') || false,
+      description: m[3] || `CLI flag: ${m[1]}`,
+    });
+  }
+
+  // process.argv style
+  const argRegex = /process\.argv\[\s*(\d+)\s*\]/g;
+  let posFound = false;
+  while ((m = argRegex.exec(content)) !== null) {
+    posFound = true;
+  }
+  if (posFound && params.length === 0) {
+    params.push({
+      name: 'args',
+      type: 'string',
+      required: false,
+      description: 'Command arguments',
+    });
+  }
+
+  return params;
+}
+
+function extractScriptParams(scriptCmd: string): ToolParameter[] {
+  const params: ToolParameter[] = [];
+  // Look for environment variable references in script commands
+  const envRegex = /\$\{?(\w+)\}?/g;
+  let m: RegExpExecArray | null;
+  while ((m = envRegex.exec(scriptCmd)) !== null) {
+    const envName = m[1];
+    if (!/^(npm_|npm_config|PATH|HOME|USER|NODE)/.test(envName)) {
+      params.push({
+        name: snakeCase(envName),
+        type: 'string',
+        required: false,
+        description: `Environment variable: ${envName}`,
+      });
+    }
+  }
+  return params;
+}
+
+// ─── TypeScript exported async function detection ─────────────────────────────
+
+function detectExportedFunctions(projectPath: string): ToolCandidate[] {
+  const candidates: ToolCandidate[] = [];
+  const allTsFiles = walkDir(join(projectPath, 'src'), ['.ts', '.tsx']);
+  const extraFiles = walkDir(join(projectPath, 'lib'), ['.ts', '.tsx']);
+
+  const files = [...new Set([...allTsFiles, ...extraFiles])];
+
+  for (const filePath of files) {
+    const content = readFileSafe(filePath);
+    if (!content || content.length > 200_000) continue;
+
+    // Match: export async function name(args): ReturnType {
+    const funcRegex =
+      /export\s+async\s+function\s+(\w+)\s*\(\s*([^)]*)\)\s*(?::\s*([^{]+?))?\s*\{/g;
+    let m: RegExpExecArray | null;
+    while ((m = funcRegex.exec(content)) !== null) {
+      const funcName = m[1];
+      const rawParams = m[2] || '';
+      const returnType = (m[3] || '').trim();
+      const lineIdx = content.substring(0, m.index).split('\n').length - 1;
+      const jsdoc = getJsDocForLine(content, lineIdx);
+
+      const params = parseTsParams(rawParams);
+
+      // Skip internal/private-looking functions
+      if (funcName.startsWith('_') || funcName.startsWith('#')) continue;
+      // Skip React components
+      if (/^[A-Z]/.test(funcName) && !returnType.includes('Promise')) continue;
+
+      const toolName = sanitizeToolName(funcName);
+      const description =
+        jsdoc ||
+        (returnType
+          ? `Calls ${funcName} (returns ${returnType})`
+          : `Calls ${funcName}`);
+
+      candidates.push({
+        name: toolName,
+        description,
+        source: 'exported-function',
+        filePath,
+        parameters: params,
+      });
+    }
+  }
+
+  return deduplicateTools(candidates);
+}
+
+function parseTsParams(rawParams: string): ToolParameter[] {
+  if (!rawParams.trim()) return [];
+
+  const params: ToolParameter[] = [];
+  let depth = 0;
+  let current = '';
+
+  for (const ch of rawParams) {
+    if (ch === '<' || ch === '(' || ch === '{' || ch === '[') depth++;
+    else if (ch === '>' || ch === ')' || ch === '}' || ch === ']') depth--;
+    else if (ch === ',' && depth === 0) {
+      if (current.trim()) {
+        params.push(paramFromTsSignature(current.trim()));
+      }
+      current = '';
+      continue;
+    }
+    current += ch;
+  }
+
+  if (current.trim()) {
+    params.push(paramFromTsSignature(current.trim()));
+  }
+
+  return params;
+}
+
+function deduplicateTools(candidates: ToolCandidate[]): ToolCandidate[] {
+  const seen = new Map<string, ToolCandidate>();
+  for (const c of candidates) {
+    if (!seen.has(c.name)) {
+      seen.set(c.name, c);
+    }
+  }
+  return Array.from(seen.values());
+}
+
+// ─── Python FastAPI detection ─────────────────────────────────────────────────
+
+function detectFastApiRoutes(projectPath: string): ToolCandidate[] {
+  const candidates: ToolCandidate[] = [];
+  const pyFiles = walkDir(projectPath, ['.py']);
+
+  for (const filePath of pyFiles) {
+    const content = readFileSafe(filePath);
+    if (!content) continue;
+
+    // @app.get('/path') or @router.get('/path')
+    const decoratorRegex =
+      /@(?:app|router)\s*\.\s*(get|post|put|patch|delete|options)\s*\(\s*['"]([^'"']+)['"]/gi;
+    let m: RegExpExecArray | null;
+    while ((m = decoratorRegex.exec(content)) !== null) {
+      const method = m[1].toLowerCase();
+      const routePath = m[2];
+      const lineIdx = content.substring(0, m.index).split('\n').length - 1;
+
+      // Get the function line that follows
+      const afterDecorator = content.substring(m.index + m[0].length);
+      const funcMatch = afterDecorator.match(/def\s+(\w+)\s*\(/);
+      const funcName = funcMatch ? funcMatch[1] : 'handler';
+
+      // Get the function body for parameter detection
+      const restOfFile = content.substring(m.index);
+      const bodyMatch = restOfFile.match(/def\s+\w+\s*\(([^)]*)\)/) || [''];
+      const paramStr = bodyMatch[1] || '';
+
+      const params = parsePythonParams(paramStr, routePath);
+
+      const toolName = generateRouteToolName(method, routePath, funcName);
+
+      candidates.push({
+        name: toolName,
+        description: `${method.toUpperCase()} ${routePath} (${funcName})`,
+        source: 'fastapi-route',
+        filePath,
+        parameters: params,
+        httpMethod: method,
+        routePath,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+function parsePythonParams(paramStr: string, routePath: string): ToolParameter[] {
+  const params: ToolParameter[] = [];
+
+  // Extract route params
+  const pathParamRegex = /\{(\w+)\}/g;
+  let m: RegExpExecArray | null;
+  while ((m = pathParamRegex.exec(routePath)) !== null) {
+    params.push({
+      name: m[1],
+      type: 'string',
+      required: true,
+      description: `Path parameter: ${m[1]}`,
+    });
+  }
+
+  // Extract function params that are not 'self', 'request', 'response'
+  const funcParams = paramStr
+    .split(',')
+    .map((p) => p.trim())
+    .filter((p) => p && p !== 'self' && p !== 'request' && p !== 'response');
+
+  for (const p of funcParams) {
+    const parts = p.split(':');
+    const name = parts[0].trim();
+    const type = parts.length > 1 ? parts[1].trim().split('=')[0].trim() : 'str';
+    const hasDefault = p.includes('=');
+
+    const tsType = mapPythonTypeToTs(type);
+
+    if (!params.find((x) => x.name === name)) {
+      params.push({
+        name,
+        type: tsType,
+        required: !hasDefault,
+        description: `Function parameter: ${name}`,
+      });
+    }
+  }
+
+  return params;
+}
+
+function mapPythonTypeToTs(pyType: string): string {
+  const typeMap: Record<string, string> = {
+    int: 'number',
+    float: 'number',
+    str: 'string',
+    bool: 'boolean',
+    list: 'string[]',
+    dict: 'object',
+    None: 'string',
+  };
+  return typeMap[pyType] || 'string';
+}
+
+// ─── Main detection ───────────────────────────────────────────────────────────
+
+export async function detectToolCandidates(
+  projectPath: string,
+): Promise<ToolCandidate[]> {
+  const absPath = resolve(projectPath);
+  if (!existsSync(absPath)) {
+    throw new Error(`Project path does not exist: ${absPath}`);
+  }
+
+  const isTypescript = existsSync(join(absPath, 'tsconfig.json'));
+  const isPython = !isTypescript && walkDir(absPath, ['.py']).length > 0;
+
+  let allCandidates: ToolCandidate[] = [];
+
+  if (isTypescript) {
+    allCandidates = [
+      ...detectExpressRoutes(absPath),
+      ...detectNextApiRoutes(absPath),
+      ...detectCliScripts(absPath),
+      ...detectExportedFunctions(absPath),
+    ];
+  }
+
+  if (isPython) {
+    allCandidates = [...detectFastApiRoutes(absPath), ...detectCliScripts(absPath)];
+  }
+
+  // Fallback: scan both
+  if (!isTypescript && !isPython) {
+    allCandidates = [
+      ...detectExpressRoutes(absPath),
+      ...detectNextApiRoutes(absPath),
+      ...detectFastApiRoutes(absPath),
+      ...detectCliScripts(absPath),
+      ...detectExportedFunctions(absPath),
+    ];
+  }
+
+  return deduplicateTools(allCandidates);
+}
+
+// ─── MCP Server Code Generation ───────────────────────────────────────────────
+
+function generateServerCode(tools: ToolCandidate[]): string {
+  const toolDefinitions = tools
+    .map((t) => {
+      const inputSchema = generateInputSchema(t.parameters);
+      return `  {
+    name: ${JSON.stringify(t.name)},
+    description: ${JSON.stringify(t.description)},
+    inputSchema: ${JSON.stringify(inputSchema, null, 6).replace(/\n/g, '\n    ')},
+  }`;
+    })
+    .join(',\n');
+
+  const toolHandlers = tools
+    .map((t) => {
+      const paramExtract = t.parameters
+        .map((p) => `    const ${p.name} = args.${p.name};`)
+        .join('\n');
+
+      return `    case '${t.name}':
+      ${t.parameters.length > 0 ? paramExtract + '\n' : ''}      // Source: ${t.filePath}
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ tool: '${t.name}', status: 'ok', args, message: 'Tool ${t.name} invoked. Implement handler at ${t.filePath}' }, null, 2) }],
+      };`;
+    })
+    .join('\n\n');
+
+  const isTypescript = tools.some((t) => t.source !== 'fastapi-route');
+
+  return `#!/usr/bin/env node
+/**
+ * Auto-generated MCP Server
+ * Generated by @aria/connector auto-mcp
+ *
+ * Tools detected: ${tools.length}
+ * Sources: ${[...new Set(tools.map((t) => t.source))].join(', ')}
+ */
+${isTypescript ? `import process from 'node:process';` : ''}
+${isTypescript ? `import { readFileSync } from 'node:fs';` : ''}
+${isTypescript ? `import { resolve, dirname } from 'node:path';` : ''}
+${isTypescript ? `import { fileURLToPath } from 'node:url';` : ''}
+
+${isTypescript ? `const __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);` : ''}
+
+// ── Tool definitions ──────────────────────────────────────────────────────────
+
+const TOOLS = [
+${toolDefinitions}
+];
+
+// ── Tool handlers ────────────────────────────────────────────────────────────
+
+async function callTool(name, args) {
+  switch (name) {
+${toolHandlers}
+
+    default:
+      return {
+        content: [{ type: 'text', text: JSON.stringify({ error: \`Unknown tool: \${name}\` }) }],
+        isError: true,
+      };
+  }
+}
+
+// ── MCP stdio protocol ──────────────────────────────────────────────────────
+
+interface McpRequest {
+  jsonrpc: '2.0';
+  id?: number | string;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface McpResponse {
+  jsonrpc: '2.0';
+  id?: number | string;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+function sendResponse(response: McpResponse): void {
+  process.stdout.write(JSON.stringify(response) + '\\n');
+}
+
+function sendNotification(method: string, params: Record<string, unknown>): void {
+  const notification = {
+    jsonrpc: '2.0' as const,
+    method,
+    params,
+  };
+  process.stdout.write(JSON.stringify(notification) + '\\n');
+}
+
+async function handleRequest(req: McpRequest): Promise<void> {
+  try {
+    switch (req.method) {
+      case 'initialize':
+        sendResponse({
+          jsonrpc: '2.0',
+          id: req.id,
+          result: {
+            protocolVersion: '2024-11-05',
+            serverInfo: {
+              name: 'auto-mcp-server',
+              version: '0.1.0',
+            },
+            capabilities: {
+              tools: {},
+            },
+          },
+        });
+        break;
+
+      case 'tools/list':
+        sendResponse({
+          jsonrpc: '2.0',
+          id: req.id,
+          result: { tools: TOOLS },
+        });
+        break;
+
+      case 'tools/call':
+        const result = await callTool(
+          (req.params as Record<string, string>)?.name,
+          (req.params as Record<string, unknown>)?.arguments || {},
+        );
+        sendResponse({
+          jsonrpc: '2.0',
+          id: req.id,
+          result,
+        });
+        break;
+
+      case 'notifications/initialized':
+        void 0;
+        break;
+
+      case 'ping':
+        sendResponse({
+          jsonrpc: '2.0',
+          id: req.id,
+          result: {},
+        });
+        break;
+
+      default:
+        sendResponse({
+          jsonrpc: '2.0',
+          id: req.id,
+          error: {
+            code: -32601,
+            message: \`Method not found: \${req.method}\`,
+          },
+        });
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    sendResponse({
+      jsonrpc: '2.0',
+      id: req.id,
+      error: {
+        code: -32603,
+        message,
+      },
+    });
+  }
+}
+
+function main(): void {
+  let buffer = '';
+
+  process.stdin.setEncoding('utf-8');
+  process.stdin.on('data', (chunk: string) => {
+    buffer += chunk;
+
+    let newlineIdx: number;
+    while ((newlineIdx = buffer.indexOf('\\n')) !== -1) {
+      const line = buffer.substring(0, newlineIdx).trim();
+      buffer = buffer.substring(newlineIdx + 1);
+
+      if (!line) continue;
+
+      try {
+        const req = JSON.parse(line) as McpRequest;
+        handleRequest(req);
+      } catch {
+        sendResponse({
+          jsonrpc: '2.0',
+          id: undefined,
+          error: { code: -32700, message: 'Parse error' },
+        });
+      }
+    }
+  });
+
+  process.stdin.on('end', () => {
+    process.exit(0);
+  });
+
+  process.on('uncaughtException', (error: Error) => {
+    console.error('Uncaught exception:', error.message);
+    process.exit(1);
+  });
+
+  process.on('unhandledRejection', (reason: unknown) => {
+    console.error('Unhandled rejection:', reason instanceof Error ? reason.message : String(reason));
+    process.exit(1);
+  });
+}
+
+main();
+`;
+}
+
+function generateInputSchema(params: ToolParameter[]): Record<string, unknown> {
+  const properties: Record<string, Record<string, unknown>> = {};
+  const required: string[] = [];
+
+  for (const p of params) {
+    properties[p.name] = {
+      type: p.type,
+      description: p.description,
+    };
+    if (p.required) {
+      required.push(p.name);
+    }
+  }
+
+  return {
+    type: 'object',
+    properties,
+    ...(required.length > 0 ? { required } : {}),
+  };
+}
+
+function generateReadme(toolCount: number, sourceTypes: string[]): string {
+  const sources = sourceTypes
+    .map((s) => `- ${s}`)
+    .join('\n');
+
+  return `# Auto-MCP Server
+
+Auto-generated MCP server with ${toolCount} detected tools.
+
+## Sources Detected
+
+${sources}
+
+## Usage
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Build
+npm run build
+
+# Run (via stdio)
+node dist/server.js
+\`\`\`
+
+## Adding to Claude Desktop / Cursor / OpenCode
+
+\`\`\`json
+{
+  "mcpServers": {
+    "auto-mcp": {
+      "command": "node",
+      "args": ["dist/server.js"],
+      "cwd": "."
+    }
+  }
+}
+\`\`\`
+
+## Tools
+
+${toolCount} tools available. See \`src/server.ts\` for full tool definitions.
+
+## Generated by
+
+@aria/connector auto-mcp generator
+`;
+}
+
+// ─── Main generation ──────────────────────────────────────────────────────────
+
+export async function generateMcpServer(
+  projectPath: string,
+  outputPath: string,
+): Promise<McpGenerationResult> {
+  const absProjectPath = resolve(projectPath);
+  const absOutputPath = resolve(outputPath);
+
+  const tools = await detectToolCandidates(absProjectPath);
+
+  // Create output directory structure
+  const srcDir = join(absOutputPath, 'src');
+  mkdirSync(srcDir, { recursive: true });
+
+  // Write package.json
+  const pkgJson = {
+    name: 'auto-mcp-server',
+    version: '0.1.0',
+    description: `Auto-generated MCP server for ${basename(absProjectPath)}`,
+    type: 'module',
+    main: './dist/src/server.js',
+    types: './dist/src/server.d.ts',
+    scripts: {
+      build: 'tsc',
+      start: 'node dist/src/server.js',
+      dev: 'tsc --watch',
+    },
+    dependencies: {},
+    devDependencies: {
+      '@types/node': '^22.0.0',
+      typescript: '^5.7.0',
+    },
+    engines: {
+      node: '>=20.0.0',
+    },
+    license: 'UNLICENSED',
+    private: true,
+  };
+
+  writeFileSync(join(absOutputPath, 'package.json'), JSON.stringify(pkgJson, null, 2));
+
+  // Write tsconfig.json
+  const tsConfig = {
+    compilerOptions: {
+      target: 'ES2022',
+      module: 'ES2022',
+      moduleResolution: 'bundler',
+      outDir: './dist',
+      strict: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      forceConsistentCasingInFileNames: true,
+      declaration: true,
+      sourceMap: true,
+      noEmitOnError: true,
+    },
+    include: ['src/**/*.ts'],
+    exclude: ['node_modules', 'dist'],
+  };
+
+  writeFileSync(join(absOutputPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
+
+  // Write server.ts
+  const serverCode = generateServerCode(tools);
+  writeFileSync(join(srcDir, 'server.ts'), serverCode);
+
+  // Write README.md
+  const sourceTypes = [...new Set(tools.map((t) => t.source))];
+  const readme = generateReadme(tools.length, sourceTypes);
+  writeFileSync(join(absOutputPath, 'README.md'), readme);
+
+  return {
+    serverPath: absOutputPath,
+    toolCount: tools.length,
+    tools: tools.map((t) => t.name),
+  };
+}