mnehmos.trace.mcp 1.0.0

package/dist/patterns/registry.js

@@ -0,0 +1,304 @@
+/**
+ * Pattern Registry
+ *
+ * Registry for pattern matchers, following the same design as AdapterRegistry.
+ * Provides registration, lookup, and scanning capabilities.
+ *
+ * The registry uses a module-scoped singleton pattern with exported wrapper
+ * functions for a clean, functional API.
+ *
+ * @module patterns/registry
+ * @see .context/ADR-P2-1-PATTERN-MATCHER.md
+ *
+ * @example
+ * ```typescript
+ * import { registerPattern, scanForPatterns } from './patterns';
+ *
+ * // Register a custom pattern matcher
+ * registerPattern(myExpressMatcher);
+ *
+ * // Scan source file for patterns
+ * const matches = scanForPatterns(sourceFile, {
+ *   frameworks: ['express'],
+ *   types: ['call']
+ * });
+ * ```
+ */
+import { PatternNotFoundError, PatternValidationError, } from './errors.js';
+/**
+ * Registry of pattern matchers
+ *
+ * Follows the same design as AdapterRegistry from Phase 1,
+ * with module-scoped singleton and exported wrapper functions.
+ */
+class PatternRegistry {
+    matchers = new Map();
+    matchersByFramework = new Map();
+    /**
+     * Register a pattern matcher
+     * @throws {PatternValidationError} if matcher is invalid
+     */
+    register(matcher) {
+        this.validate(matcher);
+        // Warn on overwrite in debug mode
+        if (this.matchers.has(matcher.name) && process.env.DEBUG_TRACE_MCP) {
+            console.error(`[PatternRegistry] Overwriting matcher: ${matcher.name}`);
+        }
+        this.matchers.set(matcher.name, matcher);
+        // Index by framework
+        const existing = this.matchersByFramework.get(matcher.framework) || [];
+        this.matchersByFramework.set(matcher.framework, [...existing.filter(m => m.name !== matcher.name), matcher]);
+        if (process.env.DEBUG_TRACE_MCP) {
+            console.error(`[PatternRegistry] Registered: ${matcher.name} (${matcher.framework})`);
+        }
+    }
+    /**
+     * Get matcher by name
+     * @throws {PatternNotFoundError} if not found
+     */
+    get(name) {
+        const matcher = this.matchers.get(name);
+        if (!matcher) {
+            throw new PatternNotFoundError(name, this.names());
+        }
+        return matcher;
+    }
+    /**
+     * Get all matchers for a framework
+     */
+    getByFramework(framework) {
+        return this.matchersByFramework.get(framework) || [];
+    }
+    /**
+     * Get all matchers supporting a pattern type
+     */
+    getByType(type) {
+        return Array.from(this.matchers.values())
+            .filter(m => m.supportedTypes.includes(type));
+    }
+    /**
+     * Check if a matcher exists
+     */
+    has(name) {
+        return this.matchers.has(name);
+    }
+    /**
+     * List all matcher names
+     */
+    names() {
+        return Array.from(this.matchers.keys());
+    }
+    /**
+     * List all frameworks
+     */
+    frameworks() {
+        return Array.from(this.matchersByFramework.keys());
+    }
+    /**
+     * Scan a source file with all registered matchers
+     *
+     * @param sourceFile - The file to scan
+     * @param options - Optional filtering options
+     * @returns All matches found across all matchers
+     */
+    scan(sourceFile, options) {
+        let matchers = Array.from(this.matchers.values());
+        // Filter by framework
+        if (options?.frameworks?.length) {
+            matchers = matchers.filter(m => options.frameworks.includes(m.framework));
+        }
+        // Filter by pattern type
+        if (options?.types?.length) {
+            matchers = matchers.filter(m => m.supportedTypes.some(t => options.types.includes(t)));
+        }
+        const allMatches = [];
+        for (const matcher of matchers) {
+            const matches = matcher.scan
+                ? matcher.scan(sourceFile)
+                : this.defaultScan(matcher, sourceFile);
+            allMatches.push(...matches);
+        }
+        return allMatches;
+    }
+    defaultScan(matcher, sourceFile) {
+        const matches = [];
+        sourceFile.forEachDescendant((node) => {
+            const result = matcher.match(node);
+            if (result) {
+                matches.push(result);
+            }
+        });
+        return matches;
+    }
+    validate(matcher) {
+        const m = matcher;
+        if (!m.name || typeof m.name !== 'string') {
+            throw new PatternValidationError(matcher, "Matcher must have 'name' property");
+        }
+        if (!m.framework || typeof m.framework !== 'string') {
+            throw new PatternValidationError(matcher, "Matcher must have 'framework' property");
+        }
+        if (!Array.isArray(m.patterns) || m.patterns.length === 0) {
+            throw new PatternValidationError(matcher, "Matcher must have at least one pattern");
+        }
+        if (!Array.isArray(m.supportedTypes) || m.supportedTypes.length === 0) {
+            throw new PatternValidationError(matcher, "Matcher must declare supportedTypes");
+        }
+        if (typeof m.match !== 'function') {
+            throw new PatternValidationError(matcher, "Matcher must implement match()");
+        }
+        if (typeof m.extract !== 'function') {
+            throw new PatternValidationError(matcher, "Matcher must implement extract()");
+        }
+    }
+}
+// Module-scoped singleton
+const registry = new PatternRegistry();
+// ─────────────────────────────────────────────────────────────────────────────
+// Public API - Wrapper Functions
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Register a pattern matcher with the global registry.
+ *
+ * The matcher is validated before registration. If validation fails,
+ * a {@link PatternValidationError} is thrown with details.
+ *
+ * @param matcher - The pattern matcher to register
+ * @throws {PatternValidationError} If the matcher fails validation
+ *
+ * @example
+ * ```typescript
+ * import { registerPattern, BasePatternMatcher } from './patterns';
+ *
+ * class MyMatcher extends BasePatternMatcher {
+ *   readonly name = 'my-matcher';
+ *   readonly framework = 'express';
+ *   // ... implementation
+ * }
+ *
+ * registerPattern(new MyMatcher());
+ * ```
+ */
+export function registerPattern(matcher) {
+    registry.register(matcher);
+}
+/**
+ * Get a pattern matcher by its unique name.
+ *
+ * @param name - The unique name of the matcher to retrieve
+ * @returns The registered pattern matcher
+ * @throws {PatternNotFoundError} If no matcher with that name exists
+ *
+ * @example
+ * ```typescript
+ * const matcher = getPattern('express-router');
+ * const matches = matcher.scan(sourceFile);
+ * ```
+ */
+export function getPattern(name) {
+    return registry.get(name);
+}
+/**
+ * Get all pattern matchers for a specific framework.
+ *
+ * @param framework - The framework name to filter by
+ * @returns Array of matchers for that framework (empty if none)
+ *
+ * @example
+ * ```typescript
+ * const expressMatchers = getPatternsByFramework('express');
+ * console.log(`Found ${expressMatchers.length} Express matchers`);
+ * ```
+ */
+export function getPatternsByFramework(framework) {
+    return registry.getByFramework(framework);
+}
+/**
+ * Get all pattern matchers supporting a specific pattern type.
+ *
+ * @param type - The pattern type to filter by
+ * @returns Array of matchers supporting that type
+ *
+ * @example
+ * ```typescript
+ * const decoratorMatchers = getPatternsByType('decorator');
+ * // Returns matchers like NestJS that use decorators
+ * ```
+ */
+export function getPatternsByType(type) {
+    return registry.getByType(type);
+}
+/**
+ * Check if a pattern matcher is registered by name.
+ *
+ * @param name - The name to check
+ * @returns `true` if a matcher with that name exists
+ *
+ * @example
+ * ```typescript
+ * if (!hasPattern('express-router')) {
+ *   registerPattern(new ExpressRouterMatcher());
+ * }
+ * ```
+ */
+export function hasPattern(name) {
+    return registry.has(name);
+}
+/**
+ * List all registered pattern matcher names.
+ *
+ * @returns Array of all registered matcher names
+ *
+ * @example
+ * ```typescript
+ * console.log('Available matchers:', listPatterns().join(', '));
+ * ```
+ */
+export function listPatterns() {
+    return registry.names();
+}
+/**
+ * List all unique framework names from registered matchers.
+ *
+ * @returns Array of unique framework names
+ *
+ * @example
+ * ```typescript
+ * const frameworks = listFrameworks();
+ * // ['express', 'nestjs', 'trpc', ...]
+ * ```
+ */
+export function listFrameworks() {
+    return registry.frameworks();
+}
+/**
+ * Scan a source file for patterns using all registered matchers.
+ *
+ * This is the primary entry point for pattern detection. It applies
+ * all registered matchers (or a filtered subset) to find API patterns.
+ *
+ * @param sourceFile - The ts-morph SourceFile to scan
+ * @param options - Optional filtering options
+ * @returns Array of all matches found across all matchers
+ *
+ * @example
+ * ```typescript
+ * import { Project } from 'ts-morph';
+ *
+ * const project = new Project();
+ * const sourceFile = project.addSourceFileAtPath('./src/routes.ts');
+ *
+ * // Scan with all matchers
+ * const allMatches = scanForPatterns(sourceFile);
+ *
+ * // Scan with filters
+ * const expressMatches = scanForPatterns(sourceFile, {
+ *   frameworks: ['express'],
+ *   types: ['call']
+ * });
+ * ```
+ */
+export function scanForPatterns(sourceFile, options) {
+    return registry.scan(sourceFile, options);
+}
+//# sourceMappingURL=registry.js.map

