blasttrace 1.2.0__py2.py3-none-any.whl

blasttrace/parsers/sql_schema_parser.py

@@ -0,0 +1,376 @@
+"""
+BlastTrace Database & Schema Parser
+Parses SQL migrations/schemas (.sql), Prisma (schema.prisma), Drizzle ORM, and SQLAlchemy/Django ORM models
+for the Full-Stack Contract Topology Engine.
+"""
+
+import os
+import re
+from typing import Dict, Any, List
+
+
+_SQL_KEYWORDS = {
+    "CONSTRAINT", "PRIMARY", "FOREIGN", "UNIQUE", "CHECK", "INDEX",
+    "KEY", "REFERENCES", "CREATE", "ALTER", "DROP", "TABLE", "IF", "NOT", "EXISTS"
+}
+
+
+def _singularize(name: str) -> str:
+    lower = name.lower().strip()
+    if lower.endswith("ies") and len(lower) > 3:
+        return lower[:-3] + "y"
+    if lower.endswith("ses") and len(lower) > 3:
+        return lower[:-2]
+    if lower.endswith("s") and not lower.endswith("ss") and len(lower) > 1:
+        return lower[:-1]
+    return lower
+
+
+def _pluralize(name: str) -> str:
+    lower = name.lower().strip()
+    if lower.endswith("s"):
+        return lower
+    if lower.endswith("y") and len(lower) > 1 and lower[-2] not in "aeiou":
+        return lower[:-1] + "ies"
+    return lower + "s"
+
+
+def parse_sql_content(content: str, rel_file: str) -> Dict[str, Any]:
+    tables: Dict[str, Dict[str, Any]] = {}
+    nodes: List[Dict[str, Any]] = []
+    edges: List[Dict[str, str]] = []
+
+    # Match CREATE TABLE [IF NOT EXISTS] <table_name> ( ... );
+    create_pattern = re.compile(
+        r"CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?[`\"']?([a-zA-Z0-9_.]+)[`\"']?\s*\((.*?)\)\s*;",
+        re.IGNORECASE | re.DOTALL,
+    )
+    for match in create_pattern.finditer(content):
+        raw_table = match.group(1).split(".")[-1].strip().lower()
+        body = match.group(2)
+        table_node_id = f"db:{raw_table}"
+        tables.setdefault(raw_table, {"name": raw_table, "file": rel_file, "columns": {}})
+        nodes.append({
+            "id": table_node_id,
+            "type": "db_table",
+            "name": raw_table,
+            "file": rel_file,
+            "layer": "database",
+        })
+
+        for raw_line in body.splitlines():
+            line = raw_line.strip().rstrip(",")
+            if not line or line.startswith("--") or line.startswith("/*"):
+                continue
+            tokens = line.split()
+            if not tokens:
+                continue
+            first_word = tokens[0].strip("`\"'").upper()
+            if first_word in _SQL_KEYWORDS or first_word.startswith("("):
+                # Check for table-level FOREIGN KEY (col) REFERENCES other_table(other_col)
+                fk_match = re.search(
+                    r"FOREIGN\s+KEY\s*\([`\"']?(\w+)[`\"']?\)\s*REFERENCES\s+[`\"']?(\w+)[`\"']?\s*\([`\"']?(\w+)[`\"']?\)",
+                    line,
+                    re.IGNORECASE,
+                )
+                if fk_match:
+                    src_col, ref_table, ref_col = (
+                        fk_match.group(1).lower(),
+                        fk_match.group(2).lower(),
+                        fk_match.group(3).lower(),
+                    )
+                    edges.append({
+                        "source": f"db:{ref_table}.{ref_col}",
+                        "target": f"db:{raw_table}.{src_col}",
+                        "relation": "foreign_key",
+                    })
+                continue
+
+            col_name = tokens[0].strip("`\"'").lower()
+            col_type = tokens[1].upper() if len(tokens) > 1 else "UNKNOWN"
+            upper_line = line.upper()
+            nullable = "NOT NULL" not in upper_line and "PRIMARY KEY" not in upper_line
+            has_default = "DEFAULT" in upper_line
+
+            col_node_id = f"db:{raw_table}.{col_name}"
+            col_meta = {
+                "name": col_name,
+                "table": raw_table,
+                "type": col_type,
+                "nullable": nullable,
+                "has_default": has_default,
+                "raw_definition": line,
+                "file": rel_file,
+            }
+            tables[raw_table]["columns"][col_name] = col_meta
+            nodes.append({
+                "id": col_node_id,
+                "type": "db_column",
+                "name": f"{raw_table}.{col_name}",
+                "table": raw_table,
+                "column": col_name,
+                "data_type": col_type,
+                "nullable": nullable,
+                "has_default": has_default,
+                "file": rel_file,
+                "layer": "database",
+            })
+            edges.append({
+                "source": table_node_id,
+                "target": col_node_id,
+                "relation": "has_column",
+            })
+
+            inline_fk = re.search(
+                r"REFERENCES\s+[`\"']?(\w+)[`\"']?\s*(?:\([`\"']?(\w+)[`\"']?\))?",
+                line,
+                re.IGNORECASE,
+            )
+            if inline_fk:
+                ref_table = inline_fk.group(1).lower()
+                ref_col = (inline_fk.group(2) or "id").lower()
+                edges.append({
+                    "source": f"db:{ref_table}.{ref_col}",
+                    "target": col_node_id,
+                    "relation": "foreign_key",
+                })
+
+    # Also parse ALTER TABLE statements in migration files
+    alter_pattern = re.compile(
+        r"ALTER\s+TABLE\s+[`\"']?([a-zA-Z0-9_.]+)[`\"']?\s+(.*?);",
+        re.IGNORECASE | re.DOTALL,
+    )
+    for match in alter_pattern.finditer(content):
+        raw_table = match.group(1).split(".")[-1].strip().lower()
+        action = match.group(2).strip()
+        table_node_id = f"db:{raw_table}"
+        tables.setdefault(raw_table, {"name": raw_table, "file": rel_file, "columns": {}})
+
+        col_match = re.search(
+            r"(?:ADD|DROP|ALTER|MODIFY|RENAME)\s+(?:COLUMN\s+)?[`\"']?([a-zA-Z0-9_]+)[`\"']?(?:\s+([A-Z0-9_()]+))?",
+            action,
+            re.IGNORECASE,
+        )
+        if col_match:
+            col_name = col_match.group(1).lower()
+            col_type = (col_match.group(2) or "MODIFIED").upper()
+            col_node_id = f"db:{raw_table}.{col_name}"
+            tables[raw_table]["columns"].setdefault(col_name, {
+                "name": col_name,
+                "table": raw_table,
+                "type": col_type,
+                "nullable": "NOT NULL" not in action.upper(),
+                "has_default": "DEFAULT" in action.upper(),
+                "raw_definition": action,
+                "file": rel_file,
+            })
+            nodes.append({
+                "id": col_node_id,
+                "type": "db_column",
+                "name": f"{raw_table}.{col_name}",
+                "table": raw_table,
+                "column": col_name,
+                "data_type": col_type,
+                "file": rel_file,
+                "layer": "database",
+            })
+            edges.append({
+                "source": table_node_id,
+                "target": col_node_id,
+                "relation": "has_column",
+            })
+
+    return {"tables": tables, "nodes": nodes, "edges": edges}
+
+
+def parse_prisma_content(content: str, rel_file: str) -> Dict[str, Any]:
+    tables: Dict[str, Dict[str, Any]] = {}
+    nodes: List[Dict[str, Any]] = []
+    edges: List[Dict[str, str]] = []
+
+    model_pattern = re.compile(r"model\s+([A-Za-z0-9_]+)\s*\{(.*?)\}", re.DOTALL)
+    for match in model_pattern.finditer(content):
+        model_name = match.group(1).strip()
+        body = match.group(2)
+        map_match = re.search(r'@@map\(["\']([^"\']+)["\']\)', body)
+        table_name = map_match.group(1).lower() if map_match else _pluralize(model_name)
+        table_node_id = f"db:{table_name}"
+        tables.setdefault(table_name, {"name": table_name, "model": model_name, "file": rel_file, "columns": {}})
+        nodes.append({
+            "id": table_node_id,
+            "type": "db_table",
+            "name": table_name,
+            "model": model_name,
+            "file": rel_file,
+            "layer": "database",
+        })
+
+        for raw_line in body.splitlines():
+            line = raw_line.strip()
+            if not line or line.startswith("//") or line.startswith("@@"):
+                continue
+            parts = line.split()
+            if len(parts) < 2:
+                continue
+            col_name = parts[0].strip()
+            col_type = parts[1].strip()
+            nullable = col_type.endswith("?")
+            has_default = "@default" in line
+            col_node_id = f"db:{table_name}.{col_name.lower()}"
+            tables[table_name]["columns"][col_name.lower()] = {
+                "name": col_name.lower(),
+                "table": table_name,
+                "type": col_type.rstrip("?"),
+                "nullable": nullable,
+                "has_default": has_default,
+                "raw_definition": line,
+                "file": rel_file,
+            }
+            nodes.append({
+                "id": col_node_id,
+                "type": "db_column",
+                "name": f"{table_name}.{col_name.lower()}",
+                "table": table_name,
+                "column": col_name.lower(),
+                "data_type": col_type.rstrip("?"),
+                "nullable": nullable,
+                "has_default": has_default,
+                "file": rel_file,
+                "layer": "database",
+            })
+            edges.append({
+                "source": table_node_id,
+                "target": col_node_id,
+                "relation": "has_column",
+            })
+
+    return {"tables": tables, "nodes": nodes, "edges": edges}
+
+
+def parse_orm_python_content(content: str, rel_file: str) -> Dict[str, Any]:
+    """Extracts SQLAlchemy and Django ORM model definitions and maps them to database tables/columns."""
+    orm_models: Dict[str, Dict[str, Any]] = {}
+    nodes: List[Dict[str, Any]] = []
+    edges: List[Dict[str, str]] = []
+
+    class_pattern = re.compile(
+        r"class\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)\s*:(.*?)(?=\nclass\s+[A-Za-z0-9_]+|\ndef\s+[A-Za-z0-9_]+|\n@[A-Za-z0-9_.]|\Z)",
+        re.DOTALL,
+    )
+    for match in class_pattern.finditer(content):
+        cls_name = match.group(1).strip()
+        bases = match.group(2).strip()
+        body = match.group(3)
+
+        is_orm = (
+            "Base" in bases
+            or "Model" in bases
+            or "__tablename__" in body
+            or "Column(" in body
+            or "mapped_column(" in body
+            or "models." in body
+        )
+        if not is_orm:
+            continue
+
+        tbl_match = re.search(r'__tablename__\s*=\s*["\']([^"\']+)["\']', body)
+        table_name = tbl_match.group(1).lower() if tbl_match else _pluralize(cls_name)
+        orm_node_id = f"orm:{cls_name}"
+        orm_models[cls_name] = {
+            "class_name": cls_name,
+            "table": table_name,
+            "file": rel_file,
+            "fields": {},
+        }
+        nodes.append({
+            "id": orm_node_id,
+            "type": "orm_model",
+            "name": cls_name,
+            "table": table_name,
+            "file": rel_file,
+            "layer": "backend",
+        })
+        edges.append({
+            "source": f"db:{table_name}",
+            "target": orm_node_id,
+            "relation": "maps_to_orm",
+        })
+
+        field_pattern = re.compile(
+            r"^\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*(?::\s*[^=]+)?\s*=\s*(?:db\.)?(?:Column|mapped_column|models\.[A-Za-z0-9_]+|Field)\s*\(([^\n]*)\)",
+            re.MULTILINE,
+        )
+        for f_match in field_pattern.finditer(body):
+            field_name = f_match.group(1).strip()
+            field_args = f_match.group(2).strip()
+            if field_name.startswith("__"):
+                continue
+            field_node_id = f"orm:{cls_name}.{field_name}"
+            orm_models[cls_name]["fields"][field_name] = {
+                "name": field_name,
+                "args": field_args,
+                "table": table_name,
+                "file": rel_file,
+            }
+            nodes.append({
+                "id": field_node_id,
+                "type": "orm_field",
+                "name": f"{cls_name}.{field_name}",
+                "model": cls_name,
+                "field": field_name,
+                "table": table_name,
+                "file": rel_file,
+                "layer": "backend",
+            })
+            edges.append({
+                "source": orm_node_id,
+                "target": field_node_id,
+                "relation": "has_field",
+            })
+            edges.append({
+                "source": f"db:{table_name}.{field_name.lower()}",
+                "target": field_node_id,
+                "relation": "maps_column_to_orm_field",
+            })
+
+    return {"orm_models": orm_models, "nodes": nodes, "edges": edges}
+
+
+def parse_schema_file(file_path: str, repo_root: str = "") -> Dict[str, Any]:
+    """Parses a single SQL, Prisma, Drizzle, or Python ORM schema file."""
+    if not os.path.exists(file_path):
+        return {"error": f"Schema file not found: {file_path}", "tables": {}, "nodes": [], "edges": []}
+
+    rel_file = os.path.relpath(file_path, repo_root).replace("\\", "/") if repo_root else os.path.basename(file_path)
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+            content = f.read()
+    except Exception as exc:
+        return {"error": str(exc), "tables": {}, "nodes": [], "edges": []}
+
+    lower_path = file_path.lower()
+    if lower_path.endswith(".sql"):
+        return parse_sql_content(content, rel_file)
+    elif lower_path.endswith(".prisma"):
+        return parse_prisma_content(content, rel_file)
+    elif lower_path.endswith(".py"):
+        res = parse_orm_python_content(content, rel_file)
+        # Also populate a synthetic tables dict if no explicit SQL file was given
+        tables: Dict[str, Dict[str, Any]] = {}
+        for cls_name, model_info in res.get("orm_models", {}).items():
+            tbl = model_info["table"]
+            tables.setdefault(tbl, {"name": tbl, "file": rel_file, "columns": {}})
+            for fname, finfo in model_info["fields"].items():
+                tables[tbl]["columns"][fname.lower()] = {
+                    "name": fname.lower(),
+                    "table": tbl,
+                    "type": finfo.get("args", "ORM_FIELD"),
+                    "nullable": "nullable=False" not in finfo.get("args", ""),
+                    "has_default": "default=" in finfo.get("args", ""),
+                    "file": rel_file,
+                }
+        res["tables"] = tables
+        return res
+    else:
+        return parse_sql_content(content, rel_file)
+

