seer-mcp 0.1.0

package/src/parser/languages/go.ts

@@ -0,0 +1,259 @@
+import type Parser from 'web-tree-sitter';
+import type { SymbolDef, ServiceCallDef } from '../../types.js';
+import type { LanguageExtractor } from '../walker.js';
+import { firstLine } from '../walker.js';
+
+// Go HTTP-client method names. The receiver may be `http`, `http.DefaultClient`,
+// or any user client (e.g. `myClient`).
+const GO_HTTP_VERBS = new Set([
+  'Get', 'Post', 'PostForm', 'Head', 'Do', 'Patch', 'Put', 'Delete', 'NewRequest',
+]);
+
+const GO_BRANCH_NODES = new Set<string>([
+  'if_statement', 'for_statement', 'expression_case', 'default_case',
+  'type_case', 'communication_case', 'select_statement',
+]);
+
+const GO_NESTING_NODES = new Set<string>([
+  'if_statement', 'for_statement', 'expression_switch_statement',
+  'type_switch_statement', 'select_statement',
+]);
+
+const GO_CANDIDATE_NODE_TYPES = [
+  // tryExtractDefinition
+  'function_declaration',
+  'method_declaration',
+  'type_declaration',
+  // tryExtractCallName
+  'call_expression',
+  // tryExtractImport
+  'import_spec',
+] as const;
+
+export const goExtractor: LanguageExtractor = {
+  languageName: 'go',
+  extensions: ['.go'],
+  branchNodeTypes: GO_BRANCH_NODES,
+  nestingNodeTypes: GO_NESTING_NODES,
+  candidateNodeTypes: GO_CANDIDATE_NODE_TYPES,
+
+  tryExtractDefinition(node: Parser.SyntaxNode): SymbolDef | null {
+    switch (node.type) {
+      case 'function_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) return null;
+        return {
+          name: nameNode.text,
+          kind: 'function',
+          lineStart: node.startPosition.row,
+          lineEnd:   node.endPosition.row,
+          colStart:  node.startPosition.column,
+          colEnd:    node.endPosition.column,
+          signature: firstLine(node),
+        };
+      }
+
+      case 'method_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) return null;
+        return {
+          name: nameNode.text,
+          kind: 'method',
+          lineStart: node.startPosition.row,
+          lineEnd:   node.endPosition.row,
+          colStart:  node.startPosition.column,
+          colEnd:    node.endPosition.column,
+          signature: firstLine(node),
+        };
+      }
+
+      // type Foo struct {} or type Foo interface {}
+      case 'type_declaration': {
+        // type_declaration contains one or more type_spec children
+        for (const child of node.children) {
+          if (child.type === 'type_spec') {
+            const nameNode = child.childForFieldName('name');
+            if (!nameNode) continue;
+            const typeNode = child.childForFieldName('type');
+            const kind = typeNode?.type === 'interface_type' ? 'interface'
+                       : typeNode?.type === 'struct_type'    ? 'struct'
+                       : 'type';
+            return {
+              name: nameNode.text,
+              kind,
+              lineStart: node.startPosition.row,
+              lineEnd:   node.endPosition.row,
+              colStart:  node.startPosition.column,
+              colEnd:    node.endPosition.column,
+              signature: firstLine(node),
+            };
+          }
+        }
+        return null;
+      }
+
+      default:
+        return null;
+    }
+  },
+
+  tryExtractCallName(node: Parser.SyntaxNode): string | null {
+    if (node.type !== 'call_expression') return null;
+    const funcNode = node.childForFieldName('function');
+    if (!funcNode) return null;
+
+    // foo()
+    if (funcNode.type === 'identifier') return funcNode.text;
+
+    // pkg.Func() or receiver.Method()
+    if (funcNode.type === 'selector_expression') {
+      return funcNode.childForFieldName('field')?.text ?? null;
+    }
+
+    return null;
+  },
+
+  tryExtractImport(node: Parser.SyntaxNode): string | null {
+    // import_spec contains a "path" field (interpreted_string_literal)
+    if (node.type === 'import_spec') {
+      const pathNode = node.childForFieldName('path');
+      return pathNode?.text?.replace(/['"]/g, '') ?? null;
+    }
+    return null;
+  },
+
+  /**
+   * Go HTTP-client calls:
+   *   http.Get("https://x/y")           ← yes
+   *   http.Post("/api", "json", body)   ← yes
+   *   client.Get("/api/users")          ← yes (any receiver, capital verb)
+   *   http.NewRequest("GET", "/x", …)   ← yes (method = first string arg)
+   */
+  tryExtractServiceCalls(node: Parser.SyntaxNode): ServiceCallDef[] | null {
+    if (node.type !== 'call_expression') return null;
+    const fn = node.childForFieldName('function');
+    if (!fn || fn.type !== 'selector_expression') return null;
+    const recv = fn.childForFieldName('operand');
+    const field = fn.childForFieldName('field');
+    if (!recv || !field) return null;
+    const verb = field.text;
+
+    // v9 Track-H — gRPC client call:
+    //   pb.NewUserServiceClient(conn).GetUser(ctx, &req)
+    // recv is a call_expression to pb.New<X>ServiceClient(...) or pb.New<X>Client(...);
+    // verb is the method (capitalized). We emit a service_call with operation
+    // = "Service/Method" matching the .proto resolver.
+    if (recv.type === 'call_expression' && verb && /^[A-Z]/.test(verb)) {
+      const grpc = tryExtractGoGrpcCall(node, recv, verb);
+      if (grpc) return [grpc];
+    }
+
+    if (!GO_HTTP_VERBS.has(verb)) return null;
+
+    let framework: string;
+    if (recv.text === 'http') framework = 'http';
+    else if (recv.text === 'httputil') framework = 'httputil';
+    else framework = 'http-client';
+
+    const args = node.childForFieldName('arguments');
+    if (!args) return null;
+    const named = args.namedChildren;
+
+    let method: string | undefined;
+    let urlIdx = 0;
+    if (verb === 'NewRequest' || verb === 'NewRequestWithContext') {
+      const ctxOffset = verb === 'NewRequestWithContext' ? 1 : 0;
+      const methodNode = named[ctxOffset];
+      if (methodNode && methodNode.type === 'interpreted_string_literal') {
+        method = methodNode.text.replace(/['"`]/g, '').toUpperCase();
+      }
+      urlIdx = ctxOffset + 1;
+    } else if (verb === 'Do') {
+      // http.Client.Do(req) doesn't expose the URL here; skip.
+      return null;
+    } else {
+      method = verb === 'Get' ? 'GET'
+            : verb === 'Post' ? 'POST'
+            : verb === 'PostForm' ? 'POST'
+            : verb === 'Head' ? 'HEAD'
+            : verb === 'Patch' ? 'PATCH'
+            : verb === 'Put' ? 'PUT'
+            : verb === 'Delete' ? 'DELETE'
+            : 'ANY';
+    }
+
+    const urlNode = named[urlIdx];
+    if (!urlNode) return null;
+    let raw: string | null = null;
+    if (urlNode.type === 'interpreted_string_literal' || urlNode.type === 'raw_string_literal') {
+      raw = urlNode.text.replace(/^[`"']|[`"']$/g, '');
+    } else {
+      return null;
+    }
+    if (!raw || !goLooksLikeHttpTarget(raw)) return null;
+
+    return [{
+      protocol: 'http',
+      method: method ?? 'ANY',
+      rawTarget: raw.slice(0, 240),
+      framework,
+      line: node.startPosition.row,
+      confidence: 0.85,
+    }];
+  },
+};
+
+/**
+ * v9 Track-H — detect a gRPC client stub call in Go.
+ *
+ * Pattern: `pb.NewUserServiceClient(conn).GetUser(ctx, &req)`
+ *
+ * `recv` is the inner call expression (`pb.NewUserServiceClient(conn)`); we
+ * look at its callee to harvest the service name from `NewXServiceClient` or
+ * `NewXClient`. The outer method (`GetUser`) becomes the rpc method.
+ *
+ * Returns a ServiceCallDef with:
+ *   - protocol = 'grpc'
+ *   - operation = 'Service/Method' (matches .proto-derived routes)
+ *   - service   = 'UserService'
+ *   - method    = 'GetUser'
+ *
+ * Returns null if the inner callee does not parse as a NewXClient
+ * constructor — keeps determinism high (no false-positive on a chained
+ * method call against an unrelated builder pattern).
+ */
+function tryExtractGoGrpcCall(
+  outer: Parser.SyntaxNode,
+  recv: Parser.SyntaxNode,
+  rpcMethod: string,
+): ServiceCallDef | null {
+  const innerFn = recv.childForFieldName('function');
+  if (!innerFn || innerFn.type !== 'selector_expression') return null;
+  const innerField = innerFn.childForFieldName('field');
+  if (!innerField) return null;
+  const ctor = innerField.text;
+  // Match `New(.*)(?:Service)?Client$`. Service is the middle capture if it ends
+  // in "ServiceClient"; otherwise strip just "Client".
+  const m = ctor.match(/^New([A-Z][A-Za-z0-9_]*?)(Service)?Client$/);
+  if (!m) return null;
+  const serviceName = m[1] + (m[2] ? 'Service' : '');
+  const operation = `${serviceName}/${rpcMethod}`;
+  return {
+    protocol: 'grpc',
+    method: rpcMethod.toUpperCase(),
+    rawTarget: `${ctor}.${rpcMethod}`,
+    framework: 'grpc-go',
+    line: outer.startPosition.row,
+    confidence: 0.9,
+    operation,
+    service: serviceName,
+  };
+}
+
+function goLooksLikeHttpTarget(s: string): boolean {
+  if (!s) return false;
+  if (s.startsWith('/')) return true;
+  if (/^https?:\/\//i.test(s)) return true;
+  if (/^[a-zA-Z0-9._-]+\/[a-zA-Z0-9_-]/.test(s)) return true;
+  return false;
+}

package/src/parser/languages/java.ts

@@ -0,0 +1,382 @@
+import type Parser from 'web-tree-sitter';
+import type { SymbolDef, RouteDef, ConfigKeyRead, ServiceCallDef } from '../../types.js';
+import type { LanguageExtractor } from '../walker.js';
+import { firstLine } from '../walker.js';
+
+const JAVA_BRANCH_NODES = new Set<string>([
+  'if_statement', 'while_statement', 'do_statement', 'for_statement', 'enhanced_for_statement',
+  'switch_label', 'catch_clause', 'ternary_expression',
+]);
+
+const JAVA_NESTING_NODES = new Set<string>([
+  'if_statement', 'while_statement', 'do_statement', 'for_statement', 'enhanced_for_statement',
+  'switch_block', 'catch_clause',
+]);
+
+const SPRING_REQUEST_ANNOTATIONS: Record<string, string> = {
+  GetMapping: 'GET',
+  PostMapping: 'POST',
+  PutMapping: 'PUT',
+  PatchMapping: 'PATCH',
+  DeleteMapping: 'DELETE',
+};
+
+// Java HTTP CLIENT method names → HTTP verb. RestTemplate exposes a separate
+// method per verb; java.net.http builds the request via .GET()/.POST(…).
+const JAVA_HTTP_CLIENT_METHODS = new Map<string, string>([
+  ['getForObject', 'GET'], ['getForEntity', 'GET'],
+  ['postForObject', 'POST'], ['postForEntity', 'POST'], ['postForLocation', 'POST'],
+  ['put', 'PUT'], ['delete', 'DELETE'],
+  ['exchange', 'ANY'],
+  ['newBuilder', 'ANY'],  // HttpRequest.newBuilder(URI.create("..."))
+]);
+
+function javaLooksLikeHttpTarget(s: string): boolean {
+  if (!s) return false;
+  if (s.startsWith('/')) return true;
+  if (/^https?:\/\//i.test(s)) return true;
+  return false;
+}
+
+const JAVA_CANDIDATE_NODE_TYPES = [
+  // tryExtractDefinition
+  'method_declaration',
+  'class_declaration',
+  'interface_declaration',
+  'constructor_declaration',
+  'enum_declaration',
+  // tryExtractCallName + tryExtractConfigKey
+  'method_invocation',
+  // tryExtractImport
+  'import_declaration',
+  // tryExtractRoute (Spring annotations on methods)
+  'annotation',
+  'marker_annotation',
+] as const;
+
+export const javaExtractor: LanguageExtractor = {
+  languageName: 'java',
+  extensions: ['.java'],
+  branchNodeTypes: JAVA_BRANCH_NODES,
+  nestingNodeTypes: JAVA_NESTING_NODES,
+  candidateNodeTypes: JAVA_CANDIDATE_NODE_TYPES,
+
+  tryExtractDefinition(node: Parser.SyntaxNode): SymbolDef | null {
+    switch (node.type) {
+      case 'method_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) return null;
+        return {
+          name: nameNode.text,
+          kind: 'method',
+          lineStart: node.startPosition.row,
+          lineEnd:   node.endPosition.row,
+          colStart:  node.startPosition.column,
+          colEnd:    node.endPosition.column,
+          signature: firstLine(node),
+        };
+      }
+
+      case 'class_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) return null;
+        return {
+          name: nameNode.text,
+          kind: 'class',
+          lineStart: node.startPosition.row,
+          lineEnd:   node.endPosition.row,
+          colStart:  node.startPosition.column,
+          colEnd:    node.endPosition.column,
+          signature: firstLine(node),
+        };
+      }
+
+      case 'interface_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) return null;
+        return {
+          name: nameNode.text,
+          kind: 'interface',
+          lineStart: node.startPosition.row,
+          lineEnd:   node.endPosition.row,
+          colStart:  node.startPosition.column,
+          colEnd:    node.endPosition.column,
+          signature: firstLine(node),
+        };
+      }
+
+      case 'constructor_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) return null;
+        return {
+          name: nameNode.text,
+          kind: 'constructor',
+          lineStart: node.startPosition.row,
+          lineEnd:   node.endPosition.row,
+          colStart:  node.startPosition.column,
+          colEnd:    node.endPosition.column,
+          signature: firstLine(node),
+        };
+      }
+
+      case 'enum_declaration': {
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode) return null;
+        return {
+          name: nameNode.text,
+          kind: 'enum',
+          lineStart: node.startPosition.row,
+          lineEnd:   node.endPosition.row,
+          colStart:  node.startPosition.column,
+          colEnd:    node.endPosition.column,
+          signature: firstLine(node),
+        };
+      }
+
+      default:
+        return null;
+    }
+  },
+
+  tryExtractCallName(node: Parser.SyntaxNode): string | null {
+    if (node.type === 'method_invocation') {
+      return node.childForFieldName('name')?.text ?? null;
+    }
+    return null;
+  },
+
+  tryExtractImport(node: Parser.SyntaxNode): string | null {
+    if (node.type === 'import_declaration') {
+      for (const child of node.children) {
+        if (child.type === 'scoped_identifier' || child.type === 'identifier') {
+          return child.text;
+        }
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Spring Boot mapping annotations on methods:
+   *   @GetMapping("/users")
+   *   @PostMapping(value = "/users")
+   *   @RequestMapping(value = "/x", method = RequestMethod.GET)
+   *
+   * Class-level @RequestMapping("/api") is treated as a PREFIX for every
+   * mapping annotation on that class's methods, not as a route on its own.
+   * We never emit a route from a class-level annotation directly — that
+   * was a pre-existing bug that produced bogus entries like `GET /api`.
+   *
+   * The annotation node sits above the method_declaration; we extract on
+   * the annotation and walk up to the method for the handler name, then
+   * walk further up to find the enclosing class to pick up any class-level
+   * @RequestMapping prefix.
+   */
+  tryExtractRoute(node: Parser.SyntaxNode): RouteDef[] | null {
+    if (node.type !== 'annotation' && node.type !== 'marker_annotation') return null;
+    const nameNode = node.childForFieldName('name');
+    if (!nameNode) return null;
+    const annName = nameNode.text;
+    const method = SPRING_REQUEST_ANNOTATIONS[annName];
+
+    // The enclosing declaration (method vs class) decides whether this
+    // annotation is a route or a prefix. modifiers are the syntactic parent
+    // of an annotation in tree-sitter-java; the method/class is one more
+    // level up.
+    let enclosing: Parser.SyntaxNode | null = node.parent;
+    while (enclosing && enclosing.type === 'modifiers') enclosing = enclosing.parent;
+    if (!enclosing) return null;
+    // Class-level annotations: not a route on their own. Their path becomes
+    // a prefix for method-level routes inside the class; the method-level
+    // pass below walks up to find this annotation and prepends its path.
+    if (enclosing.type === 'class_declaration' || enclosing.type === 'interface_declaration') {
+      return null;
+    }
+    // Anything other than a method/constructor: not a route.
+    if (enclosing.type !== 'method_declaration' && enclosing.type !== 'constructor_declaration') {
+      return null;
+    }
+
+    const routePath = readSpringPath(node);
+
+    let detectedMethod = method;
+    const args = node.childForFieldName('arguments');
+    if (annName === 'RequestMapping' && args) {
+      for (const child of args.namedChildren) {
+        if (child.type === 'element_value_pair') {
+          const kn = child.childForFieldName('key');
+          const vn = child.childForFieldName('value');
+          if (kn?.text === 'method' && vn) {
+            const txt = vn.text.replace(/.*RequestMethod\./, '').replace(/[,}\s]/g, '');
+            if (txt) detectedMethod = txt;
+          }
+        }
+      }
+      if (!detectedMethod) detectedMethod = 'GET';
+    }
+
+    if (!detectedMethod) return null;
+
+    // Walk up to the enclosing class to pick up a class-level @RequestMapping
+    // prefix (if any). Concatenate with care so we don't end up with double
+    // slashes or missing slashes.
+    const prefix = findSpringClassPrefix(enclosing);
+    const fullPath = joinSpringPaths(prefix, routePath);
+    if (!fullPath) return null;
+
+    const handlerName = enclosing.childForFieldName('name')?.text;
+
+    return [{
+      method: detectedMethod,
+      path: fullPath,
+      framework: 'spring',
+      handlerName,
+      line: node.startPosition.row,
+    }];
+  },
+
+  /**
+   * Java HTTP client calls — minimal initial coverage:
+   *   HttpRequest.newBuilder(URI.create("https://x/y"))
+   *     .GET().build()                                  ← yes (path lifted; method=GET)
+   *   restTemplate.getForObject("/api/x", String.class) ← yes (Spring RestTemplate)
+   *   webClient.get().uri("/api/x")                     ← future
+   *
+   * The recognizer is conservative: we accept any method_invocation whose
+   * name is in JAVA_HTTP_CLIENT_METHODS and whose first argument is a string
+   * literal that looks like an HTTP target.
+   */
+  tryExtractServiceCalls(node: Parser.SyntaxNode): ServiceCallDef[] | null {
+    if (node.type !== 'method_invocation') return null;
+    const name = node.childForFieldName('name')?.text;
+    if (!name) return null;
+    const verb = JAVA_HTTP_CLIENT_METHODS.get(name);
+    if (!verb) return null;
+
+    const args = node.childForFieldName('arguments');
+    if (!args) return null;
+    const first = args.namedChildren[0];
+    if (!first) return null;
+    let raw: string | null = null;
+    if (first.type === 'string_literal') {
+      raw = stripJavaQuotes(first.text);
+    } else if (first.type === 'method_invocation') {
+      // URI.create("https://x/y") inside HttpRequest.newBuilder(...)
+      const innerName = first.childForFieldName('name')?.text;
+      const innerObj = first.childForFieldName('object')?.text;
+      if (innerObj === 'URI' && innerName === 'create') {
+        const ia = first.childForFieldName('arguments');
+        const first2 = ia?.namedChildren[0];
+        if (first2?.type === 'string_literal') raw = stripJavaQuotes(first2.text);
+      }
+    }
+    if (!raw || !javaLooksLikeHttpTarget(raw)) return null;
+
+    let framework = 'http-client';
+    const obj = node.childForFieldName('object')?.text;
+    if (obj === 'HttpRequest') framework = 'java.net.http';
+    else if (obj && /(restTemplate|RestTemplate)/.test(obj)) framework = 'spring-rest';
+
+    return [{
+      protocol: 'http',
+      method: verb,
+      rawTarget: raw.slice(0, 240),
+      framework,
+      line: node.startPosition.row,
+      confidence: 0.8,
+    }];
+  },
+
+  /**
+   * Java env reads: `System.getenv("NAME")`.
+   */
+  tryExtractConfigKey(node: Parser.SyntaxNode): ConfigKeyRead | null {
+    if (node.type !== 'method_invocation') return null;
+    const obj = node.childForFieldName('object');
+    const name = node.childForFieldName('name');
+    if (!obj || !name) return null;
+    if (obj.text === 'System' && name.text === 'getenv') {
+      const args = node.childForFieldName('arguments');
+      if (!args) return null;
+      for (const child of args.namedChildren) {
+        if (child.type === 'string_literal') {
+          const key = stripJavaQuotes(child.text);
+          if (key) return { key, source: 'env', line: node.startPosition.row };
+          break;
+        }
+      }
+    }
+    return null;
+  },
+};
+
+function stripJavaQuotes(s: string): string {
+  return s.replace(/^"|"$/g, '');
+}
+
+/**
+ * Read the `value=`/`path=` (or first positional string-literal) from a
+ * Spring mapping annotation. Returns '' when no path is given — which is
+ * a perfectly valid mapping (`@GetMapping` with class-level prefix only).
+ */
+function readSpringPath(annNode: Parser.SyntaxNode): string {
+  const args = annNode.childForFieldName('arguments');
+  if (!args) return '';
+  for (const child of args.namedChildren) {
+    if (child.type === 'string_literal') return stripJavaQuotes(child.text);
+    if (child.type === 'element_value_pair') {
+      const kn = child.childForFieldName('key');
+      const vn = child.childForFieldName('value');
+      if ((kn?.text === 'value' || kn?.text === 'path') && vn?.type === 'string_literal') {
+        return stripJavaQuotes(vn.text);
+      }
+    }
+  }
+  return '';
+}
+
+/**
+ * Walk up from a method_declaration to its enclosing class_declaration and
+ * return the path component of a class-level @RequestMapping(...) — or '' if
+ * the class has no such annotation. Bare class-level @RestController without
+ * a @RequestMapping yields ''.
+ */
+function findSpringClassPrefix(methodOrCtor: Parser.SyntaxNode): string {
+  let n: Parser.SyntaxNode | null = methodOrCtor.parent;
+  while (n) {
+    if (n.type === 'class_declaration' || n.type === 'interface_declaration') break;
+    n = n.parent;
+  }
+  if (!n) return '';
+  // Class-level annotations sit in a `modifiers` block as the first child of
+  // the class_declaration in tree-sitter-java.
+  for (const child of n.children) {
+    if (child.type !== 'modifiers') continue;
+    for (const m of child.namedChildren) {
+      if (m.type !== 'annotation' && m.type !== 'marker_annotation') continue;
+      const nm = m.childForFieldName('name');
+      if (nm?.text !== 'RequestMapping') continue;
+      return readSpringPath(m);
+    }
+  }
+  return '';
+}
+
+/**
+ * Join a Spring class-level prefix and method-level path. Empty strings are
+ * dropped; consecutive slashes are collapsed. Returns '' when both inputs
+ * are empty.
+ *   ('/api',  '/users')      → '/api/users'
+ *   ('/api',  '')            → '/api'
+ *   ('',      '/users')      → '/users'
+ *   ('/api/', '/users')      → '/api/users'
+ *   ('',      '')            → ''
+ */
+function joinSpringPaths(prefix: string, route: string): string {
+  if (!prefix && !route) return '';
+  if (!prefix) return route;
+  if (!route)  return prefix;
+  const a = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+  const b = route.startsWith('/') ? route : '/' + route;
+  return a + b;
+}