commiter-cli 0.3.0__py3-none-any.whl

commiter/scanner.py

@@ -0,0 +1,383 @@
+"""Orchestrator: discovers files, runs extractors, assembles documentation."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from commiter.extractors.base import BaseExtractor
+from commiter.extractors.dependencies import DependencyExtractor
+from commiter.models import RepoDocumentation, APIEndpoint, APICall, Dependency, FileClassification, DBOperation
+from commiter.parser import (
+    parse_file, get_source, find_js_imports,
+    find_nodes_by_type, node_text, resolve_url_from_node, build_constants_from_file,
+)
+from commiter.utils.env_reader import load_env_files
+from commiter.utils.file_classifier import classify_file, detect_repo_frameworks
+from commiter.utils.path_helpers import walk_repo, detect_repo_name
+from commiter.utils.tsconfig_resolver import TSConfigRegistry
+from commiter.handler_index import HandlerIndex
+from commiter.middleware_index import MiddlewareIndex
+from commiter.prefix_index import PrefixIndex
+from commiter.type_index import TypeIndex
+from commiter.wrapper_index import WrapperIndex
+
+
+@dataclass
+class ScanResult:
+    """Extended scan output that includes indexes needed by the architecture format."""
+    doc: RepoDocumentation
+    type_index: TypeIndex
+    middleware_index: MiddlewareIndex
+    file_list: list[str] = field(default_factory=list)
+    alias_resolver: TSConfigRegistry | None = None
+
+
+def _default_extractors() -> list[BaseExtractor]:
+    """Return all available extractors."""
+    # Import here to avoid circular imports when more extractors are added
+    from commiter.extractors.dependencies import DependencyExtractor
+
+    extractors: list[BaseExtractor] = [
+        DependencyExtractor(),
+    ]
+
+    # Conditionally import extractors that may not exist yet
+    try:
+        from commiter.extractors.api_endpoints import APIEndpointExtractor
+        extractors.append(APIEndpointExtractor())
+    except ImportError:
+        pass
+
+    try:
+        from commiter.extractors.api_calls import APICallExtractor
+        extractors.append(APICallExtractor())
+    except ImportError:
+        pass
+
+    try:
+        from commiter.extractors.backend_files import BackendFileExtractor
+        extractors.append(BackendFileExtractor())
+    except ImportError:
+        pass
+
+    try:
+        from commiter.extractors.db_operations import DBOperationExtractor
+        extractors.append(DBOperationExtractor())
+    except ImportError:
+        pass
+
+    return extractors
+
+
+def _scan_repo_full(
+    repo_root: str,
+    extra_excludes: list[str] | None = None,
+    extractors: list[BaseExtractor] | None = None,
+) -> ScanResult:
+    """Scan a single repository and return documentation with indexes.
+
+    This is the internal implementation that preserves indexes for consumers
+    like the architecture output format.
+    """
+    repo_name = detect_repo_name(repo_root)
+    frameworks = detect_repo_frameworks(repo_root)
+    files = walk_repo(repo_root, extra_excludes)
+
+    # Load tsconfig/jsconfig for path alias resolution
+    alias_resolver = TSConfigRegistry(repo_root)
+
+    # Load .env files for environment variable resolution
+    env_vars = load_env_files(repo_root)
+
+    if extractors is None:
+        extractors = _default_extractors()
+
+    doc = RepoDocumentation(
+        repo_name=repo_name,
+        repo_path=repo_root,
+        frameworks=frameworks,
+    )
+
+    languages_seen: set[str] = set()
+    js_family = {"javascript", "typescript", "tsx"}
+
+    # Cache parse results to avoid double-parsing JS/TS files
+    parse_cache: dict[str, tuple] = {}  # file_path -> (tree, language, source)
+
+    # === Pass 1: build wrapper index, type index, and prefix index ===
+    wrapper_idx = WrapperIndex(alias_resolver=alias_resolver, env_vars=env_vars)
+    type_idx = TypeIndex(alias_resolver=alias_resolver)
+    prefix_idx = PrefixIndex()
+    middleware_idx = MiddlewareIndex()
+    handler_idx = HandlerIndex()
+    for file_path in files:
+        parse_result = parse_file(file_path)
+        if parse_result:
+            tree, lang = parse_result
+            source = get_source(file_path)
+            parse_cache[file_path] = (tree, lang, source)
+            # Index wrappers (JS/TS only)
+            if lang in js_family:
+                wrapper_idx.index_file(file_path, tree, source)
+            # Index type definitions (all parseable languages)
+            type_idx.index_file(file_path, tree, source, lang)
+            # Index router/blueprint prefixes
+            prefix_idx.index_file(file_path, tree, source, lang)
+            # Index middleware registrations
+            middleware_idx.index_file(file_path, tree, source, lang)
+            # Index class handler method signatures
+            handler_idx.index_file(file_path, tree, source, lang)
+
+    # Resolve chained wrappers (functions that call other wrapper functions)
+    wrapper_idx.resolve_chains()
+
+    # Make indexes and env vars available to extractors
+    for extractor in extractors:
+        if hasattr(extractor, 'set_type_index'):
+            extractor.set_type_index(type_idx)
+        if hasattr(extractor, 'set_prefix_index'):
+            extractor.set_prefix_index(prefix_idx)
+        if hasattr(extractor, 'set_middleware_index'):
+            extractor.set_middleware_index(middleware_idx)
+        if hasattr(extractor, 'set_handler_index'):
+            extractor.set_handler_index(handler_idx)
+        if hasattr(extractor, 'set_env_vars'):
+            extractor.set_env_vars(env_vars)
+
+    # === Pass 2: run extractors + resolve wrapper calls ===
+    for file_path in files:
+        # Classify the file
+        classification = classify_file(file_path, repo_root)
+        doc.file_classifications.append(classification)
+        if classification.language != "unknown":
+            languages_seen.add(classification.language)
+
+        # Use cached parse result if available, otherwise parse now
+        if file_path in parse_cache:
+            tree, language, source = parse_cache[file_path]
+        else:
+            parse_result = parse_file(file_path)
+            tree = parse_result[0] if parse_result else None
+            language = parse_result[1] if parse_result else None
+
+        # Run each extractor
+        for extractor in extractors:
+            if not extractor.can_handle(file_path, language):
+                continue
+
+            artifacts = extractor.extract(file_path, repo_name, tree=tree, language=language)
+            for artifact in artifacts:
+                if isinstance(artifact, APIEndpoint):
+                    doc.endpoints.append(artifact)
+                elif isinstance(artifact, APICall):
+                    doc.api_calls.append(artifact)
+                elif isinstance(artifact, Dependency):
+                    doc.dependencies.append(artifact)
+                elif isinstance(artifact, FileClassification):
+                    pass  # already added above
+                elif isinstance(artifact, DBOperation):
+                    doc.db_operations.append(artifact)
+
+        # Resolve wrapper function calls in JS/TS files
+        if language in js_family and tree is not None:
+            if file_path not in parse_cache:
+                source = get_source(file_path)
+            else:
+                source = parse_cache[file_path][2]
+
+            caller_constants = build_constants_from_file(tree.root_node, source, env_vars)
+            imports = find_js_imports(tree.root_node, source)
+            for imp in imports:
+                for name in imp.names:
+                    wrappers = wrapper_idx.resolve(name, imp.module_path, file_path)
+                    if not wrappers:
+                        continue
+                    for wrapper in wrappers:
+                        # Try to find actual call sites with resolved arguments
+                        call_sites = _find_wrapper_call_urls(
+                            tree.root_node, source, name, caller_constants,
+                        )
+                        if call_sites:
+                            # Emit one API call per call site with the resolved URL
+                            method = wrapper.api_calls[0].http_method if wrapper.api_calls else "GET"
+                            for call_line, call_url in call_sites:
+                                doc.api_calls.append(APICall(
+                                    repo=repo_name,
+                                    file_path=file_path,
+                                    line=call_line,
+                                    component_or_page=Path(file_path).stem,
+                                    http_method=method,
+                                    url_pattern=call_url,
+                                    client_library="fetch",
+                                    traced_from=f"{name}() in {Path(wrapper.file_path).name}:{wrapper.line}",
+                                ))
+                        else:
+                            # Fallback: use wrapper definition URLs (existing behavior)
+                            for api_call in wrapper.api_calls:
+                                doc.api_calls.append(APICall(
+                                    repo=repo_name,
+                                    file_path=file_path,
+                                    line=imp.line,
+                                    component_or_page=Path(file_path).stem,
+                                    http_method=api_call.http_method,
+                                    url_pattern=api_call.url_pattern,
+                                    client_library="fetch",
+                                    traced_from=f"{name}() in {Path(wrapper.file_path).name}:{wrapper.line}",
+                                ))
+
+    doc.languages = sorted(languages_seen)
+
+    # Post-processing: link DB tables to endpoints
+    _link_db_to_endpoints(doc)
+
+    return ScanResult(
+        doc=doc,
+        type_index=type_idx,
+        middleware_index=middleware_idx,
+        file_list=files,
+        alias_resolver=alias_resolver,
+    )
+
+
+def scan_repo(
+    repo_root: str,
+    extra_excludes: list[str] | None = None,
+    extractors: list[BaseExtractor] | None = None,
+) -> RepoDocumentation:
+    """Scan a single repository and return its documentation.
+
+    Args:
+        repo_root: Path to the repository root.
+        extra_excludes: Additional path patterns to exclude.
+        extractors: Override the default set of extractors.
+    """
+    return _scan_repo_full(repo_root, extra_excludes, extractors).doc
+
+
+
+def _find_wrapper_call_urls(root_node, source, func_name, constants):
+    """Find call expressions for a wrapper function and extract the first URL argument.
+
+    Returns a list of (line_number, resolved_url) for each call site where
+    the first argument is a string or template literal that resolves to a URL.
+    """
+    results = []
+    for call in find_nodes_by_type(root_node, 'call_expression'):
+        func = call.child_by_field_name('function')
+        if not func or node_text(func, source) != func_name:
+            continue
+
+        args = call.child_by_field_name('arguments')
+        if not args:
+            continue
+
+        # Extract first string-like argument as the URL path
+        for arg in args.children:
+            if arg.type in ('string', 'template_string', 'binary_expression'):
+                url = resolve_url_from_node(arg, source, constants)
+                if url:
+                    results.append((call.start_point[0] + 1, url))
+                break
+    return results
+
+
+_UNRESOLVED_URL_RE = re.compile(r':\d+:\w+|(?<![/]):[a-z]{2,}$')
+
+
+def _is_unresolved_url(url: str) -> bool:
+    """Check if a URL contains unresolved function parameter placeholders.
+
+    Detects patterns like 'http://localhost:5000:path' where :path is a
+    function parameter that wasn't resolved, as opposed to route params
+    like ':id' or ':userId' which appear after a slash.
+    """
+    return bool(_UNRESOLVED_URL_RE.search(url))
+
+
+def _link_db_to_endpoints(doc: RepoDocumentation) -> None:
+    """Associate DB table names with the endpoints whose handler contains them.
+
+    Uses line ranges: a DB operation belongs to an endpoint if it falls between
+    that endpoint's line and the next endpoint's start line in the same file.
+    Falls back to same-file grouping for files with only one endpoint.
+    """
+    ops_by_file: dict[str, list[DBOperation]] = {}
+    for op in doc.db_operations:
+        ops_by_file.setdefault(op.file_path, []).append(op)
+
+    # Group endpoints by file and sort by line number
+    endpoints_by_file: dict[str, list[APIEndpoint]] = {}
+    for ep in doc.endpoints:
+        endpoints_by_file.setdefault(ep.file_path, []).append(ep)
+
+    for file_path, file_endpoints in endpoints_by_file.items():
+        file_ops = ops_by_file.get(file_path, [])
+        if not file_ops:
+            continue
+
+        sorted_eps = sorted(file_endpoints, key=lambda e: e.line)
+
+        for i, endpoint in enumerate(sorted_eps):
+            start_line = endpoint.line
+            # End line is the start of the next endpoint (or end of file)
+            if i + 1 < len(sorted_eps):
+                end_line = sorted_eps[i + 1].line
+            else:
+                end_line = float("inf")
+
+            # Find DB operations within this endpoint's line range
+            tables = set()
+            for op in file_ops:
+                if start_line <= op.line < end_line:
+                    tables.add(op.table_name)
+
+            if tables:
+                endpoint.db_tables = sorted(tables)
+
+
+def scan_repos(
+    repo_roots: list[str],
+    extra_excludes: list[str] | None = None,
+) -> list[RepoDocumentation]:
+    """Scan multiple repositories and correlate cross-repo relationships."""
+    docs = []
+    for root in repo_roots:
+        docs.append(scan_repo(root, extra_excludes))
+
+    # Cross-repo correlation
+    if len(docs) > 1:
+        from commiter.correlator import correlate
+        relationships = correlate(docs)
+        # Distribute relationships to source repos
+        for rel in relationships:
+            for doc in docs:
+                if doc.repo_name == rel.source_repo:
+                    doc.service_relationships.append(rel)
+                    break
+
+    return docs
+
+
+def scan_repos_full(
+    repo_roots: list[str],
+    extra_excludes: list[str] | None = None,
+) -> list[ScanResult]:
+    """Scan multiple repositories with full index access for architecture output."""
+    results = []
+    for root in repo_roots:
+        results.append(_scan_repo_full(root, extra_excludes))
+
+    # Cross-repo correlation
+    docs = [r.doc for r in results]
+    if len(docs) > 1:
+        from commiter.correlator import correlate
+        relationships = correlate(docs)
+        for rel in relationships:
+            for doc in docs:
+                if doc.repo_name == rel.source_repo:
+                    doc.service_relationships.append(rel)
+                    break
+
+    return results

commiter/type_index.py

@@ -0,0 +1,304 @@
+"""Cross-file type index: resolves type/interface definitions across files.
+
+Mirrors the WrapperIndex pattern — indexes all type definitions in Pass 1,
+then resolves type references from other files in Pass 2.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from commiter.parser import (
+    TypeField,
+    find_ts_interface_fields,
+    find_ts_enum_declarations,
+    find_ts_type_aliases,
+    find_ts_const_objects,
+    find_js_re_exports,
+    find_py_class_fields,
+    extract_type_parameters,
+    find_nodes_by_type,
+    node_text,
+    JSReExport,
+)
+
+if TYPE_CHECKING:
+    from tree_sitter import Tree
+    from commiter.utils.tsconfig_resolver import TSConfigResolver
+
+# Extensions to try when resolving import paths
+RESOLVE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.js", "/index.tsx"]
+
+# Python class base classes that indicate a type definition worth indexing
+PY_TYPE_BASES = {"BaseModel", "Schema", "TypedDict"}
+
+
+@dataclass
+class TypeDefinition:
+    """A type/interface/class/enum definition found in a source file."""
+    name: str
+    file_path: str
+    line: int
+    fields: list[TypeField]
+    language: str
+    kind: str = "interface"  # "interface" | "enum" | "type_alias" | "const"
+    generic_params: list[str] = field(default_factory=list)  # ["T"], ["T", "U"]
+
+
+class TypeIndex:
+    """Index of type definitions across all files in a repository.
+
+    Usage:
+        idx = TypeIndex(alias_resolver=resolver)
+        # Pass 1: index all files
+        for path in files:
+            idx.index_file(path, tree, source, language)
+        # Pass 2: resolve types from other files
+        typedef = idx.resolve("CreateUserBody", "../types/api", "/project/routes/users.ts")
+    """
+
+    def __init__(self, alias_resolver: "TSConfigResolver | None" = None) -> None:
+        # type_name -> list of definitions (same name can exist in multiple files)
+        self._types: dict[str, list[TypeDefinition]] = {}
+        # normalized absolute path (no extension) -> actual absolute path
+        self._indexed_paths: dict[str, str] = {}
+        self._alias_resolver = alias_resolver
+        # barrel file re-export cache: abs_path -> list[JSReExport]
+        self._re_exports: dict[str, list[JSReExport]] = {}
+
+    def index_file(self, file_path: str, tree: "Tree", source: bytes, language: str) -> None:
+        """Pass 1: extract all type definitions from a file."""
+        abs_path = os.path.abspath(file_path)
+
+        # Store path for import resolution
+        stem = _strip_extension(abs_path)
+        self._indexed_paths[stem] = abs_path
+        if Path(abs_path).stem == "index":
+            self._indexed_paths[str(Path(abs_path).parent)] = abs_path
+
+        if language in ("typescript", "tsx", "javascript"):
+            # Cache re-exports for barrel file resolution
+            re_exports = find_js_re_exports(tree.root_node, source)
+            if re_exports:
+                self._re_exports[abs_path] = re_exports
+            self._index_ts_file(abs_path, tree, source, language)
+        elif language == "python":
+            self._index_py_file(abs_path, tree, source)
+
+    def _index_ts_file(self, abs_path: str, tree: "Tree", source: bytes, language: str) -> None:
+        """Index TypeScript/JavaScript interfaces, enums, type aliases, and const objects."""
+        root = tree.root_node
+
+        # Build a map of type name -> generic params from declarations
+        generic_params_map = self._extract_all_generic_params(root, source)
+
+        # Interfaces
+        for name, fields in find_ts_interface_fields(root, source).items():
+            line = self._find_type_line(root, source, name)
+            self._types.setdefault(name, []).append(TypeDefinition(
+                name=name, file_path=abs_path, line=line,
+                fields=fields, language=language, kind="interface",
+                generic_params=generic_params_map.get(name, []),
+            ))
+
+        # Enums
+        for name, members in find_ts_enum_declarations(root, source).items():
+            line = self._find_type_line(root, source, name)
+            self._types.setdefault(name, []).append(TypeDefinition(
+                name=name, file_path=abs_path, line=line,
+                fields=members, language=language, kind="enum",
+            ))
+
+        # Type aliases
+        for name, fields in find_ts_type_aliases(root, source).items():
+            line = self._find_type_line(root, source, name)
+            self._types.setdefault(name, []).append(TypeDefinition(
+                name=name, file_path=abs_path, line=line,
+                fields=fields, language=language, kind="type_alias",
+                generic_params=generic_params_map.get(name, []),
+            ))
+
+        # Const objects (as const)
+        for name, fields in find_ts_const_objects(root, source).items():
+            line = self._find_type_line(root, source, name)
+            self._types.setdefault(name, []).append(TypeDefinition(
+                name=name, file_path=abs_path, line=line,
+                fields=fields, language=language, kind="const",
+            ))
+
+    def _extract_all_generic_params(self, root, source: bytes) -> dict[str, list[str]]:
+        """Extract generic parameters for all interfaces and type aliases in a file."""
+        result: dict[str, list[str]] = {}
+        for child in root.children:
+            target = child
+            if child.type == "export_statement":
+                for sub in child.children:
+                    if sub.type in ("interface_declaration", "type_alias_declaration"):
+                        target = sub
+                        break
+            if target.type in ("interface_declaration", "type_alias_declaration"):
+                name_node = target.child_by_field_name("name")
+                if name_node:
+                    name = node_text(name_node, source)
+                    params = extract_type_parameters(target, source)
+                    if params:
+                        result[name] = params
+        return result
+
+    def _index_py_file(self, abs_path: str, tree: "Tree", source: bytes) -> None:
+        """Index Python class definitions (Pydantic, TypedDict, dataclasses)."""
+        import re
+        text = source.decode("utf-8", errors="replace")
+        for match in re.finditer(r'class\s+(\w+)\s*\([^)]*(?:' + '|'.join(PY_TYPE_BASES) + r')', text):
+            class_name = match.group(1)
+            fields = find_py_class_fields(tree.root_node, source, class_name)
+            if fields:
+                line = text[:match.start()].count("\n") + 1
+                self._types.setdefault(class_name, []).append(TypeDefinition(
+                    name=class_name,
+                    file_path=abs_path,
+                    line=line,
+                    fields=fields,
+                    language="python",
+                ))
+
+    def resolve(self, type_name: str, import_path: str | None, caller_file: str) -> TypeDefinition | None:
+        """Pass 2: resolve a type reference to its definition.
+
+        Args:
+            type_name: The type/interface name (e.g. "CreateUserBody").
+            import_path: The import module path (e.g. "../types/api", "@/types"), or None.
+            caller_file: Absolute path of the file that references the type.
+
+        Returns:
+            The TypeDefinition if found, None otherwise.
+        """
+        if type_name not in self._types:
+            return None
+
+        # If no import path, return first match (best effort)
+        if import_path is None:
+            return self._types[type_name][0] if self._types[type_name] else None
+
+        resolved_path = self._resolve_import_path(import_path, caller_file)
+        if resolved_path is None:
+            # Fallback: return first match
+            return self._types[type_name][0] if self._types[type_name] else None
+
+        # Filter to definitions in the resolved file
+        for typedef in self._types[type_name]:
+            if typedef.file_path == resolved_path:
+                return typedef
+
+        # Barrel file fallback: check if resolved_path re-exports this type
+        actual_path = self._resolve_through_barrel(type_name, resolved_path)
+        if actual_path:
+            for typedef in self._types[type_name]:
+                if typedef.file_path == actual_path:
+                    return typedef
+
+        return None
+
+    def resolve_local(self, type_name: str, file_path: str) -> TypeDefinition | None:
+        """Look up a type defined in the same file."""
+        if type_name not in self._types:
+            return None
+        abs_path = os.path.abspath(file_path)
+        for typedef in self._types[type_name]:
+            if typedef.file_path == abs_path:
+                return typedef
+        return None
+
+    def _resolve_through_barrel(self, name: str, barrel_path: str) -> str | None:
+        """Follow re-exports in a barrel file to find the actual source file."""
+        re_exports = self._re_exports.get(barrel_path)
+        if not re_exports:
+            return None
+
+        barrel_dir = str(Path(barrel_path).parent)
+
+        for re_export in re_exports:
+            if name not in re_export.names and "*" not in re_export.names:
+                continue
+
+            target_base = os.path.normpath(os.path.join(barrel_dir, re_export.module_path))
+            target_stem = _strip_extension(target_base)
+
+            if target_stem in self._indexed_paths:
+                return self._indexed_paths[target_stem]
+
+            for ext in RESOLVE_EXTENSIONS:
+                candidate_stem = _strip_extension(target_base + ext)
+                if candidate_stem in self._indexed_paths:
+                    return self._indexed_paths[candidate_stem]
+
+        return None
+
+    def _resolve_import_path(self, import_path: str, caller_file: str) -> str | None:
+        """Resolve an import path to an absolute file path."""
+        if import_path.startswith("."):
+            # Relative import
+            caller_dir = str(Path(os.path.abspath(caller_file)).parent)
+            base = os.path.normpath(os.path.join(caller_dir, import_path))
+        elif self._alias_resolver:
+            # Try tsconfig alias
+            resolved = self._alias_resolver.resolve(import_path, caller_file)
+            if resolved:
+                return resolved
+            return None
+        else:
+            # Python relative imports: .schemas -> schemas.py in same dir
+            if import_path.startswith("."):
+                caller_dir = str(Path(os.path.abspath(caller_file)).parent)
+                # Count leading dots for relative depth
+                dots = len(import_path) - len(import_path.lstrip("."))
+                module = import_path[dots:].replace(".", "/")
+                parent = Path(caller_dir)
+                for _ in range(dots - 1):
+                    parent = parent.parent
+                base = str(parent / module)
+            else:
+                return None
+
+        # Try matching indexed paths
+        stem = _strip_extension(base)
+        if stem in self._indexed_paths:
+            return self._indexed_paths[stem]
+
+        # Try with extensions
+        for ext in RESOLVE_EXTENSIONS:
+            candidate = base + ext
+            candidate_stem = _strip_extension(candidate)
+            if candidate_stem in self._indexed_paths:
+                return self._indexed_paths[candidate_stem]
+
+        # Python: try .py extension
+        py_candidate = base + ".py"
+        if os.path.isfile(py_candidate):
+            return os.path.abspath(py_candidate)
+
+        return None
+
+    def _find_type_line(self, root_node, source: bytes, type_name: str) -> int:
+        """Find the line number of a type definition."""
+        from commiter.parser import find_nodes_by_type
+        for node in find_nodes_by_type(root_node, "interface_declaration"):
+            name_node = node.child_by_field_name("name")
+            if name_node and node_text(name_node, source) == type_name:
+                return node.start_point[0] + 1
+        return 0
+
+    @property
+    def type_count(self) -> int:
+        return sum(len(defs) for defs in self._types.values())
+
+
+def _strip_extension(path: str) -> str:
+    """Strip JS/TS/Python file extensions from a path."""
+    p = Path(path)
+    while p.suffix in (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py"):
+        p = p.with_suffix("")
+    return str(p)