blasttrace/parsers/swift_ios_parser.py

@@ -0,0 +1,127 @@
+"""
+BlastTrace Swift & iOS Mobile Parser
+Parses Swift data structures (Codable/Decodable structs, classes, CodingKeys),
+and API network consumers (URLSession, Alamofire AF.request) in iOS and macOS client apps.
+"""
+
+import os
+import re
+from typing import Dict, Any, List
+
+
+def _normalize_route_path(raw_url: str) -> str:
+    cleaned = raw_url.strip().strip("\"'`")
+    cleaned = re.sub(r"^https?://[^/]+", "", cleaned)
+    cleaned = cleaned.split("?")[0]
+    cleaned = re.sub(r"\\\(param[^)]*\)", ":param", cleaned)
+    cleaned = re.sub(r"\\\([^)]+\)", ":param", cleaned)
+    if not cleaned.startswith("/"):
+        cleaned = "/" + cleaned
+    if len(cleaned) > 1 and cleaned.endswith("/"):
+        cleaned = cleaned.rstrip("/")
+    return cleaned
+
+
+def parse_swift_content(content: str, rel_path: str = "") -> Dict[str, Any]:
+    """
+    Extracts Swift structs/classes, Codable fields, CodingKeys mappings,
+    and HTTP API consumer calls from Swift source code.
+    """
+    classes: List[Dict[str, Any]] = []
+    api_calls: List[Dict[str, Any]] = []
+    accessed_properties: List[str] = []
+
+    # 1. Parse Swift Structs and Classes (e.g. struct Product: Codable, class UserModel)
+    struct_regex = re.compile(
+        r"""(?:public\s+|private\s+|internal\s+)?(?:struct|class)\s+([A-Za-z0-9_]+)(?:\s*:\s*([^{]+))?\s*\{""",
+        re.MULTILINE,
+    )
+    for m in struct_regex.finditer(content):
+        sname = m.group(1)
+        protocol_str = m.group(2) or ""
+        classes.append({
+            "name": sname,
+            "type": "swift_model",
+            "protocols": [p.strip() for p in protocol_str.split(",") if p.strip()],
+            "file": rel_path,
+            "line": content[:m.start()].count("\n") + 1,
+        })
+
+    # 2. Parse CodingKeys mappings: case sellingPrice = "selling_price"
+    coding_key_regex = re.compile(r"""case\s+([a-zA-Z0-9_]+)\s*=\s*["']([a-zA-Z0-9_]+)["']""")
+    for cm in coding_key_regex.finditer(content):
+        prop = cm.group(2)
+        if prop not in accessed_properties:
+            accessed_properties.append(prop)
+
+    # 3. Parse Swift property declarations: let email: String or var balance: Double
+    prop_regex = re.compile(r"""(?:let|var)\s+([a-zA-Z0-9_]+)\s*:\s*([A-Za-z0-9_<>?]+)""", re.MULTILINE)
+    for pm in prop_regex.finditer(content):
+        pname = pm.group(1)
+        if pname not in ("body", "shared", "default", "self", "super") and pname not in accessed_properties:
+            accessed_properties.append(pname)
+
+    # 4. Parse URLSession / Alamofire / Moya API calls
+    # Examples: URL(string: "..."), AF.request("..."), URLSession.shared.dataTask(with: ...)
+    url_patterns = [
+        re.compile(r"""(?:URL|URLRequest)\s*\(\s*string:\s*["']([^"']+)["']""", re.IGNORECASE),
+        re.compile(r"""AF\.request\s*\(\s*["']([^"']+)["']""", re.IGNORECASE),
+        re.compile(r"""["']((?:/api/v[0-9]+|/api/|/products|/sales|/sync|/orders|/users)[^"']*)["']"""),
+    ]
+
+    for m in url_patterns[0].finditer(content):
+        raw_url = m.group(1)
+        route_path = _normalize_route_path(raw_url)
+        api_calls.append({
+            "method": "ANY",
+            "path": route_path,
+            "raw_url": raw_url,
+            "file": rel_path,
+            "line": content[:m.start()].count("\n") + 1,
+        })
+
+    for m in url_patterns[1].finditer(content):
+        raw_url = m.group(1)
+        route_path = _normalize_route_path(raw_url)
+        if not any(c["path"] == route_path for c in api_calls):
+            api_calls.append({
+                "method": "ANY",
+                "path": route_path,
+                "raw_url": raw_url,
+                "file": rel_path,
+                "line": content[:m.start()].count("\n") + 1,
+            })
+
+    for m in url_patterns[2].finditer(content):
+        raw_url = m.group(1)
+        route_path = _normalize_route_path(raw_url)
+        if not any(c["path"] == route_path for c in api_calls):
+            api_calls.append({
+                "method": "ANY",
+                "path": route_path,
+                "raw_url": raw_url,
+                "file": rel_path,
+                "line": content[:m.start()].count("\n") + 1,
+            })
+
+    return {
+        "file": rel_path,
+        "layer": "ios_client",
+        "classes": classes,
+        "api_calls": api_calls,
+        "accessed_properties": accessed_properties,
+    }
+
+
+def parse_swift_file(file_path: str, repo_root: str = "") -> Dict[str, Any]:
+    if not os.path.exists(file_path):
+        return {"error": f"File not found: {file_path}"}
+    rel_path = os.path.relpath(file_path, repo_root) if repo_root else file_path
+    rel_path = rel_path.replace("\\", "/")
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
+            content = f.read()
+        return parse_swift_content(content, rel_path)
+    except Exception as exc:
+        return {"error": str(exc), "file": rel_path}
+

