torusguard 2.0.0-alpha → 2.1.1

package/skills/torusguard/payload/core/models.py

@@ -0,0 +1,425 @@
+"""
+TorusGuard Core Data Models (v0.5.4)
+Defines canonical Finding, ProvenanceChain, ConfidenceScore, EvidencePackage, RetestRecord, RemediationPriority, and AuditReport objects.
+"""
+
+from dataclasses import dataclass, field, asdict
+from enum import Enum
+from typing import List, Optional, Dict, Any
+import datetime
+import hashlib
+import uuid
+import re
+
+
+class SeverityLevel(str, Enum):
+    CRITICAL = "Critical"
+    HIGH = "High"
+    MEDIUM = "Medium"
+    LOW = "Low"
+    INFORMATIONAL = "Informational"
+
+
+class RemediationPriority(str, Enum):
+    IMMEDIATE = "Immediate (P0)"     # Block deployment / immediate fix
+    NEAR_TERM = "Near-Term (P1)"     # Fix in current sprint / patch cycle
+    BACKLOG = "Backlog (P2)"         # Defense-in-depth hardening backlog
+
+
+class ConfidenceBand(str, Enum):
+    CONFIRMED = "Confirmed"                  # 90 - 100
+    HIGH_CONFIDENCE = "High Confidence"      # 70 - 89
+    MEDIUM_CONFIDENCE = "Medium Confidence"  # 50 - 69
+    LOW_CONFIDENCE = "Low Confidence"        # < 50
+    UNCONFIRMED = "Unconfirmed"
+    NEEDS_REVIEW = "Needs Review"
+    INFORMATIONAL = "Informational"
+    NOT_APPLICABLE = "Not Applicable"
+
+
+class FindingStatus(str, Enum):
+    CONFIRMED = "Confirmed"
+    HIGH_CONFIDENCE = "High Confidence"
+    MEDIUM_CONFIDENCE = "Medium Confidence"
+    LOW_CONFIDENCE = "Low Confidence"
+    UNCONFIRMED = "Unconfirmed"
+    NEEDS_REVIEW = "Needs Review"
+    REMEDIATED = "Remediated"
+    VERIFIED_FIXED = "Verified Fixed"
+    SUPPRESSED = "Suppressed"
+
+
+class LifecycleStage(str, Enum):
+    DETECT = "Detect"
+    CLASSIFY = "Classify"
+    VERIFY = "Verify"
+    REMEDIATE = "Remediate"
+    RECHECK = "Recheck"
+    ARCHIVE = "Archive"
+
+
+class TaxonomyCategory(str, Enum):
+    AUTH = "authentication-authorization"
+    INPUT = "input-validation-encoding"
+    DATA = "data-access-orm"
+    FILES = "file-upload-handling"
+    SECRETS = "secrets-configuration"
+    SUPPLY_CHAIN = "dependency-supply-chain"
+    NETWORK = "network-ssrf-boundaries"
+    BUSINESS_LOGIC = "business-logic-rate-limiting"
+    CLIENT_PLATFORM = "client-cache-platform"
+
+
+class EvidenceType(str, Enum):
+    SOURCE = "source"
+    RUNTIME = "runtime"
+    TEST = "test"
+    MANUAL_REVIEW = "manual_review"
+
+
+@dataclass
+class ProvenanceChain:
+    discovery_module: str
+    triggering_input: str
+    evidence_collected: List[str]
+    decision_path: List[str]
+    verification_step: str
+    agent_environment: str = "TorusGuard Engine v0.5.4"
+    timestamp: str = field(default_factory=lambda: datetime.datetime.utcnow().isoformat() + "Z")
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class ConfidenceFactors:
+    evidence_quality: int           # Max: 35
+    reproduction_success: int       # Max: 25
+    independent_confirmations: int  # Max: 15
+    environmental_clarity: int      # Max: 15
+    manual_review_status: int       # Max: 10
+
+    def total_score(self) -> int:
+        return max(0, min(100, (
+            self.evidence_quality +
+            self.reproduction_success +
+            self.independent_confirmations +
+            self.environmental_clarity +
+            self.manual_review_status
+        )))
+
+
+@dataclass
+class ConfidenceScore:
+    factors: ConfidenceFactors
+    score: int = field(init=False)
+    band: ConfidenceBand = field(init=False)
+    rationale: str = ""
+
+    def __post_init__(self):
+        self.score = self.factors.total_score()
+        if self.score >= 90:
+            self.band = ConfidenceBand.CONFIRMED
+        elif self.score >= 70:
+            self.band = ConfidenceBand.HIGH_CONFIDENCE
+        elif self.score >= 50:
+            self.band = ConfidenceBand.MEDIUM_CONFIDENCE
+        else:
+            self.band = ConfidenceBand.LOW_CONFIDENCE
+
+    @staticmethod
+    def calculate(
+        evidence_quality: int = 30,
+        reproduction_success: int = 25,
+        independent_confirmations: int = 15,
+        environmental_clarity: int = 15,
+        manual_review_status: int = 5,
+        rationale: str = ""
+    ) -> 'ConfidenceScore':
+        factors = ConfidenceFactors(
+            evidence_quality=evidence_quality,
+            reproduction_success=reproduction_success,
+            independent_confirmations=independent_confirmations,
+            environmental_clarity=environmental_clarity,
+            manual_review_status=manual_review_status,
+        )
+        return ConfidenceScore(factors=factors, rationale=rationale)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "score": self.score,
+            "band": self.band.value,
+            "factors": asdict(self.factors),
+            "rationale": self.rationale,
+        }
+
+
+def mask_sensitive_data(text: str) -> str:
+    """Masks secrets, tokens, API keys, and passwords from report output."""
+    text = re.sub(r'sk_live_[0-9a-zA-Z_\-]{6,}', 'sk_live_***REDACTED***', text)
+    text = re.sub(r'ghp_[0-9a-zA-Z_\-]{6,}', 'ghp_***REDACTED***', text)
+    text = re.sub(r'(Bearer\s+)[A-Za-z0-9\-_=]+\.[A-Za-z0-9\-_=]+\.?[A-Za-z0-9\-_=]*', r'\1***REDACTED_JWT***', text)
+
+    def redact_kv(m):
+        val = m.group(3)
+        if "***REDACTED" in val:
+            return m.group(0)
+        return f"{m.group(1)}{m.group(2)}***REDACTED***{m.group(4)}"
+
+    text = re.sub(
+        r'(?i)(secret[_\-\w]*|password|api[_\-\w]*key|token|auth[_\-\w]*key)(\s*[:=]\s*[\'"])([^\'"]{4,})([\'"])',
+        redact_kv,
+        text
+    )
+    return text
+
+
+@dataclass
+class Evidence:
+    type: EvidenceType
+    location: str
+    raw_snippet: str
+    rationale: str
+    confidence_level: ConfidenceBand
+    sha256_checksum: str = field(init=False)
+    context: Optional[str] = None
+    reproduction_notes: Optional[str] = None
+    reviewer_notes: Optional[str] = None
+    is_sufficient_for_confirmed: bool = False
+    collected_at: str = field(default_factory=lambda: datetime.datetime.utcnow().isoformat() + "Z")
+
+    def __post_init__(self):
+        self.sha256_checksum = hashlib.sha256(self.raw_snippet.strip().encode("utf-8")).hexdigest()
+
+    def get_masked_snippet(self) -> str:
+        return mask_sensitive_data(self.raw_snippet)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "type": self.type.value if isinstance(self.type, EvidenceType) else self.type,
+            "location": self.location,
+            "raw_snippet": self.get_masked_snippet(),
+            "sha256_checksum": self.sha256_checksum,
+            "collected_at": self.collected_at,
+            "context": self.context,
+            "rationale": self.rationale,
+            "confidence_level": self.confidence_level.value if isinstance(self.confidence_level, ConfidenceBand) else self.confidence_level,
+            "reproduction_notes": self.reproduction_notes,
+            "reviewer_notes": self.reviewer_notes,
+            "is_sufficient_for_confirmed": self.is_sufficient_for_confirmed,
+        }
+
+
+@dataclass
+class SeverityInfo:
+    level: SeverityLevel
+    rationale: str
+    rubric_justification: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "level": self.level.value if isinstance(self.level, SeverityLevel) else self.level,
+            "rationale": self.rationale,
+            "rubric_justification": self.rubric_justification,
+        }
+
+
+@dataclass
+class FrameworkPattern:
+    framework: str
+    unsafe_snippet: str
+    safe_snippet: str
+    least_invasive: bool = True
+
+
+@dataclass
+class Remediation:
+    problem_statement: str
+    risk_explanation: str
+    recommended_fix: str
+    framework_pattern: FrameworkPattern
+    verification_method: str
+    residual_risk_notes: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "problem_statement": self.problem_statement,
+            "risk_explanation": self.risk_explanation,
+            "recommended_fix": self.recommended_fix,
+            "framework_pattern": asdict(self.framework_pattern),
+            "verification_method": self.verification_method,
+            "residual_risk_notes": self.residual_risk_notes,
+        }
+
+
+@dataclass
+class AffectedComponent:
+    component_name: str
+    target_path: str
+    start_line: Optional[int] = None
+    end_line: Optional[int] = None
+    symbol: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+
+@dataclass
+class ReproductionMethod:
+    step_by_step: List[str]
+    deterministic: bool = True
+    test_command: Optional[str] = None
+    expected_failure_response: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+
+@dataclass
+class RetestRecord:
+    retest_performed: bool = False
+    closure_status: FindingStatus = FindingStatus.UNCONFIRMED
+    fix_applied: Optional[str] = None
+    retest_method: Optional[str] = None
+    retest_evidence_hash: Optional[str] = None
+    residual_risk: Optional[str] = None
+    verifier_notes: Optional[str] = None
+    retest_timestamp: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        d["closure_status"] = self.closure_status.value if isinstance(self.closure_status, FindingStatus) else self.closure_status
+        return {k: v for k, v in d.items() if v is not None}
+
+
+@dataclass
+class NotesRecord:
+    business_impact: str
+    technical_description: str
+    raw_facts_summary: str
+    ai_interpretation: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class FindingTimestamps:
+    discovered_at: str = field(default_factory=lambda: datetime.datetime.utcnow().isoformat() + "Z")
+    updated_at: str = field(default_factory=lambda: datetime.datetime.utcnow().isoformat() + "Z")
+    verified_at: Optional[str] = None
+    remediated_at: Optional[str] = None
+    retested_at: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+
+@dataclass
+class Finding:
+    rule_id: str
+    title: str
+    category: TaxonomyCategory
+    severity: SeverityInfo
+    confidence: ConfidenceScore
+    status: FindingStatus
+    affected_component: AffectedComponent
+    evidence: List[Evidence]
+    provenance: ProvenanceChain
+    reproduction_method: ReproductionMethod
+    remediation: Remediation
+    remediation_priority: RemediationPriority = RemediationPriority.IMMEDIATE
+    retest_result: RetestRecord = field(default_factory=RetestRecord)
+    timestamps: FindingTimestamps = field(default_factory=FindingTimestamps)
+    notes: NotesRecord = field(default_factory=lambda: NotesRecord(
+        business_impact="Exposure of sensitive application resources or unauthorized data modification.",
+        technical_description="Direct unmitigated pattern detected in application route or data layer.",
+        raw_facts_summary="Unmitigated pattern identified in source.",
+        ai_interpretation="High priority fix recommended.",
+    ))
+    finding_id: str = field(default_factory=lambda: f"TG-FIND-{datetime.datetime.utcnow().year}-{uuid.uuid4().hex[:6]}")
+    lifecycle_stage: LifecycleStage = LifecycleStage.DETECT
+    asvs_control: Optional[str] = None
+    cwe: Optional[str] = None
+    nist_ssdf: Optional[str] = None
+
+    def __post_init__(self):
+        # Auto-derive remediation priority from severity level if default
+        if self.severity.level == SeverityLevel.CRITICAL:
+            self.remediation_priority = RemediationPriority.IMMEDIATE
+        elif self.severity.level == SeverityLevel.HIGH:
+            self.remediation_priority = RemediationPriority.NEAR_TERM
+        else:
+            self.remediation_priority = RemediationPriority.BACKLOG
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "finding_id": self.finding_id,
+            "rule_id": self.rule_id,
+            "title": self.title,
+            "category": self.category.value if isinstance(self.category, TaxonomyCategory) else self.category,
+            "severity": self.severity.to_dict(),
+            "confidence": self.confidence.to_dict(),
+            "status": self.status.value if isinstance(self.status, FindingStatus) else self.status,
+            "remediation_priority": self.remediation_priority.value if isinstance(self.remediation_priority, RemediationPriority) else self.remediation_priority,
+            "lifecycle_stage": self.lifecycle_stage.value if isinstance(self.lifecycle_stage, LifecycleStage) else self.lifecycle_stage,
+            "affected_component": self.affected_component.to_dict(),
+            "evidence": [e.to_dict() for e in self.evidence],
+            "provenance": self.provenance.to_dict(),
+            "reproduction_method": self.reproduction_method.to_dict(),
+            "remediation": self.remediation.to_dict(),
+            "retest_result": self.retest_result.to_dict(),
+            "requirement_reference": {
+                "asvs_v4": self.asvs_control,
+                "cwe": self.cwe,
+                "nist_ssdf": self.nist_ssdf,
+            },
+            "cwe": self.cwe,
+            "timestamps": self.timestamps.to_dict(),
+            "notes": self.notes.to_dict(),
+        }
+
+
+@dataclass
+class AuditReport:
+    project_name: str
+    detected_stack: Dict[str, Any]
+    findings: List[Finding]
+    summary_counts: Dict[str, Any] = field(default_factory=dict)
+    generated_at: str = field(default_factory=lambda: datetime.datetime.utcnow().isoformat() + "Z")
+    torusguard_version: str = "v0.5.4"
+    report_owner: str = "TorusGuard Security Subsystem"
+    repository_ref: str = "workspace"
+
+    def calculate_summary(self) -> None:
+        total = len(self.findings)
+        avg_confidence = round(sum(f.confidence.score for f in self.findings) / total, 1) if total > 0 else 100.0
+        self.summary_counts = {
+            "total_findings": total,
+            "average_confidence_score": avg_confidence,
+            "critical": sum(1 for f in self.findings if f.severity.level == SeverityLevel.CRITICAL),
+            "high": sum(1 for f in self.findings if f.severity.level == SeverityLevel.HIGH),
+            "medium": sum(1 for f in self.findings if f.severity.level == SeverityLevel.MEDIUM),
+            "low": sum(1 for f in self.findings if f.severity.level == SeverityLevel.LOW),
+            "confirmed": sum(1 for f in self.findings if f.confidence.band == ConfidenceBand.CONFIRMED),
+            "high_confidence": sum(1 for f in self.findings if f.confidence.band == ConfidenceBand.HIGH_CONFIDENCE),
+            "needs_review": sum(1 for f in self.findings if f.confidence.band in (ConfidenceBand.NEEDS_REVIEW, ConfidenceBand.LOW_CONFIDENCE)),
+            "verified_fixed": sum(1 for f in self.findings if f.status == FindingStatus.VERIFIED_FIXED),
+            "remediated": sum(1 for f in self.findings if f.status in (FindingStatus.REMEDIATED, FindingStatus.VERIFIED_FIXED)),
+            "immediate_priority": sum(1 for f in self.findings if f.remediation_priority == RemediationPriority.IMMEDIATE),
+            "near_term_priority": sum(1 for f in self.findings if f.remediation_priority == RemediationPriority.NEAR_TERM),
+            "backlog_priority": sum(1 for f in self.findings if f.remediation_priority == RemediationPriority.BACKLOG),
+        }
+
+    def to_dict(self) -> Dict[str, Any]:
+        self.calculate_summary()
+        return {
+            "project_name": self.project_name,
+            "torusguard_version": self.torusguard_version,
+            "generated_at": self.generated_at,
+            "report_owner": self.report_owner,
+            "repository_ref": self.repository_ref,
+            "detected_stack": self.detected_stack,
+            "summary": self.summary_counts,
+            "findings": [f.to_dict() for f in self.findings],
+        }

