@blamechris/repo-memory 0.9.0 → 0.11.0

package/dist/indexer/ast-summarizer.js

@@ -14,6 +14,12 @@ const EXT_TO_GRAMMAR = {
     '.jsx': 'javascript',
     '.mjs': 'javascript',
     '.cjs': 'javascript',
+    '.py': 'python',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.kt': 'kotlin',
+    '.kts': 'kotlin',
+    '.java': 'java',
 };
 const MAX_PURPOSE_LENGTH = 160;
 const require = createRequire(import.meta.url);
@@ -68,6 +74,29 @@ async function getParser(grammar) {
 function stripQuotes(text) {
     return text.replace(/^['"`]|['"`]$/g, '');
 }
+function emptyResult() {
+    return {
+        exports: [],
+        imports: [],
+        topLevelDeclarations: [],
+        classes: [],
+        functions: [],
+        typeNames: [],
+        constNames: [],
+        fileDoc: null,
+    };
+}
+function dedupeResult(out) {
+    out.exports = [...new Set(out.exports)];
+    out.imports = [...new Set(out.imports)];
+    out.topLevelDeclarations = [...new Set(out.topLevelDeclarations)];
+    return out;
+}
+/** Keep only the first sentence so multi-sentence doc lines stay short. */
+function firstSentence(line) {
+    const sentenceEnd = line.indexOf('. ');
+    return sentenceEnd === -1 ? line : line.slice(0, sentenceEnd + 1);
+}
 /** First meaningful line of a comment, with `/**`, `*` and `//` markers removed. */
 function commentFirstLine(text) {
     const cleaned = text
@@ -76,9 +105,7 @@ function commentFirstLine(text) {
     for (const rawLine of cleaned.split('\n')) {
         const line = rawLine.replace(/^\s*(?:\*|\/\/)?\s*/, '').trim();
         if (line.length > 0 && !line.startsWith('@') && !line.startsWith('eslint')) {
-            // Keep only the first sentence so multi-sentence doc lines stay short.
-            const sentenceEnd = line.indexOf('. ');
-            return sentenceEnd === -1 ? line : line.slice(0, sentenceEnd + 1);
+            return firstSentence(line);
         }
     }
     return null;
@@ -148,7 +175,7 @@ function collectDeclaration(node, exported, doc, out) {
             const name = node.childForFieldName('name')?.text;
             if (name) {
                 out.topLevelDeclarations.push(`class ${name}`);
-                out.classes.push({ name, methodCount: countMethods(node), doc, exported });
+                out.classes.push({ name, kind: 'class', methodCount: countMethods(node), doc, exported });
                 if (exported)
                     out.exports.push(name);
             }
@@ -238,17 +265,8 @@ function collectExportStatement(node, out) {
         }
     }
 }
-function extract(root) {
-    const out = {
-        exports: [],
-        imports: [],
-        topLevelDeclarations: [],
-        classes: [],
-        functions: [],
-        typeNames: [],
-        constNames: [],
-        fileDoc: null,
-    };
+function extractTsJs(root) {
+    const out = emptyResult();
     let seenCode = false;
     for (const child of root.namedChildren) {
         if (!child)
@@ -276,16 +294,869 @@ function extract(root) {
                 break;
         }
     }
-    out.exports = [...new Set(out.exports)];
-    out.imports = [...new Set(out.imports)];
-    out.topLevelDeclarations = [...new Set(out.topLevelDeclarations)];
-    return out;
+    return dedupeResult(out);
+}
+// ---------------------------------------------------------------------------
+// Python extraction
+// ---------------------------------------------------------------------------
+/** First line of a Python string literal's content, quotes and prefixes removed. */
+function pyStringFirstLine(stringNode) {
+    const content = stringNode.namedChildren.find((c) => c?.type === 'string_content');
+    if (!content)
+        return null;
+    for (const rawLine of content.text.split('\n')) {
+        const line = rawLine.trim();
+        if (line.length > 0)
+            return firstSentence(line);
+    }
+    return null;
+}
+/** Docstring first line of a `block` (or `module`) node, when present. */
+function pyDocstring(body) {
+    const first = body?.namedChildren.find((c) => c !== null && c.type !== 'comment');
+    if (first && first.type === 'expression_statement') {
+        const str = first.namedChildren.find((c) => c?.type === 'string');
+        if (str)
+            return pyStringFirstLine(str);
+    }
+    return null;
+}
+function countPyMethods(classNode) {
+    const body = classNode.childForFieldName('body');
+    if (!body)
+        return 0;
+    let count = 0;
+    for (let child of body.namedChildren) {
+        if (!child)
+            continue;
+        if (child.type === 'decorated_definition') {
+            child = child.childForFieldName('definition') ?? child;
+        }
+        if (child.type === 'function_definition') {
+            if (child.childForFieldName('name')?.text !== '__init__')
+                count++;
+        }
+    }
+    return count;
+}
+function extractPython(root) {
+    const out = emptyResult();
+    out.fileDoc = pyDocstring(root);
+    let allList = null;
+    const publicNames = [];
+    for (let child of root.namedChildren) {
+        if (!child)
+            continue;
+        if (child.type === 'decorated_definition') {
+            child = child.childForFieldName('definition') ?? child;
+        }
+        switch (child.type) {
+            case 'import_statement': {
+                for (const item of child.namedChildren) {
+                    if (!item)
+                        continue;
+                    if (item.type === 'dotted_name')
+                        out.imports.push(item.text);
+                    else if (item.type === 'aliased_import') {
+                        const name = item.childForFieldName('name');
+                        if (name)
+                            out.imports.push(name.text);
+                    }
+                }
+                break;
+            }
+            case 'import_from_statement': {
+                const module = child.childForFieldName('module_name');
+                if (module)
+                    out.imports.push(module.text);
+                break;
+            }
+            case 'function_definition': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    const isPublic = !name.startsWith('_');
+                    out.topLevelDeclarations.push(`def ${name}`);
+                    out.functions.push({
+                        name,
+                        doc: pyDocstring(child.childForFieldName('body')),
+                        exported: isPublic,
+                    });
+                    if (isPublic)
+                        publicNames.push(name);
+                }
+                break;
+            }
+            case 'class_definition': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    const isPublic = !name.startsWith('_');
+                    out.topLevelDeclarations.push(`class ${name}`);
+                    out.classes.push({
+                        name,
+                        kind: 'class',
+                        methodCount: countPyMethods(child),
+                        doc: pyDocstring(child.childForFieldName('body')),
+                        exported: isPublic,
+                    });
+                    if (isPublic)
+                        publicNames.push(name);
+                }
+                break;
+            }
+            case 'expression_statement': {
+                const assignment = child.namedChildren.find((c) => c?.type === 'assignment');
+                const left = assignment?.childForFieldName('left');
+                if (!assignment || !left || left.type !== 'identifier')
+                    break;
+                const name = left.text;
+                if (name === '__all__') {
+                    const right = assignment.childForFieldName('right');
+                    if (right && (right.type === 'list' || right.type === 'tuple')) {
+                        allList = [];
+                        for (const item of right.namedChildren) {
+                            if (item?.type !== 'string')
+                                continue;
+                            const content = item.namedChildren.find((c) => c?.type === 'string_content');
+                            if (content)
+                                allList.push(content.text);
+                        }
+                    }
+                }
+                else if (!name.startsWith('_')) {
+                    publicNames.push(name);
+                    if (/^[A-Z0-9_]+$/.test(name))
+                        out.constNames.push(name);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    // `__all__` is the explicit export list; otherwise every public top-level
+    // binding (def/class/assignment without a leading underscore) is exported.
+    out.exports = allList ?? publicNames;
+    return dedupeResult(out);
+}
+// ---------------------------------------------------------------------------
+// Go extraction
+// ---------------------------------------------------------------------------
+function isGoExported(name) {
+    return /^[A-Z]/.test(name);
+}
+/**
+ * First line of the contiguous `//` comment block directly above `node`
+ * (Go doc-comment convention: no blank line between comment and declaration).
+ */
+function goDocComment(node) {
+    let expectedRow = node.startPosition.row;
+    let current = node.previousNamedSibling;
+    let top = null;
+    while (current && current.type === 'comment' && current.endPosition.row === expectedRow - 1) {
+        top = current;
+        expectedRow = current.startPosition.row;
+        current = current.previousNamedSibling;
+    }
+    return top ? commentFirstLine(top.text) : null;
+}
+function goImportPath(spec, out) {
+    const path = spec.childForFieldName('path');
+    if (path)
+        out.imports.push(stripQuotes(path.text));
+}
+/** Names declared in a `var_spec` / `const_spec` (may bind several identifiers). */
+function goSpecNames(spec) {
+    const names = [];
+    for (const child of spec.namedChildren) {
+        if (child?.type === 'identifier')
+            names.push(child.text);
+        else
+            break; // identifiers come first; stop at the type/value part
+    }
+    return names;
+}
+/** Promote named types with methods to class-like entries, the rest to typeNames. */
+function resolveNamedTypes(types, methodCounts, out) {
+    for (const entry of types) {
+        const methodCount = methodCounts.get(entry.name) ?? 0;
+        if (methodCount > 0) {
+            out.classes.push({ ...entry, methodCount });
+        }
+        else {
+            out.typeNames.push(entry.name);
+        }
+    }
+}
+function extractGo(root) {
+    const out = emptyResult();
+    const types = [];
+    const methodCounts = new Map();
+    for (const child of root.namedChildren) {
+        if (!child)
+            continue;
+        switch (child.type) {
+            case 'package_clause':
+                out.fileDoc = goDocComment(child);
+                break;
+            case 'import_declaration': {
+                for (const inner of child.namedChildren) {
+                    if (!inner)
+                        continue;
+                    if (inner.type === 'import_spec')
+                        goImportPath(inner, out);
+                    else if (inner.type === 'import_spec_list') {
+                        for (const spec of inner.namedChildren) {
+                            if (spec?.type === 'import_spec')
+                                goImportPath(spec, out);
+                        }
+                    }
+                }
+                break;
+            }
+            case 'function_declaration': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    out.topLevelDeclarations.push(`func ${name}`);
+                    out.functions.push({ name, doc: goDocComment(child), exported: isGoExported(name) });
+                    if (isGoExported(name))
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'method_declaration': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    out.topLevelDeclarations.push(`func ${name}`);
+                    if (isGoExported(name))
+                        out.exports.push(name);
+                    // Attribute the method to its receiver's named type.
+                    const receiver = child.childForFieldName('receiver');
+                    const receiverType = receiver?.descendantsOfType('type_identifier')[0]?.text;
+                    if (receiverType) {
+                        methodCounts.set(receiverType, (methodCounts.get(receiverType) ?? 0) + 1);
+                    }
+                }
+                break;
+            }
+            case 'type_declaration': {
+                for (const spec of child.namedChildren) {
+                    if (!spec || (spec.type !== 'type_spec' && spec.type !== 'type_alias'))
+                        continue;
+                    const name = spec.childForFieldName('name')?.text;
+                    if (!name)
+                        continue;
+                    const typeNode = spec.childForFieldName('type');
+                    const kind = typeNode?.type === 'struct_type'
+                        ? 'struct'
+                        : typeNode?.type === 'interface_type'
+                            ? 'interface'
+                            : 'type';
+                    out.topLevelDeclarations.push(kind === 'type' ? `type ${name}` : `type ${name} ${kind}`);
+                    types.push({ name, kind, doc: goDocComment(child), exported: isGoExported(name) });
+                    if (isGoExported(name))
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'var_declaration':
+            case 'const_declaration': {
+                const keyword = child.type === 'var_declaration' ? 'var' : 'const';
+                for (const spec of child.namedChildren) {
+                    if (!spec || (spec.type !== 'var_spec' && spec.type !== 'const_spec'))
+                        continue;
+                    for (const name of goSpecNames(spec)) {
+                        out.topLevelDeclarations.push(`${keyword} ${name}`);
+                        if (keyword === 'const')
+                            out.constNames.push(name);
+                        if (isGoExported(name))
+                            out.exports.push(name);
+                    }
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    resolveNamedTypes(types, methodCounts, out);
+    return dedupeResult(out);
+}
+// ---------------------------------------------------------------------------
+// Rust extraction
+// ---------------------------------------------------------------------------
+/** Plain `pub` only — `pub(crate)` / `pub(super)` are not part of the public API. */
+function isRustPub(node) {
+    return node.namedChildren.some((c) => c?.type === 'visibility_modifier' && c.text === 'pub');
+}
+/**
+ * First line of the contiguous `///` doc-comment block directly above `node`,
+ * skipping any `#[...]` attributes between the docs and the item.
+ */
+function rustDocComment(node) {
+    let expectedRow = node.startPosition.row;
+    let current = node.previousNamedSibling;
+    while (current && current.type === 'attribute_item' && current.endPosition.row === expectedRow - 1) {
+        expectedRow = current.startPosition.row;
+        current = current.previousNamedSibling;
+    }
+    let top = null;
+    while (current &&
+        current.type === 'line_comment' &&
+        current.text.startsWith('///') &&
+        current.endPosition.row === expectedRow - 1) {
+        top = current;
+        expectedRow = current.startPosition.row;
+        current = current.previousNamedSibling;
+    }
+    if (top) {
+        const line = top.text.replace(/^\/\/\/\s*/, '').trim();
+        return line.length > 0 ? firstSentence(line) : null;
+    }
+    if (current && current.type === 'block_comment' && current.text.startsWith('/**')) {
+        return commentFirstLine(current.text);
+    }
+    return null;
+}
+/** Module path of a `use` argument, with grouped/aliased/glob tails removed. */
+function rustUseBasePath(argument) {
+    switch (argument.type) {
+        case 'scoped_use_list': {
+            const path = argument.childForFieldName('path');
+            return path ? path.text : argument.text;
+        }
+        case 'use_as_clause': {
+            const path = argument.childForFieldName('path');
+            return path ? path.text : argument.text;
+        }
+        case 'use_wildcard': {
+            const inner = argument.namedChildren.find((c) => c !== null);
+            return inner ? inner.text : argument.text;
+        }
+        default:
+            return argument.text;
+    }
+}
+/** Visible names introduced by a `pub use` argument (re-exports). */
+function rustUseNames(argument, out) {
+    switch (argument.type) {
+        case 'identifier':
+        case 'crate':
+        case 'self':
+        case 'super':
+            out.push(argument.text);
+            break;
+        case 'scoped_identifier': {
+            const name = argument.childForFieldName('name');
+            if (name)
+                out.push(name.text);
+            break;
+        }
+        case 'use_as_clause': {
+            const alias = argument.childForFieldName('alias');
+            if (alias)
+                out.push(alias.text);
+            break;
+        }
+        case 'scoped_use_list': {
+            const list = argument.childForFieldName('list');
+            for (const item of list?.namedChildren ?? []) {
+                if (item)
+                    rustUseNames(item, out);
+            }
+            break;
+        }
+        case 'use_list': {
+            for (const item of argument.namedChildren) {
+                if (item)
+                    rustUseNames(item, out);
+            }
+            break;
+        }
+        default:
+            break;
+    }
+}
+const RUST_TYPE_ITEMS = {
+    struct_item: 'struct',
+    enum_item: 'enum',
+    trait_item: 'trait',
+    union_item: 'union',
+};
+function extractRust(root) {
+    const out = emptyResult();
+    const types = [];
+    const methodCounts = new Map();
+    let seenCode = false;
+    for (const child of root.namedChildren) {
+        if (!child)
+            continue;
+        const pub = isRustPub(child);
+        switch (child.type) {
+            case 'line_comment':
+                if (!seenCode && out.fileDoc === null && child.text.startsWith('//!')) {
+                    const line = child.text.replace(/^\/\/!\s*/, '').trim();
+                    if (line.length > 0)
+                        out.fileDoc = firstSentence(line);
+                }
+                continue; // comments don't count as code
+            case 'block_comment':
+                continue;
+            case 'use_declaration': {
+                const argument = child.childForFieldName('argument');
+                if (argument) {
+                    out.imports.push(rustUseBasePath(argument));
+                    if (pub)
+                        rustUseNames(argument, out.exports); // `pub use` re-exports
+                }
+                break;
+            }
+            case 'mod_item': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    out.topLevelDeclarations.push(`mod ${name}`);
+                    if (!child.childForFieldName('body'))
+                        out.imports.push(name); // `mod x;`
+                    if (pub)
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'function_item': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    out.topLevelDeclarations.push(`fn ${name}`);
+                    out.functions.push({ name, doc: rustDocComment(child), exported: pub });
+                    if (pub)
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'struct_item':
+            case 'enum_item':
+            case 'trait_item':
+            case 'union_item': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    const kind = RUST_TYPE_ITEMS[child.type];
+                    out.topLevelDeclarations.push(`${kind} ${name}`);
+                    types.push({ name, kind, doc: rustDocComment(child), exported: pub });
+                    if (pub)
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'impl_item': {
+                // Strip generic params so `impl Config<T>` matches `struct Config`.
+                const typeName = child.childForFieldName('type')?.text.replace(/<.*$/s, '');
+                if (typeName) {
+                    out.topLevelDeclarations.push(`impl ${typeName}`);
+                    const body = child.childForFieldName('body');
+                    let methods = 0;
+                    for (const item of body?.namedChildren ?? []) {
+                        if (item?.type === 'function_item')
+                            methods++;
+                    }
+                    if (methods > 0) {
+                        methodCounts.set(typeName, (methodCounts.get(typeName) ?? 0) + methods);
+                    }
+                }
+                break;
+            }
+            case 'type_item': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    out.topLevelDeclarations.push(`type ${name}`);
+                    out.typeNames.push(name);
+                    if (pub)
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'const_item':
+            case 'static_item': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    out.topLevelDeclarations.push(`${child.type === 'const_item' ? 'const' : 'static'} ${name}`);
+                    out.constNames.push(name);
+                    if (pub)
+                        out.exports.push(name);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        seenCode = true;
+    }
+    resolveNamedTypes(types, methodCounts, out);
+    return dedupeResult(out);
+}
+// ---------------------------------------------------------------------------
+// Kotlin extraction
+// ---------------------------------------------------------------------------
+/**
+ * True unless the declaration carries a `private`/`internal`/`protected`
+ * visibility modifier (`public` is the Kotlin default).
+ */
+function ktIsPublic(node) {
+    const mods = node.namedChildren.find((c) => c?.type === 'modifiers');
+    for (const m of mods?.namedChildren ?? []) {
+        if (m?.type === 'visibility_modifier' && m.text !== 'public')
+            return false;
+    }
+    return true;
+}
+/** The Kotlin grammar exposes keywords (`interface`, `enum`, …) as anonymous tokens. */
+function ktHasToken(node, token) {
+    return node.children.some((c) => c !== null && c.type === token);
+}
+function ktHasClassModifier(node, modifier) {
+    const mods = node.namedChildren.find((c) => c?.type === 'modifiers');
+    return (mods?.namedChildren ?? []).some((m) => m !== null && m.type === 'class_modifier' && m.text === modifier);
+}
+/**
+ * KDoc block immediately above `node`. The Kotlin grammar attaches the
+ * comment preceding the first declaration after the imports as the trailing
+ * descendant of the import list, so that path is checked too.
+ */
+function ktPrecedingDoc(node) {
+    let prev = node.previousNamedSibling;
+    if (prev && (prev.type === 'import_list' || prev.type === 'package_header')) {
+        let tail = prev;
+        while (tail.lastNamedChild)
+            tail = tail.lastNamedChild;
+        prev = tail;
+    }
+    if (prev && prev.type === 'multiline_comment' && prev.text.startsWith('/**')) {
+        return commentFirstLine(prev.text);
+    }
+    return null;
+}
+/** Method count of a class/object body, including companion-object functions. */
+function ktCountMethods(body) {
+    let count = 0;
+    for (const child of body?.namedChildren ?? []) {
+        if (!child)
+            continue;
+        if (child.type === 'function_declaration')
+            count++;
+        else if (child.type === 'companion_object') {
+            count += ktCountMethods(child.namedChildren.find((c) => c?.type === 'class_body'));
+        }
+    }
+    return count;
+}
+function extractKotlin(root) {
+    const out = emptyResult();
+    let seenCode = false;
+    for (const child of root.namedChildren) {
+        if (!child)
+            continue;
+        switch (child.type) {
+            case 'multiline_comment':
+                if (!seenCode && out.fileDoc === null && child.text.startsWith('/**')) {
+                    out.fileDoc = commentFirstLine(child.text);
+                }
+                continue;
+            case 'line_comment':
+                continue;
+            case 'package_header':
+                break;
+            case 'import_list': {
+                for (const header of child.namedChildren) {
+                    if (header?.type !== 'import_header')
+                        continue;
+                    // `identifier` is the dotted path; a trailing `.*` (wildcard_import)
+                    // and `as` aliases sit outside it, so they are stripped for free.
+                    const path = header.namedChildren.find((c) => c?.type === 'identifier');
+                    if (path)
+                        out.imports.push(path.text.replace(/\s/g, ''));
+                }
+                break;
+            }
+            case 'class_declaration': {
+                const name = child.namedChildren.find((c) => c?.type === 'type_identifier')?.text;
+                if (!name)
+                    break;
+                const pub = ktIsPublic(child);
+                const doc = ktPrecedingDoc(child);
+                const body = child.namedChildren.find((c) => c?.type === 'class_body');
+                if (ktHasToken(child, 'interface')) {
+                    out.topLevelDeclarations.push(`interface ${name}`);
+                    out.classes.push({
+                        name,
+                        kind: 'interface',
+                        methodCount: ktCountMethods(body),
+                        doc,
+                        exported: pub,
+                    });
+                }
+                else if (ktHasToken(child, 'enum')) {
+                    out.topLevelDeclarations.push(`enum class ${name}`);
+                    out.typeNames.push(name);
+                }
+                else {
+                    const kind = ktHasClassModifier(child, 'data') ? 'data class' : 'class';
+                    out.topLevelDeclarations.push(`${kind} ${name}`);
+                    out.classes.push({ name, kind, methodCount: ktCountMethods(body), doc, exported: pub });
+                }
+                if (pub)
+                    out.exports.push(name);
+                break;
+            }
+            case 'object_declaration': {
+                const name = child.namedChildren.find((c) => c?.type === 'type_identifier')?.text;
+                if (name) {
+                    const pub = ktIsPublic(child);
+                    const body = child.namedChildren.find((c) => c?.type === 'class_body');
+                    out.topLevelDeclarations.push(`object ${name}`);
+                    out.classes.push({
+                        name,
+                        kind: 'object',
+                        methodCount: ktCountMethods(body),
+                        doc: ktPrecedingDoc(child),
+                        exported: pub,
+                    });
+                    if (pub)
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'function_declaration': {
+                const name = child.namedChildren.find((c) => c?.type === 'simple_identifier')?.text;
+                if (name) {
+                    const pub = ktIsPublic(child);
+                    out.topLevelDeclarations.push(`fun ${name}`);
+                    out.functions.push({ name, doc: ktPrecedingDoc(child), exported: pub });
+                    if (pub)
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'property_declaration': {
+                const kind = child.namedChildren.find((c) => c?.type === 'binding_pattern_kind')?.text ?? 'val';
+                const decl = child.namedChildren.find((c) => c?.type === 'variable_declaration');
+                const name = decl?.namedChildren.find((c) => c?.type === 'simple_identifier')?.text;
+                if (name) {
+                    out.topLevelDeclarations.push(`${kind} ${name}`);
+                    if (kind === 'val')
+                        out.constNames.push(name);
+                    if (ktIsPublic(child))
+                        out.exports.push(name);
+                }
+                break;
+            }
+            case 'type_alias': {
+                const name = child.namedChildren.find((c) => c?.type === 'type_identifier')?.text;
+                if (name) {
+                    out.topLevelDeclarations.push(`typealias ${name}`);
+                    out.typeNames.push(name);
+                    if (ktIsPublic(child))
+                        out.exports.push(name);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        seenCode = true;
+    }
+    return dedupeResult(out);
+}
+// ---------------------------------------------------------------------------
+// Java extraction
+// ---------------------------------------------------------------------------
+/** Javadoc block immediately preceding `node`. */
+function javaPrecedingDoc(node) {
+    const prev = node.previousNamedSibling;
+    if (prev && prev.type === 'block_comment' && prev.text.startsWith('/**')) {
+        return commentFirstLine(prev.text);
+    }
+    return null;
+}
+/** Java modifiers (`public`, `static`, …) are anonymous tokens under `modifiers`. */
+function javaHasModifier(node, modifier) {
+    const mods = node.namedChildren.find((c) => c?.type === 'modifiers');
+    return (mods?.children ?? []).some((c) => c !== null && c.type === modifier);
+}
+/**
+ * Collect the public members of a top-level type into `out.exports` (when the
+ * type itself is public) and return its method count. Interface members are
+ * implicitly public. A `static main` method is recorded as a function so the
+ * purpose generator can mark the file as an entry point.
+ */
+function javaCollectMembers(typeNode, kind, typePublic, out) {
+    const body = typeNode.childForFieldName('body');
+    let methods = 0;
+    for (const member of body?.namedChildren ?? []) {
+        if (!member)
+            continue;
+        if (member.type === 'method_declaration') {
+            methods++;
+            const name = member.childForFieldName('name')?.text;
+            if (!name)
+                continue;
+            const memberPublic = kind === 'interface' || javaHasModifier(member, 'public');
+            if (name === 'main' && javaHasModifier(member, 'static')) {
+                out.functions.push({ name, doc: null, exported: memberPublic });
+            }
+            if (typePublic && memberPublic)
+                out.exports.push(name);
+        }
+        else if (member.type === 'field_declaration') {
+            if (!typePublic)
+                continue;
+            if (kind !== 'interface' && !javaHasModifier(member, 'public'))
+                continue;
+            for (const decl of member.namedChildren) {
+                if (decl?.type !== 'variable_declarator')
+                    continue;
+                const name = decl.childForFieldName('name')?.text;
+                if (!name)
+                    continue;
+                out.exports.push(name);
+                if (/^[A-Z0-9_]+$/.test(name))
+                    out.constNames.push(name);
+            }
+        }
+    }
+    return methods;
+}
+function extractJava(root) {
+    const out = emptyResult();
+    let seenCode = false;
+    for (const child of root.namedChildren) {
+        if (!child)
+            continue;
+        switch (child.type) {
+            case 'block_comment':
+                if (!seenCode && out.fileDoc === null && child.text.startsWith('/**')) {
+                    out.fileDoc = commentFirstLine(child.text);
+                }
+                continue;
+            case 'line_comment':
+                continue;
+            case 'package_declaration':
+                break;
+            case 'import_declaration': {
+                // The dotted path; a trailing `.*` is a separate `asterisk` node, so
+                // wildcard imports already arrive stripped.
+                const path = child.namedChildren.find((c) => c?.type === 'scoped_identifier' || c?.type === 'identifier');
+                if (path)
+                    out.imports.push(path.text.replace(/\s/g, ''));
+                break;
+            }
+            case 'class_declaration':
+            case 'interface_declaration':
+            case 'record_declaration': {
+                const name = child.childForFieldName('name')?.text;
+                if (!name)
+                    break;
+                const kind = child.type === 'class_declaration'
+                    ? 'class'
+                    : child.type === 'interface_declaration'
+                        ? 'interface'
+                        : 'record';
+                const pub = javaHasModifier(child, 'public');
+                out.topLevelDeclarations.push(`${kind} ${name}`);
+                const methodCount = javaCollectMembers(child, kind, pub, out);
+                out.classes.push({ name, kind, methodCount, doc: javaPrecedingDoc(child), exported: pub });
+                if (pub)
+                    out.exports.push(name);
+                break;
+            }
+            case 'enum_declaration':
+            case 'annotation_type_declaration': {
+                const name = child.childForFieldName('name')?.text;
+                if (name) {
+                    const kind = child.type === 'enum_declaration' ? 'enum' : 'annotation';
+                    out.topLevelDeclarations.push(`${kind} ${name}`);
+                    out.typeNames.push(name);
+                    if (javaHasModifier(child, 'public'))
+                        out.exports.push(name);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        seenCode = true;
+    }
+    return dedupeResult(out);
+}
+function extract(root, grammar) {
+    switch (grammar) {
+        case 'python':
+            return extractPython(root);
+        case 'go':
+            return extractGo(root);
+        case 'rust':
+            return extractRust(root);
+        case 'kotlin':
+            return extractKotlin(root);
+        case 'java':
+            return extractJava(root);
+        default:
+            return extractTsJs(root);
+    }
 }
 // ---------------------------------------------------------------------------
 // Purpose line generation
 // ---------------------------------------------------------------------------
-function fileCategory(filePath) {
+function fileCategory(filePath, contents) {
     const basename = getBasename(filePath);
+    const ext = getExtension(filePath);
+    const dir = filePath.replace(/\\/g, '/');
+    const inTestsDir = dir.includes('/tests/') || dir.includes('/test/') || /^tests?\//.test(dir);
+    if (ext === '.py') {
+        if (basename.startsWith('test_') || basename.endsWith('_test.py'))
+            return 'test';
+        if (basename === 'conftest.py')
+            return 'test';
+        if (inTestsDir)
+            return 'test';
+        if (basename === 'setup.py' || basename === 'settings.py' || basename === 'config.py') {
+            return 'config';
+        }
+        if (basename === '__init__.py' || basename === '__main__.py')
+            return 'entry point';
+        if (/\bif\s+__name__\s*==\s*['"]__main__['"]\s*:/.test(contents))
+            return 'entry point';
+        return null;
+    }
+    if (ext === '.go') {
+        if (basename.endsWith('_test.go'))
+            return 'test';
+        if (basename === 'main.go')
+            return 'entry point';
+        return null;
+    }
+    if (ext === '.rs') {
+        if (inTestsDir || basename.startsWith('test_'))
+            return 'test';
+        if (basename === 'main.rs' || basename === 'lib.rs' || basename === 'mod.rs') {
+            return 'entry point';
+        }
+        if (basename === 'build.rs')
+            return 'config';
+        return null;
+    }
+    if (ext === '.kt' || ext === '.kts') {
+        if (/Test\.kts?$/.test(basename) || inTestsDir || dir.includes('/androidTest/'))
+            return 'test';
+        if (basename.endsWith('.gradle.kts'))
+            return 'config';
+        if (basename === 'Main.kt')
+            return 'entry point';
+        return null;
+    }
+    if (ext === '.java') {
+        if (/Tests?\.java$/.test(basename) || inTestsDir)
+            return 'test';
+        if (basename === 'Main.java')
+            return 'entry point';
+        return null;
+    }
     if (filePath.endsWith('.d.ts'))
         return 'types';
     if (/\.(?:test|spec)\.[tj]sx?$/.test(basename))
@@ -304,7 +1175,7 @@ function listNames(names, max) {
     return `${names.slice(0, max).join(', ')} (+${names.length - max} more)`;
 }
 function buildPurpose(filePath, contents, info) {
-    let category = fileCategory(filePath);
+    let category = fileCategory(filePath, contents);
     // Executable entry points: shebang line or a top-level main() function.
     if (category === null &&
         (contents.startsWith('#!') || info.functions.some((f) => f.name === 'main'))) {
@@ -318,7 +1189,7 @@ function buildPurpose(filePath, contents, info) {
     if (classes.length > 0) {
         const primary = [...classes].sort((a, b) => b.methodCount - a.methodCount)[0];
         const desc = primary.doc ?? info.fileDoc;
-        const head = `class ${primary.name} (${primary.methodCount} method${primary.methodCount === 1 ? '' : 's'})`;
+        const head = `${primary.kind} ${primary.name} (${primary.methodCount} method${primary.methodCount === 1 ? '' : 's'})`;
         const rest = classes.filter((c) => c !== primary).map((c) => c.name);
         const suffix = rest.length > 0 ? ` +${listNames(rest, 2)}` : '';
         detail = desc ? `${head}${suffix}: ${desc}` : `${head}${suffix}`;
@@ -355,9 +1226,9 @@ function buildPurpose(filePath, contents, info) {
 // Entry point
 // ---------------------------------------------------------------------------
 /**
- * Summarize a TS/JS file from its syntax tree. Falls back to the regex
- * summarizer for unsupported extensions, empty files, parse errors, or when
- * the WASM runtime cannot be loaded.
+ * Summarize a TS/JS, Python, Go, Rust, Kotlin or Java file from its syntax
+ * tree. Falls back to the regex summarizer for unsupported extensions, empty
+ * files, parse errors, or when the WASM runtime cannot be loaded.
  */
 export async function summarizeFileAst(filePath, contents) {
     const grammar = EXT_TO_GRAMMAR[getExtension(filePath)];
@@ -373,14 +1244,16 @@ export async function summarizeFileAst(filePath, contents) {
         runtimeBroken = true;
         return summarizeFile(filePath, contents);
     }
-    const tree = parser.parse(contents);
+    // Some grammars (Go) need a statement terminator after the last declaration;
+    // parse with a trailing newline so files missing one don't report errors.
+    const tree = parser.parse(contents.endsWith('\n') ? contents : `${contents}\n`);
     if (!tree)
         return summarizeFile(filePath, contents);
     try {
         if (tree.rootNode.hasError) {
             return summarizeFile(filePath, contents);
         }
-        const info = extract(tree.rootNode);
+        const info = extract(tree.rootNode, grammar);
         return {
             purpose: buildPurpose(filePath, contents, info),
             exports: info.exports,