agent-manifest 3.2.0 → 3.3.0

package/dist/parser/remix-parser.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemixParser = void 0;
+exports.looksLikeRemixRouteFile = looksLikeRemixRouteFile;
+const ts_morph_1 = require("ts-morph");
+const intent_classifier_1 = require("./intent-classifier");
+const path = __importStar(require("path"));
+/**
+ * Parses Remix route files and extracts `action` and `loader` exports.
+ *
+ * Remix v2 file-based routing:
+ *   app/routes/users.tsx         → /users
+ *   app/routes/users.$id.tsx     → /users/:id
+ *   app/routes/_index.tsx        → /  (layout route — leading _ stripped)
+ *   app/routes/users.$id.edit.tsx → /users/:id/edit
+ *
+ * - `loader`  export → GET  (read)
+ * - `action`  export → POST (write)
+ */
+class RemixParser {
+    project;
+    constructor(sharedProject) {
+        this.project = sharedProject ?? new ts_morph_1.Project({
+            compilerOptions: { allowJs: true, checkJs: false },
+        });
+    }
+    async parseFile(filePath, projectPath) {
+        const sourceFile = this.project.addSourceFileAtPath(filePath);
+        const routePath = this.filePathToRoute(filePath, projectPath);
+        const actions = [];
+        // Look for: export async function action / export async function loader
+        // or: export const action = async ({ request }) => { ... }
+        const exportedNames = this.getExportedNames(sourceFile);
+        for (const exportName of exportedNames) {
+            if (exportName !== 'action' && exportName !== 'loader')
+                continue;
+            const httpMethod = exportName === 'loader' ? 'GET' : 'POST';
+            const actionName = this.routeToActionName(routePath, exportName);
+            const safety = (0, intent_classifier_1.classifySafety)({ name: actionName, httpMethod, type: 'api' });
+            actions.push({
+                name: actionName,
+                description: `Remix ${exportName}: ${httpMethod} ${routePath}`,
+                intent: (0, intent_classifier_1.inferIntent)(actionName),
+                type: 'api',
+                location: routePath,
+                method: httpMethod,
+                safety,
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, httpMethod, type: 'api' }),
+                inputs: this.extractRouteParams(routePath),
+                outputs: { type: 'object' },
+            });
+        }
+        return actions;
+    }
+    getExportedNames(sourceFile) {
+        const names = [];
+        // export function name / export async function name
+        for (const fn of sourceFile.getFunctions()) {
+            if (fn.isExported())
+                names.push(fn.getName() ?? '');
+        }
+        // export const name = ...
+        for (const varStatement of sourceFile.getVariableStatements()) {
+            if (!varStatement.isExported())
+                continue;
+            for (const decl of varStatement.getDeclarations()) {
+                names.push(decl.getName());
+            }
+        }
+        return names.filter(Boolean);
+    }
+    /**
+     * Convert a Remix v2 file path to a URL route path.
+     *
+     * Rules:
+     *  - Strip leading `app/routes/` prefix
+     *  - Strip file extension
+     *  - Split on `.` → each segment becomes a path segment
+     *  - `$param` → `:param`
+     *  - Segments starting with `_` are layout markers — skip (unless it's the whole segment)
+     *  - `_index` → empty (index route)
+     */
+    filePathToRoute(filePath, projectPath) {
+        const rel = path.relative(projectPath, filePath).replace(/\\/g, '/');
+        // Strip known prefix variations: app/routes/, routes/
+        const withoutPrefix = rel
+            .replace(/^.*?(?:app\/routes|routes)\//, '')
+            .replace(/\.[jt]sx?$/, '');
+        const segments = withoutPrefix.split('.');
+        const routeSegments = [];
+        for (const seg of segments) {
+            if (seg === '_index')
+                continue; // index route
+            if (seg.startsWith('_'))
+                continue; // layout route (e.g. _auth, _app)
+            routeSegments.push(seg.replace(/^\$/, ':')); // $id → :id
+        }
+        return '/' + routeSegments.join('/');
+    }
+    routeToActionName(routePath, exportName) {
+        const slug = routePath
+            .replace(/^\//, '')
+            .replace(/\/:([^/]+)/g, '_$1')
+            .replace(/\//g, '_')
+            .replace(/[^a-zA-Z0-9_]/g, '');
+        return slug ? `${slug}_${exportName}` : `root_${exportName}`;
+    }
+    extractRouteParams(routePath) {
+        const params = {};
+        for (const match of routePath.matchAll(/:([a-zA-Z][a-zA-Z0-9_]*)/g)) {
+            params[match[1]] = { type: 'string', description: `Path parameter: ${match[1]}`, required: true };
+        }
+        return params;
+    }
+}
+exports.RemixParser = RemixParser;
+function looksLikeRemixRouteFile(content) {
+    return ((content.includes('export') && content.includes('function loader')) ||
+        (content.includes('export') && content.includes('function action')) ||
+        content.includes('LoaderFunctionArgs') ||
+        content.includes('ActionFunctionArgs') ||
+        content.includes('LoaderFunction') ||
+        content.includes('ActionFunction'));
+}

package/dist/parser/socketio-parser.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketIOParser = void 0;
+exports.looksLikeSocketIOFile = looksLikeSocketIOFile;
+const ts_morph_1 = require("ts-morph");
+const intent_classifier_1 = require("./intent-classifier");
+const path = __importStar(require("path"));
+/**
+ * Parses Socket.IO server files and extracts socket event handlers as agent actions.
+ *
+ * Detects patterns like:
+ *   socket.on("create-room", ({ playerName, fid }: { playerName: string; fid?: number }) => { ... })
+ *   socket.on("make-move", async ({ col }: { col: number }) => { ... })
+ *
+ * Infrastructure events (connection, disconnect, error, etc.) are skipped.
+ */
+const SKIP_EVENTS = new Set([
+    'connection', 'disconnect', 'disconnecting', 'connect',
+    'connect_error', 'reconnect', 'reconnect_attempt', 'reconnect_error',
+    'reconnect_failed', 'error', 'ping', 'pong', 'close', 'open',
+]);
+class SocketIOParser {
+    project;
+    constructor(sharedProject) {
+        this.project = sharedProject ?? new ts_morph_1.Project({
+            compilerOptions: { allowJs: true, checkJs: false },
+        });
+    }
+    async parseFile(filePath, projectPath) {
+        const sourceFile = this.project.addSourceFileAtPath(filePath);
+        const relativePath = './' + path.relative(projectPath, filePath).replace(/\\/g, '/');
+        const actions = [];
+        const seen = new Set();
+        sourceFile.forEachDescendant(node => {
+            if (!ts_morph_1.Node.isCallExpression(node))
+                return;
+            const expr = node.getExpression();
+            if (!ts_morph_1.Node.isPropertyAccessExpression(expr))
+                return;
+            if (expr.getName() !== 'on')
+                return;
+            const args = node.getArguments();
+            if (args.length < 2)
+                return;
+            const eventArg = args[0];
+            if (!ts_morph_1.Node.isStringLiteral(eventArg))
+                return;
+            const eventName = eventArg.getLiteralValue();
+            if (SKIP_EVENTS.has(eventName))
+                return;
+            if (seen.has(eventName))
+                return;
+            seen.add(eventName);
+            const handler = args[1];
+            if (!ts_morph_1.Node.isArrowFunction(handler) && !ts_morph_1.Node.isFunctionExpression(handler))
+                return;
+            // Extract description from JSDoc on the handler
+            let description = `Socket event: ${eventName}`;
+            const jsDocs = handler.getJsDocs?.() ?? [];
+            if (jsDocs.length > 0) {
+                const text = jsDocs[0].getDescription().trim();
+                if (text)
+                    description = text;
+            }
+            const inputs = this.extractInputs(handler);
+            // Normalize kebab-case event names to camelCase for intent/safety classification
+            const camelName = eventName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+            const safety = (0, intent_classifier_1.classifySafety)({ name: camelName, type: 'socket' });
+            const intent = (0, intent_classifier_1.inferIntent)(camelName);
+            actions.push({
+                name: eventName,
+                description,
+                intent,
+                type: 'socket',
+                location: relativePath,
+                socketEvent: eventName,
+                safety,
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, type: 'socket' }),
+                inputs,
+                outputs: { type: 'object' },
+            });
+        });
+        return actions;
+    }
+    extractInputs(handler) {
+        const params = handler.getParameters?.() ?? [];
+        if (params.length === 0)
+            return {};
+        const firstParam = params[0];
+        const bindingPattern = firstParam.getNameNode?.();
+        if (!bindingPattern || !ts_morph_1.Node.isObjectBindingPattern(bindingPattern))
+            return {};
+        // Prefer explicit type annotation on the parameter: ({ col }: { col: number })
+        const typeNode = firstParam.getTypeNode?.();
+        if (typeNode && ts_morph_1.Node.isTypeLiteral(typeNode)) {
+            const inputs = {};
+            for (const member of typeNode.getMembers()) {
+                if (!ts_morph_1.Node.isPropertySignature(member))
+                    continue;
+                const name = member.getName();
+                const optional = member.hasQuestionToken();
+                const tsType = member.getTypeNode()?.getText() ?? 'any';
+                inputs[name] = {
+                    type: this.tsTypeToJsonType(tsType),
+                    required: !optional,
+                };
+            }
+            return inputs;
+        }
+        // Fallback: read names from the destructuring pattern only (no type info)
+        const inputs = {};
+        for (const element of bindingPattern.getElements()) {
+            if (ts_morph_1.Node.isBindingElement(element)) {
+                inputs[element.getName()] = { type: 'any', required: true };
+            }
+        }
+        return inputs;
+    }
+    tsTypeToJsonType(ts) {
+        const t = ts.trim();
+        if (t === 'string')
+            return 'string';
+        if (t === 'number' || t === 'bigint')
+            return 'number';
+        if (t === 'boolean')
+            return 'boolean';
+        return 'object';
+    }
+}
+exports.SocketIOParser = SocketIOParser;
+/** Quick check: does this file look like it registers Socket.IO event handlers? */
+function looksLikeSocketIOFile(content) {
+    return (/socket\.on\s*\(\s*['"`]/.test(content) ||
+        /io\.on\s*\(\s*['"`]connection['"`]/.test(content));
+}

package/dist/parser/sse-parser.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEParser = void 0;
+exports.looksLikeSSEFile = looksLikeSSEFile;
+const ts_morph_1 = require("ts-morph");
+const intent_classifier_1 = require("./intent-classifier");
+const path = __importStar(require("path"));
+/**
+ * Detects Server-Sent Event (SSE) streaming endpoints.
+ *
+ * Patterns detected:
+ *   // Express
+ *   res.setHeader('Content-Type', 'text/event-stream')
+ *   res.writeHead(200, { 'Content-Type': 'text/event-stream' })
+ *
+ *   // Next.js App Router (route handler)
+ *   return new Response(stream, { headers: { 'Content-Type': 'text/event-stream' } })
+ *   return new StreamingTextResponse(stream)
+ *
+ *   // AI SDK
+ *   return result.toDataStreamResponse()
+ *   return result.toTextStreamResponse()
+ *
+ * SSE endpoints are classified as 'read' safety + streaming output.
+ */
+class SSEParser {
+    project;
+    constructor(sharedProject) {
+        this.project = sharedProject ?? new ts_morph_1.Project({
+            compilerOptions: { allowJs: true, checkJs: false },
+        });
+    }
+    async parseFile(filePath, projectPath) {
+        const sourceFile = this.project.addSourceFileAtPath(filePath);
+        const relativePath = './' + path.relative(projectPath, filePath).replace(/\\/g, '/');
+        const actions = [];
+        // Collect functions/arrow-fns that contain SSE signals
+        const sseFunctions = new Set();
+        sourceFile.forEachDescendant(node => {
+            if (!this.isSSESignal(node))
+                return;
+            // Walk up to the nearest function/arrow/method to name the action
+            const fn = node.getFirstAncestorByKind(213 /* ArrowFunction */) ??
+                node.getFirstAncestorByKind(259 /* FunctionDeclaration */) ??
+                node.getFirstAncestorByKind(171 /* MethodDeclaration */) ??
+                node.getFirstAncestorByKind(215 /* FunctionExpression */);
+            if (fn && !sseFunctions.has(fn)) {
+                sseFunctions.add(fn);
+            }
+        });
+        for (const fn of sseFunctions) {
+            const name = this.resolveFunctionName(fn, filePath);
+            const safety = 'read';
+            actions.push({
+                name,
+                description: `Streaming SSE endpoint — ${path.basename(filePath)}`,
+                intent: (0, intent_classifier_1.inferIntent)(name),
+                type: 'api',
+                location: relativePath,
+                method: 'GET',
+                safety,
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                requiredAuth: (0, intent_classifier_1.inferActionAuth)({ safety, httpMethod: 'GET', type: 'api' }),
+                inputs: {},
+                outputs: { type: 'stream', description: 'Server-Sent Events stream' },
+            });
+        }
+        return actions;
+    }
+    isSSESignal(node) {
+        if (ts_morph_1.Node.isStringLiteral(node)) {
+            return node.getLiteralValue() === 'text/event-stream';
+        }
+        if (ts_morph_1.Node.isCallExpression(node)) {
+            const text = node.getText();
+            return (text.includes('toDataStreamResponse') ||
+                text.includes('toTextStreamResponse') ||
+                text.includes('toUIMessageStreamResponse') ||
+                text.includes('StreamingTextResponse'));
+        }
+        return false;
+    }
+    resolveFunctionName(fn, filePath) {
+        // Named function declaration
+        const decl = fn.getName?.();
+        if (decl)
+            return decl;
+        // Arrow function assigned to a variable
+        const varDecl = fn.getFirstAncestorByKind(249 /* VariableDeclaration */);
+        if (varDecl) {
+            const varName = varDecl.getName?.();
+            if (varName)
+                return varName;
+        }
+        // Fallback: derive from filename
+        const base = path.basename(filePath, path.extname(filePath));
+        return `${base}_stream`;
+    }
+}
+exports.SSEParser = SSEParser;
+function looksLikeSSEFile(content) {
+    return (content.includes('text/event-stream') ||
+        content.includes('toDataStreamResponse') ||
+        content.includes('toTextStreamResponse') ||
+        content.includes('toUIMessageStreamResponse') ||
+        content.includes('StreamingTextResponse') ||
+        content.includes('event-stream'));
+}

package/dist/parser/trpc-parser.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRPCParser = void 0;
+exports.looksLikeTRPCFile = looksLikeTRPCFile;
+const ts_morph_1 = require("ts-morph");
+const intent_classifier_1 = require("./intent-classifier");
+const path = __importStar(require("path"));
+/**
+ * Parses tRPC router files and extracts procedures as agent actions.
+ *
+ * Detects patterns like:
+ *   export const userRouter = createTRPCRouter({
+ *     list:   publicProcedure.query(({ ctx }) => { ... }),
+ *     create: protectedProcedure.input(z.object({ name: z.string() })).mutation(({ ctx, input }) => { ... }),
+ *   });
+ */
+class TRPCParser {
+    project;
+    constructor(sharedProject) {
+        this.project = sharedProject ?? new ts_morph_1.Project({
+            compilerOptions: { allowJs: true, checkJs: false },
+        });
+    }
+    async parseFile(filePath, projectPath) {
+        const sourceFile = this.project.addSourceFileAtPath(filePath);
+        const relativePath = './' + path.relative(projectPath, filePath).replace(/\\/g, '/');
+        const actions = [];
+        const seen = new Set();
+        sourceFile.forEachDescendant(node => {
+            if (!ts_morph_1.Node.isCallExpression(node))
+                return;
+            const expr = node.getExpression();
+            if (!ts_morph_1.Node.isPropertyAccessExpression(expr))
+                return;
+            const methodName = expr.getName();
+            if (methodName !== 'query' && methodName !== 'mutation' && methodName !== 'subscription')
+                return;
+            // Walk up to find the PropertyAssignment that gives us the procedure name.
+            // Structure: createTRPCRouter({ procedureName: procedure.input(...).query(handler) })
+            const propAssignment = node.getFirstAncestorByKind(147 /* SyntaxKind.PropertyAssignment */);
+            if (!propAssignment)
+                return;
+            const procedureName = propAssignment.getName?.()?.replace(/['"]/g, '') ?? '';
+            if (!procedureName || seen.has(procedureName))
+                return;
+            seen.add(procedureName);
+            // Determine if protected (auth required) by scanning the chain text
+            const chainText = expr.getExpression().getText();
+            const isProtected = /protected|authed|private|admin|requireAuth/i.test(chainText);
+            // Description from JSDoc on the PropertyAssignment
+            let description = `tRPC ${methodName}: ${procedureName}`;
+            const jsDocs = propAssignment.getJsDocs?.() ?? [];
+            if (jsDocs.length > 0) {
+                const text = jsDocs[0].getDescription?.().trim();
+                if (text)
+                    description = text;
+            }
+            // Extract inputs from .input(z.object({...})) in the chain
+            const inputs = this.extractInputsFromChain(expr.getExpression());
+            // query → GET semantics, mutation → POST, subscription → streaming
+            const httpLike = methodName === 'query' ? 'GET' : 'POST';
+            const safety = (0, intent_classifier_1.classifySafety)({ name: procedureName, httpMethod: httpLike, type: 'function' });
+            actions.push({
+                name: procedureName,
+                description,
+                intent: (0, intent_classifier_1.inferIntent)(procedureName),
+                type: 'function',
+                location: relativePath,
+                method: methodName,
+                safety,
+                agentSafe: (0, intent_classifier_1.deriveAgentSafe)(safety),
+                requiredAuth: (0, intent_classifier_1.inferActionAuth)({
+                    safety,
+                    httpMethod: httpLike,
+                    appAuthType: isProtected ? 'bearer' : undefined,
+                    type: 'function',
+                }),
+                inputs,
+                outputs: { type: 'object' },
+            });
+        });
+        return actions;
+    }
+    /**
+     * Walk the call expression chain (e.g. procedure.use(mid).input(schema).query(handler))
+     * looking for an .input(zodObject) call and extract its fields.
+     */
+    extractInputsFromChain(chainExpr) {
+        // Traverse the chain: each link is a PropertyAccessExpression whose object
+        // is another CallExpression.  We're looking for the one named "input".
+        let current = chainExpr;
+        while (current) {
+            if (ts_morph_1.Node.isCallExpression(current)) {
+                const callExpr = current;
+                const callCallee = callExpr.getExpression?.();
+                if (ts_morph_1.Node.isPropertyAccessExpression(callCallee) && callCallee.getName() === 'input') {
+                    const inputArg = callExpr.getArguments?.()[0];
+                    if (inputArg)
+                        return this.extractZodObjectFields(inputArg);
+                }
+                current = callExpr.getExpression?.();
+            }
+            else if (ts_morph_1.Node.isPropertyAccessExpression(current)) {
+                current = current.getExpression?.();
+            }
+            else {
+                break;
+            }
+        }
+        return {};
+    }
+    /** Extract field names/types from a z.object({ ... }) argument node. */
+    extractZodObjectFields(node) {
+        if (!ts_morph_1.Node.isCallExpression(node))
+            return {};
+        const callee = node.getExpression();
+        if (!ts_morph_1.Node.isPropertyAccessExpression(callee) || callee.getName() !== 'object')
+            return {};
+        const arg = node.getArguments()[0];
+        if (!ts_morph_1.Node.isObjectLiteralExpression(arg))
+            return {};
+        const inputs = {};
+        for (const prop of arg.getProperties()) {
+            if (!ts_morph_1.Node.isPropertyAssignment(prop))
+                continue;
+            const name = prop.getName().replace(/['"]/g, '');
+            const valText = prop.getInitializer()?.getText() ?? '';
+            const optional = valText.includes('.optional()') || valText.includes('.nullish()');
+            inputs[name] = {
+                type: this.inferZodType(valText),
+                required: !optional,
+            };
+        }
+        return inputs;
+    }
+    inferZodType(zodText) {
+        if (/z\.string/i.test(zodText))
+            return 'string';
+        if (/z\.number|z\.int/i.test(zodText))
+            return 'number';
+        if (/z\.boolean/i.test(zodText))
+            return 'boolean';
+        if (/z\.array/i.test(zodText))
+            return 'array';
+        if (/z\.object/i.test(zodText))
+            return 'object';
+        if (/z\.enum/i.test(zodText))
+            return 'string';
+        return 'any';
+    }
+}
+exports.TRPCParser = TRPCParser;
+function looksLikeTRPCFile(content) {
+    return (content.includes('createTRPCRouter') ||
+        content.includes('initTRPC') ||
+        content.includes('publicProcedure') ||
+        content.includes('protectedProcedure') ||
+        (content.includes('.query(') && content.includes('procedure')));
+}