package/skills/torusguard/payload/core/parallel.py

@@ -0,0 +1,56 @@
+"""
+TorusGuard Parallel Audit Executor
+Executes multi-threaded static security scanning across files with deterministic result collation.
+"""
+
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import List, Dict, Any, Callable, Optional
+
+
+class ParallelAuditExecutor:
+    """Distributes file analysis across a thread pool with deterministic output ordering."""
+
+    def __init__(self, max_workers: Optional[int] = None):
+        self.max_workers = max_workers or min(os.cpu_count() or 4, 8)
+
+    def scan_files_parallel(
+        self,
+        files: List[Path],
+        scan_fn: Callable[[Path], List[Dict[str, Any]]]
+    ) -> List[Dict[str, Any]]:
+        """
+        Executes `scan_fn` across all files in parallel.
+        Returns deterministically ordered list of all findings.
+        """
+        if not files:
+            return []
+
+        # If only a few files, avoid thread pool overhead
+        if len(files) <= 3:
+            all_findings = []
+            for f in files:
+                all_findings.extend(scan_fn(f))
+            return all_findings
+
+        all_findings: List[Dict[str, Any]] = []
+        file_results: Dict[str, List[Dict[str, Any]]] = {}
+
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            future_to_file = {executor.submit(scan_fn, f): str(f) for f in files}
+            for future in as_completed(future_to_file):
+                f_str = future_to_file[future]
+                try:
+                    res = future.result()
+                    file_results[f_str] = res
+                except Exception:
+                    file_results[f_str] = []
+
+        # Deterministic sort by original file order
+        for f in files:
+            f_str = str(f)
+            if f_str in file_results:
+                all_findings.extend(file_results[f_str])
+
+        return all_findings

