seer-mcp 0.1.0

package/tests/fixtures/sample.py

@@ -0,0 +1,46 @@
+"""Sample Python fixture for Seer smoke tests."""
+
+
+class PaymentService:
+    """Handles payment processing."""
+
+    def __init__(self, gateway):
+        self.gateway = gateway
+
+    def process_payment(self, amount: float, currency: str) -> bool:
+        if not validate_amount(amount):
+            return False
+        charge = self.charge_card(amount, currency)
+        return charge is not None
+
+    def charge_card(self, amount: float, currency: str):
+        return self.gateway.charge(amount, currency)
+
+    def refund(self, transaction_id: str) -> bool:
+        return self.gateway.refund(transaction_id)
+
+
+class OrderService:
+    """Manages order lifecycle."""
+
+    def __init__(self, payment_service: PaymentService):
+        self.payment = payment_service
+
+    def place_order(self, cart, user):
+        total = calculate_total(cart)
+        ok = self.payment.process_payment(total, "USD")
+        if ok:
+            notify_user(user, "Order placed!")
+        return ok
+
+
+def validate_amount(amount: float) -> bool:
+    return isinstance(amount, (int, float)) and amount > 0
+
+
+def calculate_total(cart) -> float:
+    return sum(item.price * item.quantity for item in cart.items)
+
+
+def notify_user(user, message: str) -> None:
+    print(f"Notify {user.email}: {message}")

package/tests/fixtures/sample.rs

