@aria_asi/cli 0.2.0

package/dist/aria-connector/src/auto-mcp.js

@@ -0,0 +1,994 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'fs';
+import { basename, extname, join, relative, resolve } from 'path';
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+function readFileSafe(p) {
+    try {
+        return readFileSync(p, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+function walkDir(dir, extensions) {
+    const results = [];
+    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, beforeLineIdx) {
+    const lines = source.split('\n');
+    const docLines = [];
+    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, lineIdx) {
+    return extractJSDoc(source, lineIdx);
+}
+function snakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, '_$1')
+        .toLowerCase()
+        .replace(/^_/, '')
+        .replace(/[^a-z0-9_]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '');
+}
+function inferTsTypeFromValue(val) {
+    if (/^\d+$/.test(val))
+        return 'number';
+    if (/^(true|false)$/.test(val))
+        return 'boolean';
+    return 'string';
+}
+function paramFromTsSignature(param) {
+    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) {
+    return snakeCase(raw)
+        .replace(/^get_/, 'get_')
+        .replace(/[^a-z0-9_]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')
+        .substring(0, 64);
+}
+// ─── Express route detection ──────────────────────────────────────────────────
+function detectExpressRoutes(projectPath) {
+    const candidates = [];
+    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 = [];
+        // app.<method>(path, ...handler)
+        const methodRegex = /(?:app|router)\s*\.\s*(get|post|put|patch|delete|options|all)\s*\(\s*['"`]([^'"`]+)['"`]/gi;
+        let m;
+        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, handlerBody, jsdoc) {
+    const params = [];
+    // 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;
+    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, routePath, fileName) {
+    const parts = routePath.split('/').filter(Boolean);
+    const resource = parts.find((p) => !p.startsWith(':') && !p.startsWith('['));
+    const baseName = resource || basename(fileName, extname(fileName));
+    const prefixMap = {
+        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) {
+    const candidates = [];
+    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 = [];
+        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;
+            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;
+            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) {
+    const methods = [];
+    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, handlerBody, _jsdoc) {
+    const params = [];
+    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) {
+    return name === 'id' || name === 'ID' || name === 'Id' ? 'id' : snakeCase(name);
+}
+function buildNextPath(segments) {
+    return '/' + segments.map((s) => (s.startsWith('[') ? `:${s.replace(/[\[\]]/g, '')}` : s)).join('/');
+}
+// ─── CLI script detection ─────────────────────────────────────────────────────
+function detectCliScripts(projectPath) {
+    const candidates = [];
+    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)) {
+                    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)) {
+                    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) {
+    const params = [];
+    // commander/yargs style: .option('--name <type>', 'desc')
+    const optionRegex = /\.(?:option|requiredOption)\s*\(\s*['"](--?\w+)\s*(?:<(\w+)>)?['"],\s*['"]([^'"]*)['"]/g;
+    let m;
+    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) {
+    const params = [];
+    // Look for environment variable references in script commands
+    const envRegex = /\$\{?(\w+)\}?/g;
+    let m;
+    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) {
+    const candidates = [];
+    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;
+        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) {
+    if (!rawParams.trim())
+        return [];
+    const params = [];
+    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) {
+    const seen = new Map();
+    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) {
+    const candidates = [];
+    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;
+        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, routePath) {
+    const params = [];
+    // Extract route params
+    const pathParamRegex = /\{(\w+)\}/g;
+    let m;
+    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) {
+    const typeMap = {
+        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) {
+    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 = [];
+    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) {
+    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) {
+    const properties = {};
+    const required = [];
+    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, sourceTypes) {
+    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, outputPath) {
+    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),
+    };
+}
+//# sourceMappingURL=auto-mcp.js.map