package/skills/torusguard/payload/core/parser.py

@@ -0,0 +1,202 @@
+"""
+TorusGuard Polyglot Parser
+Unified Tree-sitter parser wrapper with language auto-detection and resilient
+fallback parsing across Python, JavaScript, TypeScript, Go, Rust, Java, Ruby, PHP, and C#.
+"""
+
+from pathlib import Path
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any
+import re
+
+from core.ast_walker import FunctionCall, Assignment, ImportStatement, StringLiteral, TreeSitterWalker
+from core.symbol_table import SymbolTable
+
+
+LANGUAGE_EXTENSIONS: Dict[str, str] = {
+    ".py": "python",
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".ts": "typescript",
+    ".tsx": "tsx",
+    ".go": "go",
+    ".rs": "rust",
+    ".java": "java",
+    ".rb": "ruby",
+    ".php": "php",
+    ".cs": "csharp",
+}
+
+
+@dataclass
+class ParseResult:
+    file_path: str
+    language: str
+    function_calls: List[FunctionCall] = field(default_factory=list)
+    assignments: List[Assignment] = field(default_factory=list)
+    imports: List[ImportStatement] = field(default_factory=list)
+    string_literals: List[StringLiteral] = field(default_factory=list)
+    symbol_table: SymbolTable = field(default_factory=SymbolTable)
+    is_tree_sitter: bool = False
+    raw_content: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "file_path": self.file_path,
+            "language": self.language,
+            "function_calls_count": len(self.function_calls),
+            "assignments_count": len(self.assignments),
+            "imports_count": len(self.imports),
+            "is_tree_sitter": self.is_tree_sitter,
+        }
+
+
+class PolyglotParser:
+    """Parses source files into Tree-sitter ASTs or fallback token models with language auto-detection."""
+
+    def __init__(self):
+        self._parsers: Dict[str, Any] = {}
+        self._init_tree_sitter()
+
+    def _init_tree_sitter(self):
+        try:
+            import tree_sitter
+            # Python
+            try:
+                import tree_sitter_python
+                py_lang = tree_sitter.Language(tree_sitter_python.language())
+                self._parsers["python"] = tree_sitter.Parser(py_lang)
+            except Exception:
+                pass
+
+            # JavaScript
+            try:
+                import tree_sitter_javascript
+                js_lang = tree_sitter.Language(tree_sitter_javascript.language())
+                self._parsers["javascript"] = tree_sitter.Parser(js_lang)
+            except Exception:
+                pass
+
+            # TypeScript / TSX
+            try:
+                import tree_sitter_typescript
+                ts_lang = tree_sitter.Language(tree_sitter_typescript.language_typescript())
+                self._parsers["typescript"] = tree_sitter.Parser(ts_lang)
+                tsx_lang = tree_sitter.Language(tree_sitter_typescript.language_tsx())
+                self._parsers["tsx"] = tree_sitter.Parser(tsx_lang)
+            except Exception:
+                pass
+
+            # Go
+            try:
+                import tree_sitter_go
+                go_lang = tree_sitter.Language(tree_sitter_go.language())
+                self._parsers["go"] = tree_sitter.Parser(go_lang)
+            except Exception:
+                pass
+
+        except Exception:
+            pass
+
+    def detect_language(self, file_path: Path) -> str:
+        ext = file_path.suffix.lower()
+        return LANGUAGE_EXTENSIONS.get(ext, "unknown")
+
+    def parse_file(self, file_path: Path) -> ParseResult:
+        lang = self.detect_language(file_path)
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            return ParseResult(file_path=str(file_path), language=lang)
+
+        source_bytes = content.encode("utf-8")
+        ts_parser = self._parsers.get(lang)
+
+        if ts_parser is not None:
+            try:
+                tree = ts_parser.parse(source_bytes)
+                calls = TreeSitterWalker.extract_function_calls(tree.root_node, source_bytes)
+                assigns = TreeSitterWalker.extract_assignments(tree.root_node, source_bytes)
+                imports = TreeSitterWalker.extract_imports(tree.root_node, source_bytes, lang)
+                strings = TreeSitterWalker.extract_string_literals(tree.root_node, source_bytes)
+
+                sym_table = SymbolTable(str(file_path))
+                for a in assigns:
+                    sym_table.add_variable(name=a.target, line=a.line_number, expression=a.value_expression)
+                for imp in imports:
+                    for alias, orig in imp.alias_map.items():
+                        sym_table.add_import_alias(alias, orig)
+
+                return ParseResult(
+                    file_path=str(file_path),
+                    language=lang,
+                    function_calls=calls,
+                    assignments=assigns,
+                    imports=imports,
+                    string_literals=strings,
+                    symbol_table=sym_table,
+                    is_tree_sitter=True,
+                    raw_content=content
+                )
+            except Exception:
+                pass
+
+        # Resilient Fallback Parser
+        return self._fallback_parse(str(file_path), content, lang)
+
+    def _fallback_parse(self, file_path: str, content: str, lang: str) -> ParseResult:
+        lines = content.splitlines()
+        calls: List[FunctionCall] = []
+        assigns: List[Assignment] = []
+        imports: List[ImportStatement] = []
+        strings: List[StringLiteral] = []
+        sym_table = SymbolTable(file_path)
+
+        for idx, line in enumerate(lines):
+            line_num = idx + 1
+            stripped = line.strip()
+            if not stripped or stripped.startswith(("#", "//", "/*", "*")):
+                continue
+
+            # Assignments
+            assign_match = re.match(r"^(?:const|let|var)?\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*(?::=[=]?|=)\s*(.+)$", stripped)
+            if assign_match:
+                target = assign_match.group(1).strip()
+                val = assign_match.group(2).strip()
+                assigns.append(Assignment(target=target, value_expression=val, line_number=line_num, column=0))
+                sym_table.add_variable(target, line_num, expression=val)
+
+            # Function calls (e.g. foo(x), obj.method(y))
+            call_matches = re.finditer(r"([a-zA-Z_][a-zA-Z0-9_\.]*)\s*\((.*?)\)", stripped)
+            for cm in call_matches:
+                func_name = cm.group(1)
+                args_str = cm.group(2)
+                args = [a.strip() for a in args_str.split(",") if a.strip()]
+                calls.append(FunctionCall(
+                    name=func_name,
+                    full_call=cm.group(0),
+                    arguments=args,
+                    line_number=line_num,
+                    column=cm.start()
+                ))
+
+            # Imports
+            if "import " in stripped or "require(" in stripped or "from " in stripped:
+                imp_match = re.search(r"(?:from\s+([a-zA-Z0-9_\.]+)\s+import\s+([a-zA-Z0-9_,\s]+)|import\s+([a-zA-Z0-9_\.]+))", stripped)
+                if imp_match:
+                    mod = imp_match.group(1) or imp_match.group(3) or ""
+                    names = [n.strip() for n in (imp_match.group(2) or "").split(",") if n.strip()]
+                    imports.append(ImportStatement(module=mod, imported_names=names, line_number=line_num))
+
+        return ParseResult(
+            file_path=file_path,
+            language=lang,
+            function_calls=calls,
+            assignments=assigns,
+            imports=imports,
+            string_literals=strings,
+            symbol_table=sym_table,
+            is_tree_sitter=False,
+            raw_content=content
+        )