arceus-s 1.6.4

package/dist/core/group/extractors/thrift-patterns/java.js

@@ -0,0 +1,220 @@
+import Java from 'tree-sitter-java';
+import { compilePatterns, runCompiledPatterns, } from '../tree-sitter-scanner.js';
+const GENERATED_MEMBER_TYPES = new Set(['Iface', 'Client']);
+const SERVICE_TYPE_RE = /^[A-Z][A-Za-z0-9]*(?:Service|Management)$/;
+const VARIABLE_PATTERNS = compilePatterns({
+    name: 'java-thrift-variables',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (field_declaration
+          type: (_) @type
+          declarator: (variable_declarator
+            name: (identifier) @var))
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (local_variable_declaration
+          type: (_) @type
+          declarator: (variable_declarator
+            name: (identifier) @var))
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (formal_parameter
+          type: (_) @type
+          name: (identifier) @var)
+      `,
+        },
+    ],
+});
+const CALL_PATTERNS = compilePatterns({
+    name: 'java-thrift-method-calls',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (identifier) @receiver
+          name: (identifier) @method)
+      `,
+        },
+        {
+            meta: {},
+            query: `
+        (method_invocation
+          object: (field_access
+            object: (this)
+            field: (identifier) @receiver)
+          name: (identifier) @method)
+      `,
+        },
+    ],
+});
+const PROVIDER_PATTERNS = compilePatterns({
+    name: 'java-thrift-providers',
+    language: Java,
+    patterns: [
+        {
+            meta: {},
+            query: `
+        (class_declaration
+          name: (identifier) @class_name
+          (super_interfaces
+            (type_list
+              (_) @type))
+          body: (class_body) @body) @class
+      `,
+        },
+    ],
+});
+function serviceFromType(typeText) {
+    const segments = typeText.split('.').filter((segment) => segment.length > 0);
+    const last = segments.at(-1);
+    const service = segments.at(-2);
+    if (last && service && GENERATED_MEMBER_TYPES.has(last)) {
+        return { serviceName: service, usesGeneratedServiceMember: true };
+    }
+    return last && SERVICE_TYPE_RE.test(last)
+        ? { serviceName: last, usesGeneratedServiceMember: false }
+        : null;
+}
+function methodNamesInClassBody(body) {
+    const names = [];
+    for (let i = 0; i < body.namedChildCount; i++) {
+        const child = body.namedChild(i);
+        if (!child || child.type !== 'method_declaration')
+            continue;
+        const name = child.childForFieldName('name');
+        if (name?.text)
+            names.push(name.text);
+    }
+    return names;
+}
+function nearestAncestor(node, types) {
+    let current = node;
+    while (current) {
+        if (types.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
+function bindingScope(varNode) {
+    const declaration = nearestAncestor(varNode, new Set(['field_declaration', 'local_variable_declaration', 'formal_parameter']));
+    if (!declaration)
+        return null;
+    if (declaration.type === 'field_declaration') {
+        const classBody = nearestAncestor(declaration, new Set(['class_body']));
+        if (!classBody)
+            return null;
+        return { scope: classBody, declarationEnd: 0 };
+    }
+    if (declaration.type === 'formal_parameter') {
+        const callable = nearestAncestor(declaration, new Set(['method_declaration', 'constructor_declaration']));
+        if (!callable)
+            return null;
+        return { scope: callable, declarationEnd: 0 };
+    }
+    const block = nearestAncestor(declaration, new Set(['block']));
+    if (!block)
+        return null;
+    return { scope: block, declarationEnd: declaration.endIndex };
+}
+function resolveServiceForReceiver(bindings, receiver, callNode) {
+    const callStart = callNode.startIndex;
+    const candidates = bindings.filter((binding) => binding.name === receiver &&
+        binding.scopeStart <= callStart &&
+        callStart <= binding.scopeEnd &&
+        binding.declarationEnd <= callStart);
+    candidates.sort((a, b) => {
+        if (a.scopeSize !== b.scopeSize)
+            return a.scopeSize - b.scopeSize;
+        return b.declarationEnd - a.declarationEnd;
+    });
+    return candidates[0] ?? null;
+}
+export const JAVA_THRIFT_PLUGIN = {
+    name: 'java-thrift',
+    language: Java,
+    scan(tree) {
+        const out = [];
+        const bindings = [];
+        for (const match of runCompiledPatterns(VARIABLE_PATTERNS, tree)) {
+            const typeNode = match.captures.type;
+            const varNode = match.captures.var;
+            if (!typeNode || !varNode)
+                continue;
+            const service = serviceFromType(typeNode.text);
+            if (!service)
+                continue;
+            const scope = bindingScope(varNode);
+            if (!scope)
+                continue;
+            bindings.push({
+                name: varNode.text,
+                serviceName: service.serviceName,
+                usesGeneratedServiceMember: service.usesGeneratedServiceMember,
+                scopeStart: scope.scope.startIndex,
+                scopeEnd: scope.scope.endIndex,
+                declarationEnd: scope.declarationEnd,
+                scopeSize: scope.scope.endIndex - scope.scope.startIndex,
+            });
+        }
+        for (const match of runCompiledPatterns(CALL_PATTERNS, tree)) {
+            const receiver = match.captures.receiver?.text;
+            const methodName = match.captures.method?.text;
+            const callNode = match.captures.receiver?.parent;
+            if (!receiver || !methodName)
+                continue;
+            if (!callNode)
+                continue;
+            const binding = resolveServiceForReceiver(bindings, receiver, callNode);
+            if (!binding)
+                continue;
+            out.push({
+                role: 'consumer',
+                serviceName: binding.serviceName,
+                methodName,
+                symbolName: `${receiver}.${methodName}`,
+                source: 'java_thrift_consumer',
+                confidenceWithIdl: 0.75,
+                confidenceWithoutIdl: 0.45,
+                usesGeneratedServiceMember: binding.usesGeneratedServiceMember,
+            });
+        }
+        const emittedProviders = new Set();
+        for (const match of runCompiledPatterns(PROVIDER_PATTERNS, tree)) {
+            const typeNode = match.captures.type;
+            const bodyNode = match.captures.body;
+            if (!typeNode || !bodyNode)
+                continue;
+            const service = serviceFromType(typeNode.text);
+            if (!service)
+                continue;
+            for (const methodName of methodNamesInClassBody(bodyNode)) {
+                const key = `${service.serviceName}.${methodName}`;
+                if (emittedProviders.has(key))
+                    continue;
+                emittedProviders.add(key);
+                out.push({
+                    role: 'provider',
+                    serviceName: service.serviceName,
+                    methodName,
+                    symbolName: `${service.serviceName}.${methodName}`,
+                    source: 'java_thrift_provider',
+                    confidenceWithIdl: 0.8,
+                    confidenceWithoutIdl: 0,
+                });
+            }
+        }
+        return out;
+    },
+};

package/dist/core/group/extractors/thrift-patterns/types.d.ts

@@ -0,0 +1,17 @@
+import type Parser from 'tree-sitter';
+export type ThriftRole = 'provider' | 'consumer';
+export interface ThriftDetection {
+    role: ThriftRole;
+    serviceName: string;
+    methodName: string;
+    symbolName: string;
+    source: string;
+    confidenceWithIdl: number;
+    confidenceWithoutIdl: number;
+    usesGeneratedServiceMember?: boolean;
+}
+export interface ThriftLanguagePlugin {
+    name: string;
+    language: unknown;
+    scan(tree: Parser.Tree): ThriftDetection[];
+}

package/dist/core/group/extractors/thrift-patterns/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/group/extractors/topic-extractor.d.ts

@@ -0,0 +1,8 @@
+import type { ContractExtractor, CypherExecutor } from '../contract-extractor.js';
+import type { ExtractedContract, RepoHandle } from '../types.js';
+export declare class TopicExtractor implements ContractExtractor {
+    type: "topic";
+    canExtract(_repo: RepoHandle): Promise<boolean>;
+    extract(_dbExecutor: CypherExecutor | null, repoPath: string, _repo: RepoHandle): Promise<ExtractedContract[]>;
+    private dedupe;
+}

package/dist/core/group/extractors/topic-extractor.js

@@ -0,0 +1,97 @@
+import { glob } from 'glob';
+import Parser from 'tree-sitter';
+import { createIgnoreFilter } from '../../../config/ignore-service.js';
+import { readSafe } from './fs-utils.js';
+import { scanFile, unquoteLiteral } from './tree-sitter-scanner.js';
+import { TOPIC_SCAN_GLOB, getProviderForFile, } from './topic-patterns/index.js';
+/**
+ * Language-agnostic orchestrator for topic (message broker) contract
+ * extraction. All grammar-specific knowledge lives in `topic-patterns/*`
+ * — this file must not import any tree-sitter grammar directly.
+ *
+ * Flow per file:
+ *   1. `getProviderForFile(rel)` → compiled plugin (or `undefined` if the
+ *      file's extension isn't registered, in which case we skip it).
+ *   2. `scanFile(parser, provider, content)` → list of `{meta, valueText}`
+ *      pairs, one per matched literal.
+ *   3. `unquoteLiteral(valueText)` → the raw topic string.
+ *   4. `makeContract(topic, meta, relPath)` → `ExtractedContract`.
+ *
+ * Adding a new language is a one-file edit in `topic-patterns/index.ts`.
+ */
+function makeContract(topicName, meta, filePath) {
+    return {
+        contractId: `topic::${topicName}`,
+        type: 'topic',
+        role: meta.role,
+        symbolUid: '',
+        symbolRef: { filePath: filePath.replace(/\\/g, '/'), name: meta.symbolName },
+        symbolName: meta.symbolName,
+        confidence: meta.confidence,
+        meta: {
+            broker: meta.broker,
+            topicName,
+            extractionStrategy: 'tree_sitter',
+        },
+    };
+}
+export class TopicExtractor {
+    type = 'topic';
+    async canExtract(_repo) {
+        return true;
+    }
+    async extract(_dbExecutor, repoPath, _repo) {
+        // Honour `.arcignore` / `.gitignore` via the shared IgnoreService —
+        // mirrors `filesystem-walker.ts`. The 5-name hardcoded list
+        // (`node_modules, .git, vendor, dist, build`) is preserved because every
+        // entry is in `DEFAULT_IGNORE_LIST`, so default behaviour is unchanged
+        // (#1185). The Go-specific `**/*_test.go` filter is layered on top via a
+        // small wrapper so glob-level pruning is preserved (we never read those
+        // files); the wrapper short-circuits before calling the base filter.
+        const baseFilter = await createIgnoreFilter(repoPath);
+        const ignoreFilter = {
+            ignored: (p) => p.relative().endsWith('_test.go') || baseFilter.ignored(p),
+            childrenIgnored: (p) => baseFilter.childrenIgnored(p),
+        };
+        const files = await glob(TOPIC_SCAN_GLOB, {
+            cwd: repoPath,
+            ignore: ignoreFilter,
+            nodir: true,
+        });
+        // One parser reused across files; the scanner calls `setLanguage` per
+        // file based on which plugin the registry returns.
+        const parser = new Parser();
+        const out = [];
+        for (const rel of files) {
+            const provider = getProviderForFile(rel);
+            if (!provider)
+                continue;
+            const content = readSafe(repoPath, rel);
+            if (!content)
+                continue;
+            const matches = scanFile(parser, provider, content);
+            for (const match of matches) {
+                const valueNode = match.captures.value;
+                if (!valueNode)
+                    continue;
+                const topicName = unquoteLiteral(valueNode.text);
+                if (!topicName)
+                    continue;
+                out.push(makeContract(topicName, match.meta, rel));
+            }
+        }
+        return this.dedupe(out);
+    }
+    dedupe(items) {
+        const seen = new Set();
+        const out = [];
+        for (const c of items) {
+            const k = `${c.contractId}|${c.role}|${c.symbolRef.filePath}`;
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            out.push(c);
+        }
+        return out;
+    }
+}

package/dist/core/group/extractors/topic-patterns/go.d.ts

@@ -0,0 +1,2 @@
+import type { TopicMeta } from './types.js';
+export declare const GO_TOPIC_PROVIDER: import("../tree-sitter-scanner.js").CompiledPatterns<TopicMeta>;

package/dist/core/group/extractors/topic-patterns/go.js

@@ -0,0 +1,120 @@
+import Go from 'tree-sitter-go';
+import { compilePatterns } from '../tree-sitter-scanner.js';
+/**
+ * Go topic extraction patterns.
+ *
+ * Detects Sarama, segmentio/kafka-go and nats.go producer/consumer APIs:
+ *   - `X.ConsumePartition("topic", ...)`
+ *   - `sarama.ProducerMessage{Topic: "xxx"}`
+ *   - `kafka.Writer{Topic: "xxx"}` / `kafka.WriterConfig{Topic: ...}`
+ *   - `kafka.Reader{Topic: "xxx"}` / `kafka.ReaderConfig{Topic: ...}`
+ *   - `nc.Subscribe("topic", ...)` / `js.Subscribe("topic", ...)`
+ *   - `nc.Publish("topic", ...)` / `js.Publish("topic", ...)`
+ *
+ * Every query MUST bind `@value` to the topic literal node.
+ */
+const GO_TOPIC_SPEC = {
+    name: 'go-topic',
+    language: Go,
+    patterns: [
+        {
+            meta: {
+                role: 'consumer',
+                broker: 'kafka',
+                confidence: 0.7,
+                symbolName: 'ConsumePartition',
+            },
+            query: `
+        (call_expression
+          function: (selector_expression
+            field: (field_identifier) @method (#eq? @method "ConsumePartition"))
+          arguments: (argument_list . (interpreted_string_literal) @value))
+      `,
+        },
+        {
+            meta: {
+                role: 'provider',
+                broker: 'kafka',
+                confidence: 0.75,
+                symbolName: 'sarama.ProducerMessage',
+            },
+            query: `
+        (composite_literal
+          type: (qualified_type
+            package: (package_identifier) @pkg (#eq? @pkg "sarama")
+            name: (type_identifier) @ty (#eq? @ty "ProducerMessage"))
+          body: (literal_value
+            (keyed_element
+              (literal_element (identifier) @field (#eq? @field "Topic"))
+              (literal_element (interpreted_string_literal) @value))))
+      `,
+        },
+        {
+            meta: {
+                role: 'provider',
+                broker: 'kafka',
+                confidence: 0.75,
+                symbolName: 'kafka.Writer',
+            },
+            query: `
+        (composite_literal
+          type: (qualified_type
+            package: (package_identifier) @pkg (#eq? @pkg "kafka")
+            name: (type_identifier) @ty (#match? @ty "^(Writer|WriterConfig)$"))
+          body: (literal_value
+            (keyed_element
+              (literal_element (identifier) @field (#eq? @field "Topic"))
+              (literal_element (interpreted_string_literal) @value))))
+      `,
+        },
+        {
+            meta: {
+                role: 'consumer',
+                broker: 'kafka',
+                confidence: 0.75,
+                symbolName: 'kafka.Reader',
+            },
+            query: `
+        (composite_literal
+          type: (qualified_type
+            package: (package_identifier) @pkg (#eq? @pkg "kafka")
+            name: (type_identifier) @ty (#match? @ty "^(Reader|ReaderConfig)$"))
+          body: (literal_value
+            (keyed_element
+              (literal_element (identifier) @field (#eq? @field "Topic"))
+              (literal_element (interpreted_string_literal) @value))))
+      `,
+        },
+        {
+            meta: {
+                role: 'consumer',
+                broker: 'nats',
+                confidence: 0.8,
+                symbolName: 'nc.Subscribe',
+            },
+            query: `
+        (call_expression
+          function: (selector_expression
+            operand: (identifier) @obj (#match? @obj "^(nc|js)$")
+            field: (field_identifier) @method (#match? @method "^[Ss]ubscribe$"))
+          arguments: (argument_list . (interpreted_string_literal) @value))
+      `,
+        },
+        {
+            meta: {
+                role: 'provider',
+                broker: 'nats',
+                confidence: 0.8,
+                symbolName: 'nc.Publish',
+            },
+            query: `
+        (call_expression
+          function: (selector_expression
+            operand: (identifier) @obj (#match? @obj "^(nc|js)$")
+            field: (field_identifier) @method (#match? @method "^[Pp]ublish$"))
+          arguments: (argument_list . (interpreted_string_literal) @value))
+      `,
+        },
+    ],
+};
+export const GO_TOPIC_PROVIDER = compilePatterns(GO_TOPIC_SPEC);

package/dist/core/group/extractors/topic-patterns/index.d.ts

@@ -0,0 +1,14 @@
+import type { CompiledPatterns } from '../tree-sitter-scanner.js';
+import type { TopicMeta } from './types.js';
+export type { TopicMeta, Broker } from './types.js';
+/**
+ * Glob pattern for files worth scanning. Kept here so adding a new
+ * language to the registry also widens the glob automatically via a
+ * single edit.
+ */
+export declare const TOPIC_SCAN_GLOB = "**/*.{ts,tsx,js,jsx,java,go,py}";
+/**
+ * Return the compiled provider registered for the given file's
+ * extension, or `undefined` if the extension is not registered.
+ */
+export declare function getProviderForFile(rel: string): CompiledPatterns<TopicMeta> | undefined;

package/dist/core/group/extractors/topic-patterns/index.js

@@ -0,0 +1,38 @@
+import * as path from 'node:path';
+import { JAVA_TOPIC_PROVIDER } from './java.js';
+import { GO_TOPIC_PROVIDER } from './go.js';
+import { PYTHON_TOPIC_PROVIDER } from './python.js';
+import { JAVASCRIPT_TOPIC_PROVIDER, TYPESCRIPT_TOPIC_PROVIDER, TSX_TOPIC_PROVIDER, } from './node.js';
+/**
+ * File-extension → compiled-plugin registry for topic extraction. The
+ * top-level orchestrator (`topic-extractor.ts`) looks up the plugin for
+ * each file it visits and delegates the scanning to `tree-sitter-scanner`.
+ *
+ * Keys are lowercase extensions including the leading dot. To add a new
+ * language, drop a `topic-patterns/<lang>.ts` that exports a compiled
+ * provider, import it here and register the extension(s). No edits to
+ * `topic-extractor.ts` are required.
+ */
+const REGISTRY = {
+    '.java': JAVA_TOPIC_PROVIDER,
+    '.go': GO_TOPIC_PROVIDER,
+    '.py': PYTHON_TOPIC_PROVIDER,
+    '.js': JAVASCRIPT_TOPIC_PROVIDER,
+    '.jsx': JAVASCRIPT_TOPIC_PROVIDER,
+    '.ts': TYPESCRIPT_TOPIC_PROVIDER,
+    '.tsx': TSX_TOPIC_PROVIDER,
+};
+/**
+ * Glob pattern for files worth scanning. Kept here so adding a new
+ * language to the registry also widens the glob automatically via a
+ * single edit.
+ */
+export const TOPIC_SCAN_GLOB = '**/*.{ts,tsx,js,jsx,java,go,py}';
+/**
+ * Return the compiled provider registered for the given file's
+ * extension, or `undefined` if the extension is not registered.
+ */
+export function getProviderForFile(rel) {
+    const ext = path.extname(rel).toLowerCase();
+    return REGISTRY[ext];
+}

package/dist/core/group/extractors/topic-patterns/java.d.ts

@@ -0,0 +1,2 @@
+import type { TopicMeta } from './types.js';
+export declare const JAVA_TOPIC_PROVIDER: import("../tree-sitter-scanner.js").CompiledPatterns<TopicMeta>;

package/dist/core/group/extractors/topic-patterns/java.js

@@ -0,0 +1,80 @@
+import Java from 'tree-sitter-java';
+import { compilePatterns } from '../tree-sitter-scanner.js';
+/**
+ * Java topic extraction patterns.
+ *
+ * Detects Kafka and RabbitMQ (Spring conventions) producer/consumer APIs:
+ *   - `@KafkaListener(topics = "xxx")`
+ *   - `@RabbitListener(queues = "xxx")`
+ *   - `kafkaTemplate.send("xxx", ...)`
+ *   - `rabbitTemplate.convertAndSend("xxx", ...)`
+ *
+ * Every query MUST bind `@value` to the topic literal node.
+ */
+const JAVA_TOPIC_SPEC = {
+    name: 'java-topic',
+    language: Java,
+    patterns: [
+        {
+            meta: {
+                role: 'consumer',
+                broker: 'kafka',
+                confidence: 0.8,
+                symbolName: 'kafkaListener',
+            },
+            query: `
+        (annotation
+          name: (identifier) @name (#eq? @name "KafkaListener")
+          arguments: (annotation_argument_list
+            (element_value_pair
+              key: (identifier) @key (#eq? @key "topics")
+              value: (string_literal) @value)))
+      `,
+        },
+        {
+            meta: {
+                role: 'consumer',
+                broker: 'rabbitmq',
+                confidence: 0.8,
+                symbolName: 'rabbitListener',
+            },
+            query: `
+        (annotation
+          name: (identifier) @name (#eq? @name "RabbitListener")
+          arguments: (annotation_argument_list
+            (element_value_pair
+              key: (identifier) @key (#eq? @key "queues")
+              value: (string_literal) @value)))
+      `,
+        },
+        {
+            meta: {
+                role: 'provider',
+                broker: 'kafka',
+                confidence: 0.8,
+                symbolName: 'kafkaTemplate.send',
+            },
+            query: `
+        (method_invocation
+          object: (identifier) @obj (#eq? @obj "kafkaTemplate")
+          name: (identifier) @method (#eq? @method "send")
+          arguments: (argument_list . (string_literal) @value))
+      `,
+        },
+        {
+            meta: {
+                role: 'provider',
+                broker: 'rabbitmq',
+                confidence: 0.8,
+                symbolName: 'rabbitTemplate.convertAndSend',
+            },
+            query: `
+        (method_invocation
+          object: (identifier) @obj (#eq? @obj "rabbitTemplate")
+          name: (identifier) @method (#eq? @method "convertAndSend")
+          arguments: (argument_list . (string_literal) @value))
+      `,
+        },
+    ],
+};
+export const JAVA_TOPIC_PROVIDER = compilePatterns(JAVA_TOPIC_SPEC);

package/dist/core/group/extractors/topic-patterns/node.d.ts

@@ -0,0 +1,4 @@
+import type { TopicMeta } from './types.js';
+export declare const JAVASCRIPT_TOPIC_PROVIDER: import("../tree-sitter-scanner.js").CompiledPatterns<TopicMeta>;
+export declare const TYPESCRIPT_TOPIC_PROVIDER: import("../tree-sitter-scanner.js").CompiledPatterns<TopicMeta>;
+export declare const TSX_TOPIC_PROVIDER: import("../tree-sitter-scanner.js").CompiledPatterns<TopicMeta>;