@mortice/mapwright 0.8.0

package/dist/extractors/python.js

@@ -0,0 +1,314 @@
+import path from "node:path";
+import { readFileSync } from "node:fs";
+import { parseDocTags } from "./docTags.js";
+import { createExternalPackageId, resolvePythonRelativeModuleTarget } from "../catalogue/moduleResolution.js";
+import { truncateEvidenceText } from "../catalogue/evidence.js";
+import { implementationFingerprint, relationshipIdentityId, signatureFingerprint, symbolIdentityId } from "../catalogue/identity.js";
+export function extractPythonSymbols(workspaceRoot, file, packageRecord) {
+    const absolute = path.resolve(workspaceRoot, file.path);
+    const sourceText = readFileSync(absolute, "utf8");
+    const lines = sourceText.split(/\r?\n/);
+    const symbols = [];
+    const relationships = [];
+    const diagnostics = [];
+    const packageId = packageRecord?.id ?? "package:unknown";
+    const modulePath = file.path;
+    const symbolProvenance = file.isGenerated ? "generated_declaration" : "authored_source";
+    const explicitExports = parseDunderAll(lines);
+    const importStatements = [];
+    const stack = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const indent = line.match(/^\s*/)?.[0].length ?? 0;
+        while (stack.length > 0 && indent <= stack[stack.length - 1].indent) {
+            stack.pop();
+        }
+        const classMatch = line.match(/^\s*class\s+([A-Za-z_][A-Za-z0-9_]*)/);
+        const functionMatch = line.match(/^\s*def\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(([^)]*)\)/);
+        if (classMatch || functionMatch) {
+            const isClass = Boolean(classMatch);
+            const name = (classMatch?.[1] ?? functionMatch?.[1] ?? "").trim();
+            const signature = line.trim();
+            const parent = stack[stack.length - 1];
+            const kind = isClass ? "class" : parent?.kind === "class" ? "method" : "function";
+            const containerPath = parent ? (parent.containerPath ? `${parent.containerPath}.${parent.name}` : parent.name) : "";
+            const doc = readDocstring(lines, i + 1, indent);
+            const parsed = doc ? parseDocTags(doc.text, file.path) : { summary: "", tags: [], diagnostics: [] };
+            diagnostics.push(...parsed.diagnostics);
+            const id = symbolIdentityId({
+                language: "python",
+                kind,
+                packageId,
+                modulePath,
+                qualifiedContainerPath: containerPath,
+                declaredName: name
+            });
+            const nameExported = explicitExports ? explicitExports.has(name) : !name.startsWith("_");
+            const exported = !file.isTest && nameExported;
+            const visibility = file.isTest ? "test_only" : exported ? "published" : "private";
+            symbols.push({
+                id,
+                name,
+                qualifiedName: `${file.path}::${name}`,
+                kind,
+                language: "python",
+                filePath: file.path,
+                packageId,
+                modulePath,
+                qualifiedContainerPath: containerPath,
+                range: { startLine: i + 1, startColumn: indent + 1 },
+                signature,
+                signatureFingerprint: signatureFingerprint([kind, signature]),
+                implementationFingerprint: implementationFingerprint([kind, signature]),
+                canonicalSymbolId: id,
+                duplicateOf: null,
+                symbolProvenance,
+                visibility,
+                exported,
+                doc: {
+                    present: Boolean(doc),
+                    text: parsed.summary,
+                    tags: parsed.tags
+                },
+                capabilities: parsed.tags.filter((t) => t.tag === "capability").map((t) => t.value),
+                parents: parent ? [parent.id] : [],
+                children: [],
+                confidence: 0.8,
+                provenance: { source: "python-static", extractors: ["python"] }
+            });
+            file.symbols.push(id);
+            relationships.push({
+                id: relationshipIdentityId({
+                    type: "defines",
+                    fromKind: "file",
+                    fromId: file.path,
+                    toKind: "symbol",
+                    toId: id,
+                    discriminant: null
+                }),
+                type: "defines",
+                from: { kind: "file", id: file.path },
+                to: { kind: "symbol", id },
+                confidence: 1,
+                provenance: { source: "python-static" }
+            });
+            if (exported) {
+                relationships.push({
+                    id: relationshipIdentityId({
+                        type: "exports",
+                        fromKind: "file",
+                        fromId: file.path,
+                        toKind: "symbol",
+                        toId: id,
+                        discriminant: explicitExports ? "__all__" : null
+                    }),
+                    type: "exports",
+                    from: { kind: "file", id: file.path },
+                    to: { kind: "symbol", id },
+                    localDiscriminant: explicitExports ? "__all__" : null,
+                    evidence: { filePath: file.path, startLine: i + 1, endLine: i + 1, text: truncateEvidenceText(signature) },
+                    confidence: explicitExports ? 0.95 : 0.7,
+                    provenance: { source: "python-static" }
+                });
+            }
+            if (parent) {
+                const parentSymbol = symbols.find((s) => s.id === parent.id);
+                parentSymbol?.children.push(id);
+                relationships.push({
+                    id: relationshipIdentityId({
+                        type: "contains",
+                        fromKind: "symbol",
+                        fromId: parent.id,
+                        toKind: "symbol",
+                        toId: id,
+                        discriminant: null
+                    }),
+                    type: "contains",
+                    from: { kind: "symbol", id: parent.id },
+                    to: { kind: "symbol", id },
+                    confidence: 0.9,
+                    provenance: { source: "python-static" }
+                });
+            }
+            stack.push({ indent, id, kind: isClass ? "class" : "function", name, containerPath });
+        }
+        const fromImportMatch = line.match(/^\s*from\s+([.A-Za-z_][A-Za-z0-9_.]*)\s+import\s+(.+)$/);
+        if (fromImportMatch) {
+            const moduleSpecifier = fromImportMatch[1]?.trim() ?? "";
+            const importedNames = fromImportMatch[2]
+                .split(",")
+                .map((part) => part.trim())
+                .filter(Boolean)
+                .map((part) => part.split(/\s+as\s+/i)[0]?.trim() ?? part);
+            importStatements.push({
+                moduleSpecifier,
+                importedNames,
+                startLine: i + 1,
+                text: line.trim(),
+                importKind: moduleSpecifier.startsWith(".") ? "relative" : "absolute"
+            });
+            continue;
+        }
+        const importMatch = line.match(/^\s*import\s+([A-Za-z_][A-Za-z0-9_.]*)(?:\s+as\s+[A-Za-z_][A-Za-z0-9_]*)?\s*$/);
+        if (importMatch) {
+            const moduleSpecifier = importMatch[1]?.trim() ?? "";
+            importStatements.push({
+                moduleSpecifier,
+                importedNames: [],
+                startLine: i + 1,
+                text: line.trim(),
+                importKind: moduleSpecifier.startsWith(".") ? "relative" : "absolute"
+            });
+        }
+    }
+    for (const statement of importStatements) {
+        const localTarget = resolvePythonRelativeModuleTarget(workspaceRoot, file.path, statement.moduleSpecifier);
+        if (statement.importKind === "relative") {
+            if (localTarget) {
+                relationships.push({
+                    id: relationshipIdentityId({
+                        type: "imports",
+                        fromKind: "file",
+                        fromId: file.path,
+                        toKind: "file",
+                        toId: localTarget,
+                        discriminant: "relative"
+                    }),
+                    type: "imports",
+                    from: { kind: "file", id: file.path },
+                    to: { kind: "file", id: localTarget },
+                    localDiscriminant: "relative",
+                    evidence: { filePath: file.path, startLine: statement.startLine, endLine: statement.startLine, text: truncateEvidenceText(statement.text) },
+                    confidence: 0.9,
+                    provenance: { source: "python-static" }
+                });
+            }
+            else {
+                diagnostics.push({
+                    id: `diag:${file.path}:${statement.startLine}:unresolved_import:${statement.moduleSpecifier}`,
+                    severity: "warning",
+                    category: "resolution",
+                    code: "unresolved_import",
+                    message: `Unresolved local import ${statement.moduleSpecifier}.`,
+                    filePath: file.path,
+                    range: { startLine: statement.startLine },
+                    target: { kind: "file", id: file.path },
+                    provenance: { source: "python-static" }
+                });
+            }
+            continue;
+        }
+        const externalId = createExternalPackageId(statement.moduleSpecifier);
+        relationships.push({
+            id: relationshipIdentityId({
+                type: "imports",
+                fromKind: "file",
+                fromId: file.path,
+                toKind: "externalPackage",
+                toId: externalId,
+                discriminant: "absolute"
+            }),
+            type: "imports",
+            from: { kind: "file", id: file.path },
+            to: { kind: "externalPackage", id: externalId },
+            localDiscriminant: "absolute",
+            evidence: { filePath: file.path, startLine: statement.startLine, endLine: statement.startLine, text: truncateEvidenceText(statement.text) },
+            confidence: 0.75,
+            provenance: { source: "python-static" }
+        });
+    }
+    return { symbols, relationships, diagnostics };
+}
+/**
+ * Statically parse a literal `__all__ = ["a", "b"]` (or tuple) assignment.
+ * Only literal string lists spanning contiguous lines are recognised; anything
+ * dynamic (concatenation with names, `+=`, function calls) yields no export set.
+ */
+function parseDunderAll(lines) {
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i] ?? "";
+        const match = line.match(/^\s*__all__\s*(?::\s*[^=]+)?=\s*(.*)$/);
+        if (!match) {
+            continue;
+        }
+        let body = match[1] ?? "";
+        // Collect continuation lines until the bracket/paren balance closes.
+        let depth = bracketDelta(body);
+        let cursor = i;
+        while (depth > 0 && cursor + 1 < lines.length) {
+            cursor += 1;
+            const next = lines[cursor] ?? "";
+            body += `\n${next}`;
+            depth += bracketDelta(next);
+        }
+        const open = body.indexOf("[") >= 0 ? "[" : body.indexOf("(") >= 0 ? "(" : undefined;
+        if (!open) {
+            return undefined;
+        }
+        const close = open === "[" ? "]" : ")";
+        const start = body.indexOf(open);
+        const end = body.lastIndexOf(close);
+        if (start < 0 || end < 0 || end <= start) {
+            return undefined;
+        }
+        const inner = body.slice(start + 1, end);
+        // Reject dynamic constructs; only literal string entries are allowed.
+        const withoutStrings = inner.replace(/(["'])(?:\\.|(?!\1).)*\1/g, "").replace(/[\s,]/g, "");
+        if (withoutStrings.length > 0) {
+            return undefined;
+        }
+        const names = new Set();
+        for (const entry of inner.matchAll(/(["'])((?:\\.|(?!\1).)*)\1/g)) {
+            const value = entry[2]?.trim();
+            if (value) {
+                names.add(value);
+            }
+        }
+        return names;
+    }
+    return undefined;
+}
+function bracketDelta(text) {
+    let delta = 0;
+    for (const char of text) {
+        if (char === "[" || char === "(")
+            delta += 1;
+        else if (char === "]" || char === ")")
+            delta -= 1;
+    }
+    return delta;
+}
+function readDocstring(lines, start, parentIndent) {
+    for (let i = start; i < Math.min(start + 6, lines.length); i += 1) {
+        const line = lines[i] ?? "";
+        if (line.trim() === "") {
+            continue;
+        }
+        const indent = line.match(/^\s*/)?.[0].length ?? 0;
+        if (indent <= parentIndent) {
+            return undefined;
+        }
+        const tripleQuote = line.match(/^\s*["']{3}/);
+        if (!tripleQuote) {
+            return undefined;
+        }
+        const quote = line.includes('"""') ? '"""' : "'''";
+        const collected = [];
+        const first = line.substring(line.indexOf(quote) + 3);
+        if (first.includes(quote)) {
+            collected.push(first.substring(0, first.indexOf(quote)));
+            return { text: collected.join("\n") };
+        }
+        collected.push(first);
+        for (let j = i + 1; j < lines.length; j += 1) {
+            const current = lines[j] ?? "";
+            if (current.includes(quote)) {
+                collected.push(current.substring(0, current.indexOf(quote)));
+                return { text: collected.join("\n") };
+            }
+            collected.push(current);
+        }
+        return { text: collected.join("\n") };
+    }
+    return undefined;
+}

package/dist/extractors/typescript.d.ts

@@ -0,0 +1,7 @@
+import type { FileRecord, PackageRecord, RelationshipRecord, SymbolRecord, DiagnosticRecord } from "../catalogue/schema.js";
+export interface TsExtractionResult {
+    symbols: SymbolRecord[];
+    relationships: RelationshipRecord[];
+    diagnostics: DiagnosticRecord[];
+}
+export declare function extractTypeScriptSymbols(workspaceRoot: string, file: FileRecord, packageRecord?: PackageRecord): TsExtractionResult;