package/dist/patterns/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/patterns/registry.ts"],"names":[],"mappings":"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"}

package/dist/patterns/rest/express.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Express Pattern Matcher
+ *
+ * Detects Express.js route patterns including:
+ * - app.get(), app.post(), etc.
+ * - router.get(), router.post(), etc.
+ * - app.route().get().post()
+ * - app.all(), app.use()
+ *
+ * @module patterns/rest/express
+ * @see .context/ADR-P2-2-REST-DETECTION.md
+ */
+import { Node } from 'ts-morph';
+import type { NormalizedSchema } from '../../core/types.js';
+import { BasePatternMatcher } from '../base.js';
+import type { PatternDef, MatchResult, PatternType } from '../types.js';
+/**
+ * Pattern matcher for Express.js routes.
+ *
+ * Detects patterns:
+ * - `app.get()`, `app.post()`, etc.
+ * - `router.get()`, `router.post()`, etc.
+ * - `app.route('/path').get().post()`
+ * - `app.all()`, `app.use()`
+ *
+ * @example
+ * ```typescript
+ * const matcher = new ExpressPatternMatcher();
+ * const result = matcher.match(callExpressionNode);
+ * if (result) {
+ *   console.log(result.captures.httpMethod); // 'GET'
+ *   console.log(result.captures.routePath);  // '/users/:id'
+ * }
+ * ```
+ */
+export declare class ExpressPatternMatcher extends BasePatternMatcher {
+    readonly name = "express";
+    readonly framework = "express";
+    readonly supportedTypes: PatternType[];
+    readonly patterns: PatternDef[];
+    /**
+     * Match an AST node against Express patterns
+     */
+    match(node: Node): MatchResult | null;
+    /**
+     * Match direct HTTP method calls: app.get(), router.post(), etc.
+     */
+    private matchDirectMethod;
+    /**
+     * Match route chain: app.route('/path').get().post()
+     */
+    private matchRouteChain;
+    /**
+     * Find app.route('/path') in a chain
+     */
+    private findRouteCall;
+    /**
+     * Check if a method name is an HTTP method
+     */
+    private isHttpMethod;
+    /**
+     * Get the router/app name from an expression
+     */
+    private getRouterName;
+    /**
+     * Extract string value from a path argument
+     */
+    private extractPathString;
+    /**
+     * Extract pattern - implement abstract method
+     */
+    protected matchPattern(pattern: PatternDef, node: Node): MatchResult | null;
+    /**
+     * Extract schema from match
+     */
+    extract(match: MatchResult): Promise<NormalizedSchema>;
+}
+//# sourceMappingURL=express.d.ts.map

