@praneeth_54/agentdoctor 2.1.0 → 3.0.0

package/dist/intelligence/graph/build.js

@@ -6,6 +6,7 @@ import { resolveRepoRoot, toPosixRelative } from "../../utils/path.js";
 import { buildRepositoryGraph } from "../../platform/graph/build.js";
 import { CONTRACTS_VERSION } from "../../contracts/index.js";
 import { loadTsconfigPaths, resolveImportSpecifier, } from "../resolve/imports.js";
+import { enrichGraphWithLanguageAdapters } from "../../product/graph/enrich-languages.js";
 function evidenceForConfidence(confidence) {
     if (confidence === "EXACT")
         return "verified";
@@ -16,6 +17,33 @@ function evidenceForConfidence(confidence) {
 export function nodeId(kind, key) {
     return `${kind}:${createHash("sha1").update(key).digest("hex").slice(0, 12)}`;
 }
+async function applyLanguageEnrichment(graph, root) {
+    try {
+        const { graph: enriched, stats } = await enrichGraphWithLanguageAdapters(graph, root);
+        const extra = stats.filesParsed > 0
+            ? [
+                `Language adapters enriched graph (+${stats.nodesAdded} nodes, +${stats.edgesAdded} edges, ${stats.filesParsed} files parsed)`,
+            ]
+            : stats.filesAttempted > 0
+                ? ["Language adapter enrichment: no supported parses in sampled .py/.php/.go files"]
+                : [];
+        return {
+            ...enriched,
+            builder: graph.builder,
+            astFilesParsed: graph.astFilesParsed,
+            limitations: [...enriched.limitations, ...extra],
+        };
+    }
+    catch (error) {
+        return {
+            ...graph,
+            limitations: [
+                ...graph.limitations,
+                `Language adapter enrichment failed (${error instanceof Error ? error.message : String(error)})`,
+            ],
+        };
+    }
+}
 export async function listTsFiles(root, limit = 400) {
     const out = [];
     const skip = new Set(["node_modules", ".git", "dist", "coverage", ".agentdoctor", "vendor"]);
@@ -56,13 +84,13 @@ export async function buildIntelligenceGraph(options) {
     const mode = options.mode ?? "auto";
     if (mode === "regex") {
         const g = await buildRepositoryGraph(root);
-        return { ...g, builder: "regex", astFilesParsed: 0 };
+        return applyLanguageEnrichment({ ...g, builder: "regex", astFilesParsed: 0 }, root);
     }
     try {
         const files = await listTsFiles(root);
         if (files.length === 0) {
             const g = await buildRepositoryGraph(root);
-            return {
+            return applyLanguageEnrichment({
                 ...g,
                 builder: "regex",
                 astFilesParsed: 0,
@@ -70,7 +98,7 @@ export async function buildIntelligenceGraph(options) {
                     ...g.limitations,
                     "No TypeScript sources found for AST builder; used regex fallback",
                 ],
-            };
+            }, root);
         }
         const program = ts.createProgram({
             rootNames: files,
@@ -228,7 +256,7 @@ export async function buildIntelligenceGraph(options) {
         }
         nodes.sort((a, b) => a.id.localeCompare(b.id));
         edges.sort((a, b) => a.id.localeCompare(b.id));
-        return {
+        return applyLanguageEnrichment({
             root,
             generatedAt: new Date().toISOString(),
             nodes,
@@ -239,14 +267,14 @@ export async function buildIntelligenceGraph(options) {
                 "TypeScript AST builder uses the TypeScript compiler API for .ts/.tsx only",
                 "Cross-file call resolution is identifier-based (not full type-checker binding)",
                 "Import edges use EXACT|RESOLVED|INFERRED confidence; UNRESOLVED never invents file targets",
-                "Non-TypeScript languages fall back to regex graph when requested via auto+empty TS set",
+                "Additional .py/.php/.go nodes may be merged via language adapters when supported",
                 `analysisVersion=${CONTRACTS_VERSION}`,
             ],
-        };
+        }, root);
     }
     catch (error) {
         const g = await buildRepositoryGraph(root);
-        return {
+        return applyLanguageEnrichment({
             ...g,
             builder: "regex",
             astFilesParsed: 0,
@@ -254,6 +282,6 @@ export async function buildIntelligenceGraph(options) {
                 ...g.limitations,
                 `TypeScript AST builder failed; regex fallback used (${error instanceof Error ? error.message : String(error)})`,
             ],
-        };
+        }, root);
     }
 }

package/dist/intelligence/resolve/imports.js

@@ -143,7 +143,7 @@ function matchTsconfigPath(specifier, config) {
                 specifier.endsWith(suffix)) {
                 const star = specifier.slice(prefix.length, specifier.length - suffix.length);
                 const target = targets[0];
-                const mapped = target.includes("*") ? target.replace("*", star) : target;
+                const mapped = target.includes("*") ? target.split("*").join(star) : target;
                 return { mapped, pattern };
             }
         }

package/dist/languages/dart.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageAdapter, LanguageImport, LanguageSymbol } from "./types.js";
+export interface DartParseSummary {
+    libraryName: string;
+    imports: LanguageImport[];
+    symbols: LanguageSymbol[];
+    limitations: string[];
+}
+/** Lightweight line-oriented Dart scan — not Dart analyzer APIs. */
+export declare function parseDartSource(filePath: string, source: string): DartParseSummary;
+export declare const dartAdapter: LanguageAdapter;

package/dist/languages/dart.js

@@ -0,0 +1,99 @@
+/** Lightweight line-oriented Dart scan — not Dart analyzer APIs. */
+export function parseDartSource(filePath, source) {
+    const lines = source.split(/\r?\n/);
+    const limitations = [
+        "Dart parsing uses a lightweight line scanner — not the Dart analyzer; calls/types are partial.",
+        "Full Dart analyzer or tree-sitter-dart integration remains an EXTERNAL enhancement path (not bundled).",
+    ];
+    let libraryName = "";
+    const imports = [];
+    const symbols = [];
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!libraryName && trimmed.startsWith("library ")) {
+            libraryName = trimmed.slice("library ".length).replace(/;$/, "").trim();
+        }
+        if (trimmed.startsWith("import ") && trimmed.endsWith(";")) {
+            const spec = trimmed
+                .slice("import ".length, -1)
+                .replace(/^['"]|['"]$/g, "")
+                .trim();
+            if (spec)
+                imports.push({ fromFile: filePath, specifier: spec, evidence: "ast" });
+        }
+        if (trimmed.startsWith("export ") && trimmed.endsWith(";")) {
+            const spec = trimmed
+                .slice("export ".length, -1)
+                .replace(/^['"]|['"]$/g, "")
+                .trim();
+            if (spec)
+                imports.push({ fromFile: filePath, specifier: spec, evidence: "ast" });
+        }
+        const typeMatch = /^(?:abstract\s+)?(?:class|mixin|extension)\s+(\w+)/.exec(trimmed);
+        if (typeMatch) {
+            let kind = "class";
+            if (trimmed.includes("mixin"))
+                kind = "mixin";
+            else if (trimmed.includes("extension"))
+                kind = "extension";
+            symbols.push({
+                id: `dart:${kind}:${filePath}:${typeMatch[1]}`,
+                name: typeMatch[1],
+                kind,
+                file: filePath,
+                line: i + 1,
+                evidence: "ast",
+            });
+        }
+        const fnMatch = /^(?:\w+\s+)?(\w+)\s*\([^)]*\)\s*(?:async\s*)?\{?\s*$/.exec(trimmed);
+        if (fnMatch &&
+            !trimmed.startsWith("if ") &&
+            !trimmed.startsWith("for ") &&
+            !trimmed.startsWith("while ") &&
+            !trimmed.startsWith("class ") &&
+            !trimmed.startsWith("return ")) {
+            const name = fnMatch[1];
+            if (!["void", "final", "const", "var", "late"].includes(name)) {
+                symbols.push({
+                    id: `dart:function:${filePath}:${name}`,
+                    name,
+                    kind: "function",
+                    file: filePath,
+                    line: i + 1,
+                    evidence: "ast",
+                });
+            }
+        }
+    }
+    return { libraryName, imports, symbols, limitations };
+}
+const DART_CAPABILITIES = () => ({
+    parse: "supported",
+    symbols: "supported",
+    definitions: "unsupported",
+    references: "unsupported",
+    imports: "supported",
+    calls: "partial",
+    diagnostics: "unsupported",
+    types: "partial",
+});
+export const dartAdapter = {
+    id: "dart",
+    extensions: [".dart"],
+    capabilities: DART_CAPABILITIES,
+    async parse(filePath, source) {
+        const summary = parseDartSource(filePath, source);
+        const ok = Boolean(summary.libraryName || summary.symbols.length > 0 || summary.imports.length > 0);
+        return {
+            language: "dart",
+            file: filePath,
+            ok,
+            capabilities: dartAdapter.capabilities(),
+            symbols: summary.symbols,
+            imports: summary.imports,
+            calls: [],
+            diagnostics: ok ? [] : ["no library, import, or declarations detected"],
+            limitations: summary.limitations,
+        };
+    },
+};

package/dist/languages/go.d.ts

@@ -1,9 +1,15 @@
-import type { LanguageAdapter } from "./types.js";
-/**
- * Go toolchain bridge placeholder.
- * Prefer real `go/ast` via `go run` when the Go toolchain is present; until an
- * extractor is bundled, capability remains unsupported even if `go` exists.
- * Today: always unsupported (no bundled extractor; avoids fake AST claims).
- */
+import type { LanguageAdapter, LanguageSymbol, LanguageImport } from "./types.js";
 export declare function goAvailable(): boolean;
+export interface GoSourceRange {
+    startLine: number;
+    endLine: number;
+}
+export interface GoParseSummary {
+    packageName: string;
+    imports: LanguageImport[];
+    symbols: LanguageSymbol[];
+    limitations: string[];
+}
+/** Lightweight line-oriented Go scan (not go/ast). Honest partial call resolution. */
+export declare function parseGoSource(filePath: string, source: string): GoParseSummary;
 export declare const goAdapter: LanguageAdapter;

package/dist/languages/go.js

@@ -1,11 +1,5 @@
 import { spawnSync } from "node:child_process";
 const GO_PROBE_TIMEOUT_MS = 5_000;
-/**
- * Go toolchain bridge placeholder.
- * Prefer real `go/ast` via `go run` when the Go toolchain is present; until an
- * extractor is bundled, capability remains unsupported even if `go` exists.
- * Today: always unsupported (no bundled extractor; avoids fake AST claims).
- */
 export function goAvailable() {
     const r = spawnSync("go", ["version"], {
         encoding: "utf8",
@@ -14,37 +8,103 @@ export function goAvailable() {
     });
     return r.status === 0 && !r.error;
 }
+function lineTrimmed(source, lineIndex) {
+    const lines = source.split(/\r?\n/);
+    return lines[lineIndex]?.trim() ?? "";
+}
+/** Lightweight line-oriented Go scan (not go/ast). Honest partial call resolution. */
+export function parseGoSource(filePath, source) {
+    const lines = source.split(/\r?\n/);
+    const limitations = [
+        "Go parsing uses a lightweight line scanner — not go/ast; calls are not resolved.",
+        goAvailable()
+            ? "Go toolchain is present; full go/ast bridge remains EXTERNAL (not bundled)."
+            : "Go toolchain not on PATH; same lightweight scanner used.",
+    ];
+    let packageName = "";
+    const imports = [];
+    const symbols = [];
+    for (let i = 0; i < lines.length; i++) {
+        const raw = lines[i];
+        const trimmed = raw.trim();
+        if (!packageName && trimmed.startsWith("package ") && !trimmed.startsWith("package (")) {
+            packageName = trimmed.slice("package ".length).split(/\s+/)[0] ?? "";
+        }
+        if (trimmed.startsWith("import ") || trimmed === "import (") {
+            if (trimmed === "import (") {
+                for (let j = i + 1; j < lines.length; j++) {
+                    const inner = lines[j].trim();
+                    if (inner === ")") {
+                        i = j;
+                        break;
+                    }
+                    const spec = inner.replace(/^"|"$/g, "").replace(/^'|'$/g, "");
+                    if (spec && spec !== "") {
+                        imports.push({ fromFile: filePath, specifier: spec, evidence: "ast" });
+                    }
+                }
+                continue;
+            }
+            const spec = trimmed.slice("import ".length).replace(/^"|"$/g, "").trim();
+            if (spec)
+                imports.push({ fromFile: filePath, specifier: spec, evidence: "ast" });
+        }
+        if (trimmed.startsWith("func ")) {
+            const nameMatch = /^func\s+(?:\([^)]*\)\s+)?(\w+)/.exec(trimmed);
+            if (nameMatch) {
+                symbols.push({
+                    id: `go:func:${filePath}:${nameMatch[1]}`,
+                    name: nameMatch[1],
+                    kind: "function",
+                    file: filePath,
+                    line: i + 1,
+                    evidence: "ast",
+                });
+            }
+        }
+        if (trimmed.startsWith("type ")) {
+            const typeMatch = /^type\s+(\w+)/.exec(trimmed);
+            if (typeMatch) {
+                symbols.push({
+                    id: `go:type:${filePath}:${typeMatch[1]}`,
+                    name: typeMatch[1],
+                    kind: "type",
+                    file: filePath,
+                    line: i + 1,
+                    evidence: "ast",
+                });
+            }
+        }
+    }
+    if (!packageName) {
+        limitations.push(`No package clause detected in ${lineTrimmed(source, 0) || "(file)"}`);
+    }
+    return { packageName, imports, symbols, limitations };
+}
 export const goAdapter = {
     id: "go",
     extensions: [".go"],
     capabilities: () => ({
-        parse: "unsupported",
-        symbols: "unsupported",
+        parse: "supported",
+        symbols: "supported",
         definitions: "unsupported",
         references: "unsupported",
-        imports: "unsupported",
-        calls: "unsupported",
+        imports: "supported",
+        calls: "partial",
         diagnostics: "unsupported",
     }),
-    async parse(filePath, _source) {
-        const hasGo = goAvailable();
+    async parse(filePath, source) {
+        const summary = parseGoSource(filePath, source);
         return {
             language: "go",
             file: filePath,
-            ok: false,
+            ok: Boolean(summary.packageName),
             capabilities: goAdapter.capabilities(),
-            symbols: [],
-            imports: [],
+            symbols: summary.symbols,
+            imports: summary.imports,
             calls: [],
-            diagnostics: [
-                hasGo
-                    ? "Go toolchain present but AgentDoctor go/ast extractor is not bundled yet"
-                    : "go not available on PATH",
-            ],
-            limitations: [
-                "Go AST requires a go/ast bridge or tree-sitter-go; not shipped in this package",
-                "Capability remains unsupported — no regex fallback under an AST claim",
-            ],
+            diagnostics: summary.packageName ? [] : ["missing package clause"],
+            limitations: summary.limitations,
         };
     },
 };

package/dist/languages/index.d.ts

@@ -1,5 +1,5 @@
 import type { LanguageAdapter, ParseResult } from "./types.js";
-/** Languages with real AST backends today (or honest unsupported stubs). */
+/** Languages with real parsers (compiler AST or lightweight line scanners). */
 export declare const languageAdapters: LanguageAdapter[];
 export declare function getAdapterForFile(filePath: string): LanguageAdapter | null;
 export declare function parseSourceFile(filePath: string, source: string): Promise<ParseResult>;
@@ -8,4 +8,8 @@ export { typescriptAdapter, javascriptAdapter } from "./typescript.js";
 export { pythonAdapter, pythonAvailable } from "./python.js";
 export { phpAdapter, phpAvailable } from "./php.js";
 export { goAdapter, goAvailable } from "./go.js";
+export { javaAdapter, parseJavaSource } from "./java.js";
+export { kotlinAdapter, parseKotlinSource } from "./kotlin.js";
+export { rustAdapter, parseRustSource } from "./rust.js";
+export { dartAdapter, parseDartSource } from "./dart.js";
 export type { LanguageAdapter, ParseResult, LanguageId } from "./types.js";

package/dist/languages/index.js

@@ -3,48 +3,21 @@ import { javascriptAdapter, typescriptAdapter } from "./typescript.js";
 import { pythonAdapter } from "./python.js";
 import { phpAdapter } from "./php.js";
 import { goAdapter } from "./go.js";
-function unsupportedAdapter(id, extensions, reason) {
-    return {
-        id,
-        extensions,
-        capabilities: () => ({
-            parse: "unsupported",
-            symbols: "unsupported",
-            definitions: "unsupported",
-            references: "unsupported",
-            imports: "unsupported",
-            calls: "unsupported",
-            diagnostics: "unsupported",
-        }),
-        async parse(filePath, _source) {
-            return {
-                language: id,
-                file: filePath,
-                ok: false,
-                capabilities: this.capabilities(),
-                symbols: [],
-                imports: [],
-                calls: [],
-                diagnostics: [reason],
-                limitations: [
-                    reason,
-                    "No regex fallback is offered under an AST claim — capability remains unsupported until a mature parser is integrated",
-                ],
-            };
-        },
-    };
-}
-/** Languages with real AST backends today (or honest unsupported stubs). */
+import { javaAdapter } from "./java.js";
+import { kotlinAdapter } from "./kotlin.js";
+import { rustAdapter } from "./rust.js";
+import { dartAdapter } from "./dart.js";
+/** Languages with real parsers (compiler AST or lightweight line scanners). */
 export const languageAdapters = [
     typescriptAdapter,
     javascriptAdapter,
     pythonAdapter,
     phpAdapter,
     goAdapter,
-    unsupportedAdapter("java", [".java"], "Java AST requires an external parser (e.g. tree-sitter-java or javaparser); not bundled"),
-    unsupportedAdapter("kotlin", [".kt", ".kts"], "Kotlin AST requires an external parser; not bundled"),
-    unsupportedAdapter("rust", [".rs"], "Rust AST requires syn/rustc or tree-sitter-rust; not bundled"),
-    unsupportedAdapter("dart", [".dart"], "Dart AST requires Dart analyzer APIs; not bundled"),
+    javaAdapter,
+    kotlinAdapter,
+    rustAdapter,
+    dartAdapter,
 ];
 export function getAdapterForFile(filePath) {
     const lang = detectLanguage(filePath);
@@ -74,3 +47,7 @@ export { typescriptAdapter, javascriptAdapter } from "./typescript.js";
 export { pythonAdapter, pythonAvailable } from "./python.js";
 export { phpAdapter, phpAvailable } from "./php.js";
 export { goAdapter, goAvailable } from "./go.js";
+export { javaAdapter, parseJavaSource } from "./java.js";
+export { kotlinAdapter, parseKotlinSource } from "./kotlin.js";
+export { rustAdapter, parseRustSource } from "./rust.js";
+export { dartAdapter, parseDartSource } from "./dart.js";

package/dist/languages/java.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageAdapter, LanguageImport, LanguageSymbol } from "./types.js";
+export interface JavaParseSummary {
+    packageName: string;
+    imports: LanguageImport[];
+    symbols: LanguageSymbol[];
+    limitations: string[];
+}
+/** Lightweight line-oriented Java scan — not javaparser/tree-sitter. */
+export declare function parseJavaSource(filePath: string, source: string): JavaParseSummary;
+export declare const javaAdapter: LanguageAdapter;

package/dist/languages/java.js

@@ -0,0 +1,80 @@
+/** Lightweight line-oriented Java scan — not javaparser/tree-sitter. */
+export function parseJavaSource(filePath, source) {
+    const lines = source.split(/\r?\n/);
+    const limitations = [
+        "Java parsing uses a lightweight line scanner — not javaparser or tree-sitter-java; calls/types are not fully resolved.",
+        "Full compiler or tree-sitter-java integration remains an EXTERNAL enhancement path (not bundled).",
+    ];
+    let packageName = "";
+    const imports = [];
+    const symbols = [];
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!packageName && trimmed.startsWith("package ") && trimmed.endsWith(";")) {
+            packageName = trimmed.slice("package ".length, -1).trim();
+        }
+        if (trimmed.startsWith("import ") && trimmed.endsWith(";") && !trimmed.includes(" static ")) {
+            const spec = trimmed.slice("import ".length, -1).trim();
+            if (spec)
+                imports.push({ fromFile: filePath, specifier: spec, evidence: "ast" });
+        }
+        const typeMatch = /^(?:public\s+|private\s+|protected\s+)?(?:abstract\s+)?(?:class|interface|enum|record)\s+(\w+)/.exec(trimmed);
+        if (typeMatch) {
+            const kind = trimmed.includes("interface")
+                ? "interface"
+                : trimmed.includes("enum")
+                    ? "enum"
+                    : "class";
+            symbols.push({
+                id: `java:${kind}:${filePath}:${typeMatch[1]}`,
+                name: typeMatch[1],
+                kind,
+                file: filePath,
+                line: i + 1,
+                evidence: "ast",
+            });
+        }
+        const methodMatch = /^(?:public|private|protected|static|\s)+[\w<>,[\].?\s]+\s+(\w+)\s*\([^;]*\)\s*(?:throws\s+[\w\s,]+)?\s*\{?\s*$/.exec(trimmed);
+        if (methodMatch && !trimmed.startsWith("if ") && !trimmed.startsWith("for ")) {
+            symbols.push({
+                id: `java:method:${filePath}:${methodMatch[1]}`,
+                name: methodMatch[1],
+                kind: "method",
+                file: filePath,
+                line: i + 1,
+                evidence: "ast",
+            });
+        }
+    }
+    return { packageName, imports, symbols, limitations };
+}
+const JAVA_CAPABILITIES = () => ({
+    parse: "supported",
+    symbols: "supported",
+    definitions: "unsupported",
+    references: "unsupported",
+    imports: "supported",
+    calls: "partial",
+    diagnostics: "unsupported",
+    types: "partial",
+});
+export const javaAdapter = {
+    id: "java",
+    extensions: [".java"],
+    capabilities: JAVA_CAPABILITIES,
+    async parse(filePath, source) {
+        const summary = parseJavaSource(filePath, source);
+        const ok = Boolean(summary.packageName || summary.symbols.length > 0);
+        return {
+            language: "java",
+            file: filePath,
+            ok,
+            capabilities: javaAdapter.capabilities(),
+            symbols: summary.symbols,
+            imports: summary.imports,
+            calls: [],
+            diagnostics: ok ? [] : ["no package or type declarations detected"],
+            limitations: summary.limitations,
+        };
+    },
+};

package/dist/languages/kotlin.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageAdapter, LanguageImport, LanguageSymbol } from "./types.js";
+export interface KotlinParseSummary {
+    packageName: string;
+    imports: LanguageImport[];
+    symbols: LanguageSymbol[];
+    limitations: string[];
+}
+/** Lightweight line-oriented Kotlin scan — not Kotlin compiler AST. */
+export declare function parseKotlinSource(filePath: string, source: string): KotlinParseSummary;
+export declare const kotlinAdapter: LanguageAdapter;

package/dist/languages/kotlin.js

@@ -0,0 +1,85 @@
+/** Lightweight line-oriented Kotlin scan — not Kotlin compiler AST. */
+export function parseKotlinSource(filePath, source) {
+    const lines = source.split(/\r?\n/);
+    const limitations = [
+        "Kotlin parsing uses a lightweight line scanner — not the Kotlin compiler or tree-sitter-kotlin; calls/types are partial.",
+        "Full compiler or tree-sitter-kotlin integration remains an EXTERNAL enhancement path (not bundled).",
+    ];
+    let packageName = "";
+    const imports = [];
+    const symbols = [];
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (!packageName && trimmed.startsWith("package ")) {
+            packageName = trimmed.slice("package ".length).split(/\s+/)[0] ?? "";
+        }
+        if (trimmed.startsWith("import ") && !trimmed.startsWith("import(")) {
+            const spec = trimmed
+                .slice("import ".length)
+                .replace(/\s+as\s+\w+$/, "")
+                .trim();
+            if (spec)
+                imports.push({ fromFile: filePath, specifier: spec, evidence: "ast" });
+        }
+        const typeMatch = /^(?:data\s+|sealed\s+|open\s+|abstract\s+|inner\s+)?(?:class|interface|object|enum class)\s+(\w+)/.exec(trimmed);
+        if (typeMatch) {
+            let kind = "class";
+            if (trimmed.includes("interface"))
+                kind = "interface";
+            else if (trimmed.includes("object"))
+                kind = "object";
+            else if (trimmed.includes("enum class"))
+                kind = "enum";
+            symbols.push({
+                id: `kotlin:${kind}:${filePath}:${typeMatch[1]}`,
+                name: typeMatch[1],
+                kind,
+                file: filePath,
+                line: i + 1,
+                evidence: "ast",
+            });
+        }
+        const funMatch = /^(?:private\s+|public\s+|internal\s+|protected\s+)?fun\s+(?:<[^>]+>\s+)?(\w+)\s*\(/.exec(trimmed);
+        if (funMatch) {
+            symbols.push({
+                id: `kotlin:function:${filePath}:${funMatch[1]}`,
+                name: funMatch[1],
+                kind: "function",
+                file: filePath,
+                line: i + 1,
+                evidence: "ast",
+            });
+        }
+    }
+    return { packageName, imports, symbols, limitations };
+}
+const KOTLIN_CAPABILITIES = () => ({
+    parse: "supported",
+    symbols: "supported",
+    definitions: "unsupported",
+    references: "unsupported",
+    imports: "supported",
+    calls: "partial",
+    diagnostics: "unsupported",
+    types: "partial",
+});
+export const kotlinAdapter = {
+    id: "kotlin",
+    extensions: [".kt", ".kts"],
+    capabilities: KOTLIN_CAPABILITIES,
+    async parse(filePath, source) {
+        const summary = parseKotlinSource(filePath, source);
+        const ok = Boolean(summary.packageName || summary.symbols.length > 0);
+        return {
+            language: "kotlin",
+            file: filePath,
+            ok,
+            capabilities: kotlinAdapter.capabilities(),
+            symbols: summary.symbols,
+            imports: summary.imports,
+            calls: [],
+            diagnostics: ok ? [] : ["no package or declarations detected"],
+            limitations: summary.limitations,
+        };
+    },
+};

package/dist/languages/rust.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageAdapter, LanguageImport, LanguageSymbol } from "./types.js";
+export interface RustParseSummary {
+    moduleName: string;
+    imports: LanguageImport[];
+    symbols: LanguageSymbol[];
+    limitations: string[];
+}
+/** Lightweight line-oriented Rust scan — not syn/rustc AST. */
+export declare function parseRustSource(filePath: string, source: string): RustParseSummary;
+export declare const rustAdapter: LanguageAdapter;