blasttrace/parsers/test_mapper.py

@@ -0,0 +1,182 @@
+"""
+BlastTrace Test Discovery & Mapping Parser
+Parses Pytest/Unittest (test_*.py, *_test.py) and Jest/Vitest/Playwright (*.test.ts, *.spec.ts, *.test.tsx)
+to deterministically map code symbols, API endpoints, and schema objects to covering test suites.
+"""
+
+import ast
+import os
+import re
+from typing import Dict, Any, List
+
+
+def is_test_file(rel_file: str) -> bool:
+    norm = rel_file.replace("\\", "/").lower()
+    base = os.path.basename(norm)
+    if base.startswith("test_") and base.endswith(".py"):
+        return True
+    if base.endswith("_test.py"):
+        return True
+    if any(base.endswith(ext) for ext in (".test.ts", ".spec.ts", ".test.tsx", ".spec.tsx", ".test.js", ".spec.js")):
+        return True
+    if "/tests/" in f"/{norm}" and base.endswith((".py", ".ts", ".tsx", ".js")):
+        return True
+    return False
+
+
+def parse_python_test_content(content: str, rel_file: str) -> Dict[str, Any]:
+    test_cases: List[Dict[str, Any]] = []
+    imported_symbols: List[str] = []
+    tested_endpoints: List[str] = []
+    nodes: List[Dict[str, Any]] = []
+    edges: List[Dict[str, str]] = []
+
+    suite_id = f"test:{rel_file}"
+    nodes.append({
+        "id": suite_id,
+        "type": "test_suite",
+        "name": rel_file,
+        "framework": "pytest",
+        "file": rel_file,
+        "layer": "tests",
+    })
+
+    try:
+        tree = ast.parse(content)
+    except SyntaxError:
+        return {"test_cases": [], "imported_symbols": [], "tested_endpoints": [], "nodes": nodes, "edges": edges}
+
+    for node in tree.body:
+        if isinstance(node, ast.ImportFrom):
+            for alias in node.names:
+                imported_symbols.append(alias.name)
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                imported_symbols.append(alias.name)
+
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name.startswith("test_"):
+            calls: List[str] = []
+            endpoints: List[str] = []
+            for sub in ast.walk(node):
+                if isinstance(sub, ast.Call):
+                    if isinstance(sub.func, ast.Name):
+                        calls.append(sub.func.id)
+                    elif isinstance(sub.func, ast.Attribute):
+                        calls.append(sub.func.attr)
+                        if sub.func.attr.lower() in ("get", "post", "put", "delete", "patch") and sub.args:
+                            first_arg = sub.args[0]
+                            if isinstance(first_arg, ast.Constant) and isinstance(first_arg.value, str):
+                                if first_arg.value.startswith("/"):
+                                    ep = f"{sub.func.attr.upper()} {first_arg.value.rstrip('/') or '/'}"
+                                    endpoints.append(ep)
+                                    if ep not in tested_endpoints:
+                                        tested_endpoints.append(ep)
+            tc_id = f"test:{rel_file}:{node.name}"
+            tc_entry = {
+                "id": tc_id,
+                "name": node.name,
+                "file": rel_file,
+                "lineno": node.lineno,
+                "called_symbols": list(dict.fromkeys(calls)),
+                "tested_endpoints": list(dict.fromkeys(endpoints)),
+            }
+            test_cases.append(tc_entry)
+            nodes.append({
+                "id": tc_id,
+                "type": "test_case",
+                "name": f"{rel_file}::{node.name}",
+                "function": node.name,
+                "file": rel_file,
+                "lineno": node.lineno,
+                "layer": "tests",
+            })
+            edges.append({
+                "source": suite_id,
+                "target": tc_id,
+                "relation": "contains_test",
+            })
+
+    return {
+        "file": rel_file,
+        "framework": "pytest",
+        "test_cases": test_cases,
+        "imported_symbols": list(dict.fromkeys(imported_symbols)),
+        "tested_endpoints": tested_endpoints,
+        "nodes": nodes,
+        "edges": edges,
+    }
+
+
+def parse_ts_test_content(content: str, rel_file: str) -> Dict[str, Any]:
+    test_cases: List[Dict[str, Any]] = []
+    imported_symbols: List[str] = []
+    tested_endpoints: List[str] = []
+    nodes: List[Dict[str, Any]] = []
+    edges: List[Dict[str, str]] = []
+
+    suite_id = f"test:{rel_file}"
+    nodes.append({
+        "id": suite_id,
+        "type": "test_suite",
+        "name": rel_file,
+        "framework": "jest_vitest",
+        "file": rel_file,
+        "layer": "tests",
+    })
+
+    for imp_match in re.finditer(r"import\s+(?:\{([^}]+)\}|([A-Za-z0-9_]+))\s+from\s+[`\"']([^`\"']+)[`\"']", content):
+        if imp_match.group(1):
+            for s in imp_match.group(1).split(","):
+                sym = s.strip().split(" as ")[0].strip()
+                if sym:
+                    imported_symbols.append(sym)
+        elif imp_match.group(2):
+            imported_symbols.append(imp_match.group(2).strip())
+
+    for tc_match in re.finditer(r"\b(?:it|test)\s*\(\s*[`\"']([^`\"']+)[`\"']", content):
+        tc_name = tc_match.group(1)
+        safe_name = re.sub(r"[^a-zA-Z0-9_]+", "_", tc_name).strip("_")
+        tc_id = f"test:{rel_file}:{safe_name}"
+        test_cases.append({
+            "id": tc_id,
+            "name": tc_name,
+            "file": rel_file,
+            "called_symbols": imported_symbols,
+            "tested_endpoints": [],
+        })
+        nodes.append({
+            "id": tc_id,
+            "type": "test_case",
+            "name": f"{rel_file}::{tc_name}",
+            "function": tc_name,
+            "file": rel_file,
+            "layer": "tests",
+        })
+        edges.append({"source": suite_id, "target": tc_id, "relation": "contains_test"})
+
+    return {
+        "file": rel_file,
+        "framework": "jest_vitest",
+        "test_cases": test_cases,
+        "imported_symbols": list(dict.fromkeys(imported_symbols)),
+        "tested_endpoints": tested_endpoints,
+        "nodes": nodes,
+        "edges": edges,
+    }
+
+
+def parse_test_file(file_path: str, repo_root: str = "") -> Dict[str, Any]:
+    if not os.path.exists(file_path):
+        return {"error": f"Test file not found: {file_path}", "test_cases": [], "nodes": [], "edges": []}
+    rel_file = os.path.relpath(file_path, repo_root).replace("\\", "/") if repo_root else os.path.basename(file_path)
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+            content = f.read()
+    except Exception as exc:
+        return {"error": str(exc), "test_cases": [], "nodes": [], "edges": []}
+
+    if file_path.lower().endswith(".py"):
+        return parse_python_test_content(content, rel_file)
+    return parse_ts_test_content(content, rel_file)
+