package/dist/patterns/rest/express.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../../src/patterns/rest/express.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,IAAI,EAAwD,MAAM,UAAU,CAAC;AACtF,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAmBxE;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,qBAAsB,SAAQ,kBAAkB;IAC3D,QAAQ,CAAC,IAAI,aAAa;IAC1B,QAAQ,CAAC,SAAS,aAAa;IAC/B,QAAQ,CAAC,cAAc,EAAE,WAAW,EAAE,CAAqB;IAE3D,QAAQ,CAAC,QAAQ,EAAE,UAAU,EAAE,CAa7B;IAEF;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,WAAW,GAAG,IAAI;IAkBrC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA4DzB;;OAEG;IACH,OAAO,CAAC,eAAe;IA2CvB;;OAEG;IACH,OAAO,CAAC,aAAa;IA4BrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAIpB;;OAEG;IACH,OAAO,CAAC,aAAa;IAWrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAezB;;OAEG;IACH,SAAS,CAAC,YAAY,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI,GAAG,WAAW,GAAG,IAAI;IAK3E;;OAEG;IACG,OAAO,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA8C7D"}

package/dist/patterns/rest/express.js

@@ -0,0 +1,289 @@
+/**
+ * Express Pattern Matcher
+ *
+ * Detects Express.js route patterns including:
+ * - app.get(), app.post(), etc.
+ * - router.get(), router.post(), etc.
+ * - app.route().get().post()
+ * - app.all(), app.use()
+ *
+ * @module patterns/rest/express
+ * @see .context/ADR-P2-2-REST-DETECTION.md
+ */
+import { Node } from 'ts-morph';
+import { BasePatternMatcher } from '../base.js';
+import { parsePath } from './path-parser.js';
+import { detectExpressMiddleware } from './middleware.js';
+/* ═══════════════════════════════════════════════════════════════════════════
+ * 📋 Constants
+ * ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * HTTP methods supported by Express
+ */
+const HTTP_METHODS = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head', 'all'];
+/* ═══════════════════════════════════════════════════════════════════════════
+ * 🔍 ExpressPatternMatcher Class
+ * ═══════════════════════════════════════════════════════════════════════════ */
+/**
+ * Pattern matcher for Express.js routes.
+ *
+ * Detects patterns:
+ * - `app.get()`, `app.post()`, etc.
+ * - `router.get()`, `router.post()`, etc.
+ * - `app.route('/path').get().post()`
+ * - `app.all()`, `app.use()`
+ *
+ * @example
+ * ```typescript
+ * const matcher = new ExpressPatternMatcher();
+ * const result = matcher.match(callExpressionNode);
+ * if (result) {
+ *   console.log(result.captures.httpMethod); // 'GET'
+ *   console.log(result.captures.routePath);  // '/users/:id'
+ * }
+ * ```
+ */
+export class ExpressPatternMatcher extends BasePatternMatcher {
+    name = 'express';
+    framework = 'express';
+    supportedTypes = ['call', 'chain'];
+    patterns = [
+        // app.get(), router.post(), etc.
+        {
+            type: 'call',
+            signature: /^(get|post|put|delete|patch|options|head|all)$/i,
+            inputSchemaLocation: { type: 'body' },
+        },
+        // app.route().get().post()
+        {
+            type: 'chain',
+            signature: /\.route\s*\([^)]+\)\s*\./,
+            inputSchemaLocation: { type: 'chain-method', method: 'route' },
+        },
+    ];
+    /**
+     * Match an AST node against Express patterns
+     */
+    match(node) {
+        if (!node)
+            return null;
+        // Must be a call expression
+        if (!Node.isCallExpression(node)) {
+            return null;
+        }
+        // Check for route chain (app.route('/path').get())
+        const routeChainResult = this.matchRouteChain(node);
+        if (routeChainResult) {
+            return routeChainResult;
+        }
+        // Check for direct method call (app.get('/path', handler))
+        return this.matchDirectMethod(node);
+    }
+    /**
+     * Match direct HTTP method calls: app.get(), router.post(), etc.
+     */
+    matchDirectMethod(call) {
+        const expression = call.getExpression();
+        if (!Node.isPropertyAccessExpression(expression)) {
+            return null;
+        }
+        const methodName = expression.getName().toLowerCase();
+        if (!this.isHttpMethod(methodName)) {
+            return null;
+        }
+        // Get the receiver (app, router, userRouter, etc.)
+        const receiver = expression.getExpression();
+        const routerName = this.getRouterName(receiver);
+        // First argument should be the path
+        const args = call.getArguments();
+        if (args.length === 0) {
+            return null;
+        }
+        const pathArg = args[0];
+        const routePath = this.extractPathString(pathArg);
+        if (!routePath) {
+            return null;
+        }
+        // Parse path parameters
+        const pathParams = parsePath(routePath);
+        // Detect validation middleware
+        const middlewareArgs = args.slice(1, -1); // All but first (path) and last (handler)
+        const validationMiddleware = detectExpressMiddleware(middlewareArgs);
+        // Get handler (last argument)
+        const handler = args[args.length - 1];
+        const handlerNode = args.length > 1 ? handler : undefined;
+        const httpMethod = methodName.toUpperCase();
+        const sourceFile = call.getSourceFile();
+        const captures = {
+            httpMethod,
+            routePath,
+            pathParameters: pathParams,
+            routerName,
+            validationMiddleware: validationMiddleware.length > 0 ? validationMiddleware : undefined,
+            handlerNode,
+        };
+        return {
+            pattern: this.patterns[0],
+            node: call,
+            framework: this.framework,
+            identifier: `${httpMethod} ${routePath}`,
+            location: this.getLocation(call, sourceFile.getFilePath()),
+            captures,
+        };
+    }
+    /**
+     * Match route chain: app.route('/path').get().post()
+     */
+    matchRouteChain(call) {
+        const expression = call.getExpression();
+        if (!Node.isPropertyAccessExpression(expression)) {
+            return null;
+        }
+        const methodName = expression.getName().toLowerCase();
+        if (!this.isHttpMethod(methodName)) {
+            return null;
+        }
+        // Check if this is part of a route() chain
+        const routeInfo = this.findRouteCall(expression.getExpression());
+        if (!routeInfo) {
+            return null;
+        }
+        // Get handler (first argument for chained methods)
+        const args = call.getArguments();
+        const handlerNode = args.length > 0 ? args[0] : undefined;
+        const httpMethod = methodName.toUpperCase();
+        const pathParams = parsePath(routeInfo.path);
+        const sourceFile = call.getSourceFile();
+        const captures = {
+            httpMethod,
+            routePath: routeInfo.path,
+            pathParameters: pathParams,
+            routerName: routeInfo.routerName,
+            handlerNode,
+        };
+        return {
+            pattern: this.patterns[1],
+            node: call,
+            framework: this.framework,
+            identifier: `${httpMethod} ${routeInfo.path}`,
+            location: this.getLocation(call, sourceFile.getFilePath()),
+            captures,
+        };
+    }
+    /**
+     * Find app.route('/path') in a chain
+     */
+    findRouteCall(node) {
+        // Could be: app.route('/path') directly
+        if (Node.isCallExpression(node)) {
+            const expr = node.getExpression();
+            if (Node.isPropertyAccessExpression(expr) && expr.getName() === 'route') {
+                const args = node.getArguments();
+                if (args.length > 0) {
+                    const path = this.extractPathString(args[0]);
+                    if (path) {
+                        const routerName = this.getRouterName(expr.getExpression());
+                        return { path, routerName };
+                    }
+                }
+            }
+            // Could be chained: app.route('/path').get().post()
+            // Walk up the chain
+            return this.findRouteCall(expr);
+        }
+        // Could be property access in a chain
+        if (Node.isPropertyAccessExpression(node)) {
+            return this.findRouteCall(node.getExpression());
+        }
+        return null;
+    }
+    /**
+     * Check if a method name is an HTTP method
+     */
+    isHttpMethod(name) {
+        return HTTP_METHODS.includes(name.toLowerCase());
+    }
+    /**
+     * Get the router/app name from an expression
+     */
+    getRouterName(expr) {
+        if (Node.isIdentifier(expr)) {
+            return expr.getText();
+        }
+        if (Node.isPropertyAccessExpression(expr)) {
+            // Could be something like this.router
+            return expr.getText();
+        }
+        return undefined;
+    }
+    /**
+     * Extract string value from a path argument
+     */
+    extractPathString(arg) {
+        if (Node.isStringLiteral(arg)) {
+            return arg.getLiteralValue();
+        }
+        if (Node.isNoSubstitutionTemplateLiteral(arg)) {
+            return arg.getLiteralValue();
+        }
+        if (Node.isTemplateExpression(arg)) {
+            // For now, just return the head text
+            // Full template analysis would need variable resolution
+            return arg.getHead().getText().slice(1, -2); // Remove ` and ${
+        }
+        return undefined;
+    }
+    /**
+     * Extract pattern - implement abstract method
+     */
+    matchPattern(pattern, node) {
+        // Delegate to the main match method
+        return this.match(node);
+    }
+    /**
+     * Extract schema from match
+     */
+    async extract(match) {
+        const captures = match.captures;
+        // Build properties from path parameters
+        const properties = {};
+        // Add path parameters
+        if (captures.pathParameters) {
+            for (const param of captures.pathParameters) {
+                properties[`params.${param.name}`] = {
+                    type: { kind: 'primitive', value: param.inferredType === 'number' ? 'number' : 'string' },
+                    optional: param.optional,
+                    nullable: false,
+                    readonly: false,
+                    deprecated: false,
+                };
+            }
+        }
+        // Add validation middleware schemas
+        if (captures.validationMiddleware) {
+            for (const middleware of captures.validationMiddleware) {
+                // The actual schema extraction would need to parse the Zod/Joi schema
+                // For now, just note that validation exists
+                properties[`${middleware.target}._validated`] = {
+                    type: { kind: 'unknown' },
+                    optional: false,
+                    nullable: false,
+                    readonly: false,
+                    deprecated: false,
+                    description: `Validated by ${middleware.library}`,
+                };
+            }
+        }
+        return {
+            name: match.identifier,
+            properties,
+            required: Object.keys(properties).filter(k => !properties[k].optional),
+            source: {
+                source: 'typescript',
+                id: `express:${match.identifier}`,
+            },
+            location: match.location,
+        };
+    }
+}
+//# sourceMappingURL=express.js.map