@@ -0,0 +1,78 @@
+// Sample Rust fixture for Seer smoke tests
+use std::collections::HashMap;
+
+pub trait Repository<T> {
+    fn find_by_id(&self, id: &str) -> Option<T>;
+    fn save(&mut self, item: T) -> Result<(), String>;
+}
+
+pub struct InMemoryUserStore {
+    data: HashMap<String, User>,
+}
+
+impl InMemoryUserStore {
+    pub fn new() -> Self {
+        InMemoryUserStore {
+            data: HashMap::new(),
+        }
+    }
+}
+
+impl Repository<User> for InMemoryUserStore {
+    fn find_by_id(&self, id: &str) -> Option<User> {
+        self.data.get(id).cloned()
+    }
+
+    fn save(&mut self, user: User) -> Result<(), String> {
+        self.data.insert(user.id.clone(), user);
+        Ok(())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct User {
+    pub id: String,
+    pub email: String,
+    pub name: String,
+}
+
+pub struct AuthService {
+    users: InMemoryUserStore,
+    sessions: HashMap<String, String>,
+}
+
+impl AuthService {
+    pub fn new(users: InMemoryUserStore) -> Self {
+        AuthService {
+            users,
+            sessions: HashMap::new(),
+        }
+    }
+
+    pub fn login(&mut self, email: &str, password: &str) -> Option<String> {
+        let user = find_user_by_email(&self.users, email)?;
+        if verify_password(password, &user.id) {
+            let token = generate_token(&user.id);
+            self.sessions.insert(token.clone(), user.id.clone());
+            Some(token)
+        } else {
+            None
+        }
+    }
+
+    pub fn logout(&mut self, token: &str) {
+        self.sessions.remove(token);
+    }
+}
+
+fn find_user_by_email(store: &InMemoryUserStore, email: &str) -> Option<User> {
+    store.data.values().find(|u| u.email == email).cloned()
+}
+
+fn verify_password(password: &str, _user_id: &str) -> bool {
+    !password.is_empty()
+}
+
+fn generate_token(user_id: &str) -> String {
+    format!("tok-{}-{}", user_id, 42)
+}

package/tests/fixtures/sample.ts

@@ -0,0 +1,76 @@
+// Sample TypeScript fixture for Seer smoke tests
+
+interface User {
+  id: string;
+  email: string;
+  name: string;
+}
+
+interface Cart {
+  items: Array<{ productId: string; quantity: number; price: number }>;
+}
+
+class AuthService {
+  private tokenStore: Map<string, string>;
+
+  constructor() {
+    this.tokenStore = new Map();
+  }
+
+  authenticate(email: string, password: string): string | null {
+    const hash = hashPassword(password);
+    const userId = lookupUser(email, hash);
+    if (!userId) return null;
+    const token = generateToken(userId);
+    this.tokenStore.set(token, userId);
+    return token;
+  }
+
+  validateToken(token: string): string | null {
+    return this.tokenStore.get(token) ?? null;
+  }
+
+  logout(token: string): void {
+    this.tokenStore.delete(token);
+  }
+}
+
+class CartService {
+  addItem(cart: Cart, productId: string, qty: number): Cart {
+    const price = fetchPrice(productId);
+    const existing = cart.items.find(i => i.productId === productId);
+    if (existing) {
+      existing.quantity += qty;
+    } else {
+      cart.items.push({ productId, quantity: qty, price });
+    }
+    return cart;
+  }
+
+  totalPrice(cart: Cart): number {
+    return cart.items.reduce((sum, i) => sum + i.price * i.quantity, 0);
+  }
+}
+
+function hashPassword(password: string): string {
+  return Buffer.from(password).toString('base64');
+}
+
+function lookupUser(email: string, hash: string): string | null {
+  // stub — would query DB
+  return `user-${email}`;
+}
+
+function generateToken(userId: string): string {
+  return `tok-${userId}-${Date.now()}`;
+}
+
+function fetchPrice(productId: string): number {
+  return 9.99; // stub
+}
+
+// Exercises `new X()` extraction — must be tracked as a call edge from
+// createAuthService → AuthService (constructor).
+function createAuthService(): AuthService {
+  return new AuthService();
+}

package/tests/fixtures-service/HttpClients.cs

@@ -0,0 +1,30 @@
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace Svc
+{
+    public class HttpClients
+    {
+        private readonly HttpClient _http;
+
+        public HttpClients(HttpClient http) { _http = http; }
+
+        // GetAsync — GET /api/users via HttpClient.
+        public Task<HttpResponseMessage> ListUsersAsync()
+        {
+            return _http.GetAsync("/api/users");
+        }
+
+        // PostAsJsonAsync — POST /api/orders via HttpClient.
+        public Task<HttpResponseMessage> CreateOrderAsync(object body)
+        {
+            return _http.PostAsJsonAsync("/api/orders", body);
+        }
+
+        // DeleteAsync with absolute URL.
+        public Task<HttpResponseMessage> DeleteSessionAsync()
+        {
+            return _http.DeleteAsync("https://auth/api/session");
+        }
+    }
+}

package/tests/fixtures-service/HttpClients.java

@@ -0,0 +1,24 @@
+package svc;
+
+import java.net.URI;
+import java.net.http.HttpRequest;
+import org.springframework.web.client.RestTemplate;
+
+public class HttpClients {
+    private final RestTemplate restTemplate = new RestTemplate();
+
+    // RestTemplate getForObject — should record GET /api/users via spring-rest.
+    public String listUsers() {
+        return restTemplate.getForObject("/api/users", String.class);
+    }
+
+    // postForObject — POST /api/orders via spring-rest.
+    public String createOrder(Object body) {
+        return restTemplate.postForObject("/api/orders", body, String.class);
+    }
+
+    // java.net.http HttpRequest.newBuilder(URI.create("..."))
+    public HttpRequest buildPing() {
+        return HttpRequest.newBuilder(URI.create("https://payment-service/api/ping")).build();
+    }
+}

package/tests/fixtures-service/billing.ts

@@ -0,0 +1,15 @@
+// Track G — handler side of the rendezvous. Registers /api/charge.
+
+declare const app: any;
+
+export function chargeHandler(req: any, res: any): unknown {
+  return res.send({ charged: true });
+}
+
+app.post('/api/charge', chargeHandler);
+
+// And a parameterised route for /users/:id
+export function getUser(req: any, res: any): unknown {
+  return res.send({ id: req.params.id });
+}
+app.get('/users/:id', getUser);

package/tests/fixtures-service/docker-compose.yml

@@ -0,0 +1,15 @@
+version: '3.8'
+
+services:
+  notifier:
+    image: notifier:latest
+    ports:
+      - 8080:8080
+  legacy-api:
+    image: legacy:latest
+    ports:
+      - 9000:9000
+  payment-service:
+    image: payment:latest
+    ports:
+      - 7000:7000

package/tests/fixtures-service/gateway.ts

@@ -0,0 +1,10 @@
+// Track G — caller side of the rendezvous. Calls /api/charge via fetch.
+
+declare const fetch: any;
+
+export async function processPayment(amount: number): Promise<unknown> {
+  return await fetch('/api/charge', {
+    method: 'POST',
+    body: JSON.stringify({ amount }),
+  });
+}

package/tests/fixtures-service/get_user.ts

@@ -0,0 +1,11 @@
+// Track G — caller side that needs route_pattern match (/users/123 → /users/:id).
+
+declare const fetch: any;
+
+export async function loadUser(id: number): Promise<unknown> {
+  return await fetch('/users/' + 123);  // not really dynamic; literal-ish
+}
+
+export async function loadUserLiteral(): Promise<unknown> {
+  return await fetch('/users/123');
+}

package/tests/fixtures-service/graphql_client.ts

@@ -0,0 +1,63 @@
+// Fixture: GraphQL client calls — Apollo client + React hooks + gql tagged
+// template literals.
+
+declare const client: any;
+declare const apolloClient: any;
+declare function gql(strings: TemplateStringsArray): any;
+declare function useQuery(doc: any, opts?: any): unknown;
+declare function useMutation(doc: any, opts?: any): unknown;
+
+// Inline gql tag — operation field = "user", op name = "GetUser".
+const GET_USER = gql`
+  query GetUser($id: ID!) {
+    user(id: $id) {
+      id
+      name
+    }
+  }
+`;
+
+const CREATE_USER = gql`
+  mutation CreateUser($name: String!) {
+    createUser(name: $name) {
+      id
+    }
+  }
+`;
+
+const ON_USER_CREATED = gql`
+  subscription OnUserCreated {
+    onUserCreated {
+      id
+    }
+  }
+`;
+
+export async function fetchUser(id: string): Promise<unknown> {
+  // operation lifted from GET_USER document — should resolve to field "user"
+  return client.query({ query: GET_USER, variables: { id } });
+}
+
+export async function createUserViaApollo(name: string): Promise<unknown> {
+  return apolloClient.mutate({ mutation: CREATE_USER, variables: { name } });
+}
+
+export function useUserHook(id: string): unknown {
+  // useQuery hook with inline gql tag — operation = field "users"
+  return useQuery(gql`
+    query ListAllUsers {
+      users {
+        id
+        name
+      }
+    }
+  `);
+}
+
+export function useCreateUserHook(): unknown {
+  return useMutation(CREATE_USER);
+}
+
+export function useOnUserCreated(): unknown {
+  return useQuery(ON_USER_CREATED);
+}

package/tests/fixtures-service/graphql_server.ts

@@ -0,0 +1,30 @@
+// Fixture: Apollo-style resolver map. Each resolver field becomes a route
+// with operation = field name.
+
+import { db } from './_helpers';
+
+export function userResolver(_: unknown, args: { id: string }): unknown {
+  return db.users.find(args.id);
+}
+
+export function createUserResolver(_: unknown, args: { name: string }): unknown {
+  return db.users.create(args.name);
+}
+
+export function onUserCreatedResolver(): AsyncIterableIterator<unknown> {
+  return db.users.subscribe();
+}
+
+export const resolvers = {
+  Query: {
+    user: userResolver,
+    users: () => db.users.list(),
+  },
+  Mutation: {
+    createUser: createUserResolver,
+    deleteUser: (_: unknown, args: { id: string }) => db.users.remove(args.id),
+  },
+  Subscription: {
+    onUserCreated: onUserCreatedResolver,
+  },
+};

package/tests/fixtures-service/grpc_client.go

@@ -0,0 +1,30 @@
+// Fixture: Go gRPC client stub calls.
+package fixtures
+
+import (
+	"context"
+	pb "example.com/proto"
+)
+
+// GetUserViaGrpc creates a UserServiceClient and calls GetUser.
+// Operation = "UserService/GetUser".
+func GetUserViaGrpc(ctx context.Context, conn pb.Conn, id string) (*pb.GetUserResponse, error) {
+	return pb.NewUserServiceClient(conn).GetUser(ctx, &pb.GetUserRequest{Id: id})
+}
+
+// CreateUserViaGrpc — Operation = "UserService/CreateUser".
+func CreateUserViaGrpc(ctx context.Context, conn pb.Conn, name string) (*pb.CreateUserResponse, error) {
+	return pb.NewUserServiceClient(conn).CreateUser(ctx, &pb.CreateUserRequest{Name: name})
+}
+
+// LoginViaGrpc — operation = "AuthService/Login".
+func LoginViaGrpc(ctx context.Context, conn pb.Conn, u, p string) (*pb.LoginResponse, error) {
+	return pb.NewAuthServiceClient(conn).Login(ctx, &pb.LoginRequest{Username: u, Password: p})
+}
+
+// CallUnknown — an unresolved gRPC method (NoSuchMethod doesn't exist in our
+// .proto). The call should be recorded as a service_call but NOT produce a
+// service_link.
+func CallUnknown(ctx context.Context, conn pb.Conn) (interface{}, error) {
+	return pb.NewUserServiceClient(conn).NoSuchMethod(ctx, &pb.GetUserRequest{})
+}

package/tests/fixtures-service/http_clients.go

@@ -0,0 +1,23 @@
+package svc
+
+import "net/http"
+
+// http.Get — should record GET /api/users via framework=http.
+func ListUsers() (*http.Response, error) {
+	return http.Get("/api/users")
+}
+
+// http.Post — POST /api/users via framework=http.
+func CreateUser(body interface{}) (*http.Response, error) {
+	return http.Post("/api/users", "application/json", nil)
+}
+
+// client.Get — generic http-client framework.
+func FetchOrders(client *http.Client) (*http.Response, error) {
+	return client.Get("/api/orders")
+}
+
+// http.NewRequest("POST", ...) — method derived from first string arg.
+func MakeRequest() (*http.Request, error) {
+	return http.NewRequest("POST", "/api/items", nil)
+}

package/tests/fixtures-service/http_clients.py

@@ -0,0 +1,38 @@
+# Track G fixtures — HTTP client call sites in Python.
+import os
+import requests
+import httpx
+
+
+def list_users():
+    """requests.get('/health') — must yield framework=requests, method=GET."""
+    return requests.get("/health")
+
+
+def create_user(payload):
+    """requests.post('/api/users') — POST method."""
+    return requests.post("/api/users", json=payload)
+
+
+def fetch_orders():
+    """httpx.get('/api/orders') — framework=httpx, method=GET."""
+    return httpx.get("/api/orders")
+
+
+class CartService:
+    def __init__(self, client):
+        self.client = client
+
+    def add_item(self, item):
+        """client.post('/api/cart/items', json=item) — generic http-client."""
+        return self.client.post("/api/cart/items", json=item)
+
+
+def charge_customer(amount):
+    """os.environ['PAYMENT_URL'] + '/charge' — recover envKey=PAYMENT_URL + /charge."""
+    return requests.post(os.environ["PAYMENT_URL"] + "/charge", json={"amount": amount})
+
+
+def dynamic_url(url):
+    """No literal path — must NOT be recorded."""
+    return requests.get(url)

package/tests/fixtures-service/http_clients.ts

@@ -0,0 +1,49 @@
+// Track G fixtures — HTTP client call sites in TypeScript/JavaScript.
+//
+// This file is consumed by tests/trackg.ts (Step 3 onward) to verify that
+// the TypeScript extractor records ServiceCallDef rows for fetch/axios/etc.
+
+declare const fetch: any;
+declare const axios: any;
+declare const apiClient: any;
+declare const process: any;
+
+// Simple fetch — should yield { protocol: 'http', framework: 'fetch',
+// method: 'ANY', rawTarget: '/api/users', normalizedPath: '/api/users' }.
+export async function listUsers(): Promise<unknown> {
+  return await fetch('/api/users');
+}
+
+// fetch with explicit method via options object — method = POST.
+export async function createUser(body: unknown): Promise<unknown> {
+  return await fetch('/api/users', { method: 'POST', body: JSON.stringify(body) });
+}
+
+// axios.<verb> shorthand — method derived from the verb. Caller attribution
+// must be `checkout`, not module scope.
+export async function checkout(): Promise<unknown> {
+  return await axios.post('/checkout', { ok: true });
+}
+
+// Generic client.<method>(literalUrl) — should yield framework 'http-client'.
+export function fetchOrders(): unknown {
+  return apiClient.get('/api/orders');
+}
+
+// Template literal with env var — recovers /charge AND envKey PAYMENT_URL.
+export async function chargeCustomer(amount: number): Promise<unknown> {
+  return await fetch(`${process.env.PAYMENT_URL}/charge`, {
+    method: 'POST',
+    body: JSON.stringify({ amount }),
+  });
+}
+
+// Dynamic URL with no literal path — should NOT be recorded.
+export async function dynamicUrl(u: string): Promise<unknown> {
+  return await fetch(u);
+}
+
+// Non-HTTP `.get` (e.g. cache lookup) — first arg is not a string, so dropped.
+export function readCache(key: string): unknown {
+  return apiClient.get(key);
+}

package/tests/fixtures-service/k8s/payment-service.yaml

@@ -0,0 +1,22 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: payment-service
+  namespace: payments
+spec:
+  selector:
+    app: payment
+  ports:
+    - port: 80
+      targetPort: 8080
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: billing-service
+spec:
+  selector:
+    app: billing
+  ports:
+    - port: 80
+      targetPort: 9090

package/tests/fixtures-service/k8s_calls.ts

@@ -0,0 +1,20 @@
+// Fixture: HTTP calls that target k8s/Docker-declared service hostnames.
+// The resolver should classify these as match_kind='service_host' when both
+// the host AND the path match a route in the workspace.
+
+export async function paymentCall(): Promise<unknown> {
+  // payment-service is declared in k8s/payment-service.yaml AND in
+  // docker-compose.yml. /api/charge is registered in billing.ts.
+  return fetch('http://payment-service/api/charge', { method: 'POST' });
+}
+
+export async function unknownHostCall(): Promise<unknown> {
+  // No matching k8s/Docker host; falls back to a literal_path link.
+  return fetch('http://random-unknown-host/api/charge', { method: 'POST' });
+}
+
+export async function hostOnlyCall(): Promise<unknown> {
+  // Host is known but path doesn't exist in any workspace route → must NOT
+  // link via service_host alone (host alone is not enough evidence).
+  return fetch('http://notifier/no-such-path', { method: 'GET' });
+}

package/tests/fixtures-service/messaging.ts

@@ -0,0 +1,87 @@
+// Fixture: Messaging producers and consumers across Kafka / SQS / SNS /
+// RabbitMQ / NATS / Redis pub-sub. The resolver should rendezvous each
+// producer with its matching consumer by topic / queue.
+
+declare const producer: any;
+declare const consumer: any;
+declare const sqs: any;
+declare const sns: any;
+declare const channel: any;
+declare const nc: any;
+declare const redis: any;
+
+// ── Kafka ────────────────────────────────────────────────────────────────────
+export async function produceOrders(): Promise<void> {
+  await producer.send({ topic: 'orders', messages: [{ value: 'x' }] });
+}
+
+export async function produceShipments(): Promise<void> {
+  await producer.send({ topic: 'shipments', messages: [{ value: 'y' }] });
+}
+
+export function handleOrder(message: unknown): void { void message; }
+
+export async function subscribeOrders(): Promise<void> {
+  // Single-topic subscribe.
+  await consumer.subscribe({ topic: 'orders' });
+  consumer.run({ eachMessage: handleOrder });
+}
+
+export async function subscribeMulti(): Promise<void> {
+  await consumer.subscribe({ topics: ['shipments', 'invoices'] });
+}
+
+// ── SQS ──────────────────────────────────────────────────────────────────────
+export async function enqueueJob(): Promise<void> {
+  await sqs.sendMessage({
+    QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789012/job-queue',
+    MessageBody: '{}',
+  });
+}
+
+export async function consumeJob(): Promise<void> {
+  await sqs.receiveMessage({
+    QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789012/job-queue',
+  });
+}
+
+// ── SNS ──────────────────────────────────────────────────────────────────────
+export async function notifySubscribers(): Promise<void> {
+  await sns.publish({
+    TopicArn: 'arn:aws:sns:us-east-1:123456789012:user-events',
+    Message: 'created',
+  });
+}
+
+// ── RabbitMQ ─────────────────────────────────────────────────────────────────
+export function publishEvent(): void {
+  channel.publish('events', 'user.created', Buffer.from('{}'));
+}
+
+export function pushToQ(): void {
+  channel.sendToQueue('mailer-queue', Buffer.from('{}'));
+}
+
+export function rabbitHandler(message: unknown): void { void message; }
+
+export function subscribeMailer(): void {
+  channel.consume('mailer-queue', rabbitHandler);
+}
+
+// ── NATS ─────────────────────────────────────────────────────────────────────
+export async function natsPublish(): Promise<void> {
+  await nc.publish('user.created', Buffer.from('{}'));
+}
+
+export async function natsSubscribe(): Promise<void> {
+  await nc.subscribe('user.created');
+}
+
+// ── Redis pub-sub ────────────────────────────────────────────────────────────
+export function redisPub(): void {
+  redis.publish('chan:notifications', 'hello');
+}
+
+export function redisSub(): void {
+  redis.subscribe('chan:notifications');
+}