tracevector 2.5.0__tar.gz

tracevector-2.5.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: tracevector
+Version: 2.5.0
+Summary: TRACEVECTOR OSINT CLI Investigator
+Project-URL: Homepage, https://github.com/oedxdigitals/tracevector
+Project-URL: Source, https://github.com/oedxdigitals/tracevector
+Requires-Python: >=3.9
+Requires-Dist: phonenumbers
+Requires-Dist: dnspython
+Requires-Dist: ipwhois

tracevector-2.5.0/README.md

@@ -0,0 +1,33 @@
+# TRACEVECTOR (tvx)
+
+TRACEVECTOR is a professional, terminal-first OSINT investigation CLI designed for investigators, analysts, and security professionals.
+
+It runs as a **single portable binary**, supports a **plugin-based architecture**, and performs ethical open-source intelligence lookups on targets such as phone numbers, IP addresses, and email addresses.
+
+---
+
+## Features
+
+- 🔍 OSINT investigations from the terminal
+- 🧩 Plugin-based architecture
+- 📦 Single-file portable binary (PyInstaller)
+- 🕵️ Phone number metadata investigation
+- 🧪 Built-in self diagnostics (`tvx doctor`)
+- 📄 JSON output support
+- ⚙️ Works in minimal / container / Android-like environments
+
+---
+
+## Installation
+
+### Option 1: Use prebuilt binary
+```bash
+chmod +x tvx
+./tvx --version
+### Option 2: Use pip
+'''bash
+pip instal tracevector
+
+### v2.5.0 Help Text
+TRACEVECTOR performs lawful, metadata-based OSINT only.
+Private communications are never accessed.

tracevector-2.5.0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "tracevector"
+version = "2.5.0"
+description = "TRACEVECTOR OSINT CLI Investigator"
+requires-python = ">=3.9"
+dependencies = [
+    "phonenumbers",
+    "dnspython",
+    "ipwhois"
+]
+
+[project.urls]
+Homepage = "https://github.com/oedxdigitals/tracevector"
+Source = "https://github.com/oedxdigitals/tracevector"
+
+[project.scripts]
+tvx = "tvx.main:main"

tracevector-2.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tracevector-2.5.0/setup.py

@@ -0,0 +1,14 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="tracevector",
+    version="2.5.0",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[],
+    entry_points={
+        "console_scripts": [
+            "tvx=tvx.main:main"
+        ]
+    },
+)

tracevector-2.5.0/tracevector.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: tracevector
+Version: 2.5.0
+Summary: TRACEVECTOR OSINT CLI Investigator
+Project-URL: Homepage, https://github.com/oedxdigitals/tracevector
+Project-URL: Source, https://github.com/oedxdigitals/tracevector
+Requires-Python: >=3.9
+Requires-Dist: phonenumbers
+Requires-Dist: dnspython
+Requires-Dist: ipwhois

tracevector-2.5.0/tracevector.egg-info/SOURCES.txt

@@ -0,0 +1,35 @@
+README.md
+pyproject.toml
+setup.py
+tracevector.egg-info/PKG-INFO
+tracevector.egg-info/SOURCES.txt
+tracevector.egg-info/dependency_links.txt
+tracevector.egg-info/entry_points.txt
+tracevector.egg-info/requires.txt
+tracevector.egg-info/top_level.txt
+tvx/__init__.py
+tvx/banner.py
+tvx/colors.py
+tvx/config.py
+tvx/doctor.py
+tvx/email.py
+tvx/ip.py
+tvx/main.py
+tvx/phone.py
+tvx/plugin_loader.py
+tvx/plugin_security.py
+tvx/reporting.py
+tvx/risk.py
+tvx/scoring.py
+tvx/utils.py
+tvx/version.py
+tvx/plugins/__init__.py
+tvx/plugins/email_basic.py
+tvx/plugins/email_osint.py
+tvx/plugins/ip_basic.py
+tvx/plugins/ip_osint.py
+tvx/plugins/phone_basic.py
+tvx/storage/__init__.py
+tvx/storage/base.py
+tvx/storage/manager.py
+tvx/storage/sqlite.py

tracevector-2.5.0/tracevector.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tracevector-2.5.0/tracevector.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tvx = tvx.main:main

tracevector-2.5.0/tracevector.egg-info/requires.txt

@@ -0,0 +1,3 @@
+phonenumbers
+dnspython
+ipwhois

tracevector-2.5.0/tracevector.egg-info/top_level.txt

@@ -0,0 +1 @@
+tvx

tracevector-2.5.0/tvx/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.5.0"

tracevector-2.5.0/tvx/banner.py

@@ -0,0 +1,13 @@
+def show_banner():
+    banner = r"""
+████████╗██████╗  █████╗  ██████╗███████╗
+╚══██╔══╝██╔══██╗██╔══██╗██╔════╝██╔════╝
+   ██║   ██████╔╝███████║██║     █████╗  
+   ██║   ██╔══██╗██╔══██║██║     ██╔══╝  
+   ██║   ██║  ██║██║  ██║╚██████╗███████╗
+   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚══════╝
+
+        TRACEVECTOR OSINT CLI
+     Digital Footprint Investigator
+    """
+    print(banner)

tracevector-2.5.0/tvx/colors.py

@@ -0,0 +1,8 @@
+import os
+
+COLOR_ENABLED = os.environ.get("TVX_COLOR", "1") == "1"
+
+def c(text, code):
+    if not COLOR_ENABLED:
+        return text
+    return f"\033[{code}m{text}\033[0m"

tracevector-2.5.0/tvx/config.py

@@ -0,0 +1,27 @@
+import json
+import os
+
+CONFIG_PATH = os.path.expanduser("~/.tracevector_config.json")
+
+
+def _load():
+    if not os.path.exists(CONFIG_PATH):
+        return {}
+    with open(CONFIG_PATH, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def _save(data: dict):
+    with open(CONFIG_PATH, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+def set_key(key: str, value: str):
+    config = _load()
+    config[key] = value
+    _save(config)
+
+
+def get_key(key: str, default=None):
+    config = _load()
+    return config.get(key, default)

tracevector-2.5.0/tvx/doctor.py

@@ -0,0 +1,39 @@
+import sys
+import platform
+from importlib import util
+
+from tvx import __version__
+from tvx import plugin_loader
+
+
+def run_doctor():
+    print("TRACEVECTOR Doctor\n")
+
+    # Version
+    print(f"[+] Version: {__version__}")
+
+    # Frozen binary check
+    frozen = getattr(sys, "frozen", False)
+    print(f"[+] Frozen binary: {frozen}")
+
+    # Python executable
+    print(f"[+] Python: {sys.executable}")
+
+    # Platform
+    print(f"[+] Platform: {platform.system()} {platform.release()}")
+
+    # Plugin diagnostics
+    plugins = []
+    try:
+        plugins = plugin_loader.list_plugins()
+    except Exception as e:
+        print(f"[!] Plugin loader error: {e}")
+
+    print(f"[+] Plugins detected: {len(plugins)}")
+
+    for p in plugins:
+        name = p.get("command", "unknown")
+        desc = p.get("name", "unnamed plugin")
+        print(f"    - [{name}] {desc}")
+
+    print("\n[✓] Environment looks healthy")

tracevector-2.5.0/tvx/email.py

@@ -0,0 +1,9 @@
+import re
+class EmailPlugin:
+    name = "email"
+
+    def run(self, target):
+        return {
+            "target": target,
+            "disposable_email": False
+        }

tracevector-2.5.0/tvx/ip.py

@@ -0,0 +1,8 @@
+import requests
+
+def investigate_ip(ip):
+    url = f"http://ip-api.com/json/{ip}"
+    data = requests.get(url).json()
+
+    for k, v in data.items():
+        print(f"[+] {k}: {v}")

tracevector-2.5.0/tvx/main.py

@@ -0,0 +1,170 @@
+import argparse
+import json
+import sys
+from datetime import datetime
+
+from tvx.plugin_loader import load_plugins
+from tvx.scoring import calculate_risk
+from tvx.reporting import generate_html
+from tvx.config import set_key
+from tvx.storage.manager import get_storage
+
+
+# =====================================
+# Banner
+# =====================================
+def print_banner():
+    print(r"""
+████████╗██████╗  █████╗  ██████╗███████╗
+╚══██╔══╝██╔══██╗██╔══██╗██╔════╝██╔════╝
+   ██║   ██████╔╝███████║██║     █████╗
+   ██║   ██╔══██╗██╔══██║██║     ██╔══╝
+   ██║   ██║  ██║██║  ██║╚██████╗███████╗
+   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚══════╝
+
+        TRACEVECTOR FRAUD INTELLIGENCE
+""")
+
+
+# =====================================
+# Main
+# =====================================
+def main():
+    parser = argparse.ArgumentParser(
+        prog="tvx",
+        description="TraceVector Fraud Intelligence Toolkit"
+    )
+
+    parser.add_argument("command", help="Core command or plugin")
+    parser.add_argument("args", nargs="*", help="Command arguments")
+    parser.add_argument("--json", action="store_true", help="Output JSON")
+    parser.add_argument("--report", help="Generate HTML report")
+
+    parsed = parser.parse_args()
+
+    print_banner()
+
+    command = parsed.command
+    arguments = parsed.args
+
+    # =========================
+    # CORE: CONFIG
+    # =========================
+    if command == "config":
+        if not arguments or "=" not in arguments[0]:
+            print("Usage: tvx config key=value")
+            sys.exit(1)
+
+        key, value = arguments[0].split("=", 1)
+        set_key(key.strip(), value.strip())
+        print(f"[✓] Config saved: {key}")
+        sys.exit(0)
+
+    # =========================
+    # CORE: CASE
+    # =========================
+    if command == "case":
+        if not arguments:
+            print("Usage: tvx case <create|add|show>")
+            sys.exit(1)
+
+        action = arguments[0]
+        storage = get_storage()
+
+        # CREATE
+        if action == "create":
+            if len(arguments) < 2:
+                print("Usage: tvx case create CASE_ID")
+                sys.exit(1)
+
+            case_id = arguments[1]
+            storage.create_case(case_id)
+            print(f"[✓] Case created: {case_id}")
+            sys.exit(0)
+
+        # ADD
+        if action == "add":
+            if len(arguments) < 4:
+                print("Usage: tvx case add CASE_ID plugin target")
+                sys.exit(1)
+
+            case_id = arguments[1]
+            plugin_name = arguments[2]
+            target = arguments[3]
+
+            plugins = load_plugins()
+
+            if plugin_name not in plugins:
+                print("[!] Unknown plugin")
+                sys.exit(1)
+
+            plugin = plugins[plugin_name]
+            result = plugin.run(target)
+            risk = calculate_risk(result)
+
+            storage.add_evidence(case_id, plugin_name, target, result, risk)
+
+            print(f"[✓] Evidence added to case {case_id}")
+            print(f"Risk Level: {risk['level']} (Score: {risk['score']})")
+            sys.exit(0)
+
+        # SHOW
+        if action == "show":
+            if len(arguments) < 2:
+                print("Usage: tvx case show CASE_ID")
+                sys.exit(1)
+
+            case_id = arguments[1]
+            case_data = storage.get_case(case_id)
+
+            if not case_data["case"]:
+                print("[!] Case not found.")
+                sys.exit(1)
+
+            print(json.dumps(case_data, indent=2))
+            sys.exit(0)
+
+        print("Unknown case action.")
+        sys.exit(1)
+
+    # =========================
+    # PLUGIN EXECUTION
+    # =========================
+    plugins = load_plugins()
+
+    if command not in plugins:
+        print(f"[!] Unknown command: {command}")
+        print("Available plugins:", ", ".join(plugins.keys()))
+        sys.exit(1)
+
+    if not arguments:
+        print("[!] Target required.")
+        sys.exit(1)
+
+    target = arguments[0]
+    plugin = plugins[command]
+
+    try:
+        result = plugin.run(target)
+    except Exception as e:
+        print(f"[!] Plugin execution failed: {e}")
+        sys.exit(1)
+
+    risk = calculate_risk(result)
+
+    output = {
+        "scan": result,
+        "risk": risk
+    }
+
+    if parsed.json:
+        print(json.dumps(output, indent=2))
+    else:
+        print("\n=== Scan Result ===")
+        print(json.dumps(result, indent=2))
+        print("\n=== Risk Assessment ===")
+        print(json.dumps(risk, indent=2))
+
+    if parsed.report:
+        file_path = generate_html(output, risk, parsed.report)
+        print(f"\n[✓] HTML report generated: {file_path}")

tracevector-2.5.0/tvx/phone.py

@@ -0,0 +1,16 @@
+try:
+    import phonenumbers
+    from phonenumbers import geocoder, carrier
+except ImportError:
+    print("[!] Missing dependency: phonenumbers")
+    print("Run: pip install phonenumbers")
+    exit(1)
+
+def investigate_phone(number):
+    try:
+        parsed = phonenumbers.parse(number)
+        print("[+] Valid Number:", phonenumbers.is_valid_number(parsed))
+        print("[+] Country:", geocoder.description_for_number(parsed, "en"))
+        print("[+] Carrier:", carrier.name_for_number(parsed, "en"))
+    except Exception as e:
+        print("[!] Error:", e)

tracevector-2.5.0/tvx/plugin_loader.py

@@ -0,0 +1,31 @@
+import importlib
+import inspect
+
+PLUGIN_MODULES = [
+    "tvx.email",
+    "tvx.phone",
+    "tvx.ip",
+]
+
+
+def load_plugins():
+    plugins = {}
+
+    for module_path in PLUGIN_MODULES:
+        try:
+            module = importlib.import_module(module_path)
+
+            # Look for a class with a run() method
+            for name, obj in inspect.getmembers(module):
+                if inspect.isclass(obj) and hasattr(obj, "run"):
+                    instance = obj()
+
+                    # Use class attribute if available
+                    plugin_name = getattr(instance, "name", module_path.split(".")[-1])
+
+                    plugins[plugin_name] = instance
+
+        except Exception:
+            continue
+
+    return plugins

tracevector-2.5.0/tvx/plugin_security.py

@@ -0,0 +1,8 @@
+import hashlib
+
+def sha256_file(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            h.update(chunk)
+    return h.hexdigest()

tracevector-2.5.0/tvx/plugins/email_basic.py

@@ -0,0 +1,18 @@
+COMMAND = "email"
+
+class Plugin:
+    name = "Basic Email Metadata"
+
+    def run(self, args):
+        target = args[0] if args else None
+
+        print("[PLUGIN] Basic Email Metadata")
+        print(f"input: {target}")
+
+        if not target or "@" not in target:
+            print("error: invalid email")
+            return
+
+        domain = target.split("@")[-1]
+        print(f"domain: {domain}")
+        print("status: plugin_loaded_successfully")

tracevector-2.5.0/tvx/plugins/email_osint.py

@@ -0,0 +1,61 @@
+import dns.resolver
+import re
+import hashlib
+
+COMMAND = "email"
+
+class Plugin:
+    name = "Email OSINT Analysis"
+
+    def run(self, args):
+        email = args[0]
+        domain = email.split("@")[-1]
+
+        result = {
+            "target": email,
+            "metadata": {},
+            "risk": {"score": 0, "level": "low"},
+            "sources": [],
+            "notes": []
+        }
+
+        # Basic validation
+        if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
+            result["notes"].append("Invalid email format")
+            result["risk"]["score"] += 50
+            return result
+
+        # MX Records
+        try:
+            mx = dns.resolver.resolve(domain, "MX")
+            result["metadata"]["mx_records"] = [r.exchange.to_text() for r in mx]
+        except Exception:
+            result["metadata"]["mx_records"] = []
+            result["risk"]["score"] += 30
+            result["notes"].append("No MX records")
+
+        # Provider detection
+        if "google.com" in str(result["metadata"].get("mx_records", "")):
+            result["metadata"]["provider"] = "Google"
+        else:
+            result["metadata"]["provider"] = "Unknown"
+
+        # Disposable check (basic)
+        disposable_domains = {"mailinator.com", "tempmail.com"}
+        if domain in disposable_domains:
+            result["risk"]["score"] += 40
+            result["notes"].append("Disposable email domain")
+
+        # Risk level
+        result["risk"]["level"] = score_level(result["risk"]["score"])
+        result["sources"].append("DNS")
+
+        return result
+
+
+def score_level(score):
+    if score >= 70:
+        return "high"
+    if score >= 40:
+        return "medium"
+    return "low"

tracevector-2.5.0/tvx/plugins/ip_basic.py

@@ -0,0 +1,20 @@
+import ipaddress
+
+COMMAND = "ip"
+
+class Plugin:
+    name = "Basic IP Metadata"
+
+    def run(self, args):
+        target = args[0] if args else None
+
+        print("[PLUGIN] Basic IP Metadata")
+        print(f"input: {target}")
+
+        try:
+            ip = ipaddress.ip_address(target)
+            print(f"version: IPv{ip.version}")
+            print("is_private:", ip.is_private)
+            print("status: plugin_loaded_successfully")
+        except ValueError:
+            print("error: invalid IP address")

tracevector-2.5.0/tvx/plugins/ip_osint.py

@@ -0,0 +1,59 @@
+import ipaddress
+from ipwhois import IPWhois
+
+COMMAND = "ip"
+
+class Plugin:
+    name = "IP OSINT Analysis"
+
+    def run(self, args):
+        ip = args[0]
+
+        result = {
+            "target": ip,
+            "metadata": {},
+            "risk": {"score": 0, "level": "low"},
+            "sources": [],
+            "notes": []
+        }
+
+        try:
+            ip_obj = ipaddress.ip_address(ip)
+        except ValueError:
+            result["notes"].append("Invalid IP address")
+            result["risk"]["score"] = 100
+            result["risk"]["level"] = "high"
+            return result
+
+        # Private IP check
+        if ip_obj.is_private:
+            result["notes"].append("Private IP address")
+            result["risk"]["score"] += 10
+
+        # WHOIS
+        try:
+            whois = IPWhois(ip).lookup_rdap()
+            result["metadata"]["asn"] = whois.get("asn")
+            result["metadata"]["org"] = whois.get("network", {}).get("name")
+        except Exception:
+            result["notes"].append("WHOIS lookup failed")
+            result["risk"]["score"] += 20
+
+        # Datacenter heuristic
+        org = str(result["metadata"].get("org", "")).lower()
+        if any(k in org for k in ["google", "amazon", "cloud", "hosting"]):
+            result["notes"].append("Datacenter / hosting IP")
+            result["risk"]["score"] += 20
+
+        result["risk"]["level"] = score_level(result["risk"]["score"])
+        result["sources"].append("RDAP")
+
+        return result
+
+
+def score_level(score):
+    if score >= 70:
+        return "high"
+    if score >= 40:
+        return "medium"
+    return "low"

tracevector-2.5.0/tvx/plugins/phone_basic.py

@@ -0,0 +1,13 @@
+COMMAND = "phone"
+NAME = "Basic Phone Metadata"
+
+def run(args):
+    phone = args[0] if args else "N/A"
+
+    print("=" * 50)
+    print("[PLUGIN] Basic Phone Metadata")
+    print("-" * 50)
+    print(f"input: {phone}")
+    print("country: Unknown")
+    print("carrier: Unknown")
+    print("risk_score: 20/100")

tracevector-2.5.0/tvx/reporting.py

@@ -0,0 +1,67 @@
+import os
+from datetime import datetime
+
+
+def generate_html(scan_data: dict, risk_data: dict, filename: str) -> str:
+    """
+    Generate simple HTML fraud investigation report.
+    """
+
+    if not filename.endswith(".html"):
+        filename += ".html"
+
+    html_content = f"""
+    <html>
+    <head>
+        <title>TraceVector Fraud Report</title>
+        <style>
+            body {{
+                font-family: Arial, sans-serif;
+                margin: 40px;
+                background-color: #f4f4f4;
+            }}
+            h1 {{
+                color: #222;
+            }}
+            .box {{
+                background: white;
+                padding: 20px;
+                margin-bottom: 20px;
+                border-radius: 8px;
+                box-shadow: 0 0 10px rgba(0,0,0,0.05);
+            }}
+            .high {{ color: red; }}
+            .medium {{ color: orange; }}
+            .low {{ color: green; }}
+        </style>
+    </head>
+    <body>
+        <h1>TraceVector Fraud Investigation Report</h1>
+        <p><strong>Generated:</strong> {datetime.utcnow().isoformat()} UTC</p>
+
+        <div class="box">
+            <h2>Scan Result</h2>
+            <pre>{scan_data}</pre>
+        </div>
+
+        <div class="box">
+            <h2>Risk Assessment</h2>
+            <p><strong>Score:</strong> {risk_data.get("score")}</p>
+            <p><strong>Level:</strong> 
+                <span class="{risk_data.get("level", "").lower()}">
+                    {risk_data.get("level")}
+                </span>
+            </p>
+            <p><strong>Flags:</strong></p>
+            <ul>
+                {''.join(f'<li>{flag}</li>' for flag in risk_data.get("flags", []))}
+            </ul>
+        </div>
+    </body>
+    </html>
+    """
+
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(html_content)
+
+    return os.path.abspath(filename)

tracevector-2.5.0/tvx/risk.py

@@ -0,0 +1,10 @@
+def normalize(score):
+    return min(100, max(0, score))
+
+def level(score):
+    score = normalize(score)
+    if score >= 70:
+        return "high"
+    if score >= 40:
+        return "medium"
+    return "low"

tracevector-2.5.0/tvx/scoring.py

@@ -0,0 +1,38 @@
+def calculate_risk(result: dict) -> dict:
+    """
+    Simple fraud risk scoring engine.
+    """
+
+    score = 0
+    flags = []
+
+    # Example signals
+    if result.get("disposable_email"):
+        score += 40
+        flags.append("Disposable email provider")
+
+    if result.get("tor_exit"):
+        score += 50
+        flags.append("Tor exit node detected")
+
+    if result.get("vpn"):
+        score += 30
+        flags.append("VPN usage suspected")
+
+    if result.get("blacklisted"):
+        score += 60
+        flags.append("Found in blacklist")
+
+    # Risk level
+    if score >= 80:
+        level = "HIGH"
+    elif score >= 40:
+        level = "MEDIUM"
+    else:
+        level = "LOW"
+
+    return {
+        "score": score,
+        "level": level,
+        "flags": flags
+    }

tracevector-2.5.0/tvx/storage/base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+
+
+class BaseStorage(ABC):
+
+    @abstractmethod
+    def init(self):
+        pass
+
+    @abstractmethod
+    def create_case(self, case_id: str):
+        pass
+
+    @abstractmethod
+    def add_scan(self, case_id: str, scan_data: dict):
+        pass
+
+    @abstractmethod
+    def get_case(self, case_id: str):
+        pass

tracevector-2.5.0/tvx/storage/manager.py

@@ -0,0 +1,96 @@
+import sqlite3
+import json
+import os
+from datetime import datetime
+
+DB_PATH = os.path.expanduser("~/.tracevector_cases.db")
+
+
+def _connect():
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def _init():
+    conn = _connect()
+    cur = conn.cursor()
+
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS cases (
+            id TEXT PRIMARY KEY,
+            created_at TEXT
+        )
+    """)
+
+    cur.execute("""
+        CREATE TABLE IF NOT EXISTS evidence (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            case_id TEXT,
+            plugin TEXT,
+            target TEXT,
+            result TEXT,
+            risk TEXT,
+            created_at TEXT
+        )
+    """)
+
+    conn.commit()
+    conn.close()
+
+
+class Storage:
+
+    def __init__(self):
+        _init()
+
+    def create_case(self, case_id):
+        conn = _connect()
+        cur = conn.cursor()
+        cur.execute(
+            "INSERT INTO cases (id, created_at) VALUES (?, ?)",
+            (case_id, datetime.utcnow().isoformat())
+        )
+        conn.commit()
+        conn.close()
+
+    def add_evidence(self, case_id, plugin, target, result, risk):
+        conn = _connect()
+        cur = conn.cursor()
+        cur.execute(
+            """
+            INSERT INTO evidence (case_id, plugin, target, result, risk, created_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                case_id,
+                plugin,
+                target,
+                json.dumps(result),
+                json.dumps(risk),
+                datetime.utcnow().isoformat()
+            )
+        )
+        conn.commit()
+        conn.close()
+
+    def get_case(self, case_id):
+        conn = _connect()
+        cur = conn.cursor()
+
+        cur.execute("SELECT * FROM cases WHERE id=?", (case_id,))
+        case = cur.fetchone()
+
+        cur.execute("SELECT * FROM evidence WHERE case_id=?", (case_id,))
+        evidence = cur.fetchall()
+
+        conn.close()
+
+        return {
+            "case": dict(case) if case else None,
+            "evidence": [dict(e) for e in evidence]
+        }
+
+
+def get_storage():
+    return Storage()

tracevector-2.5.0/tvx/storage/sqlite.py

@@ -0,0 +1,68 @@
+import sqlite3
+import json
+from datetime import datetime
+
+from tvx.storage.base import BaseStorage
+
+
+class SQLiteStorage(BaseStorage):
+
+    def __init__(self, db_path="tracevector.db"):
+        self.db_path = db_path
+        self.conn = sqlite3.connect(self.db_path)
+        self.conn.row_factory = sqlite3.Row
+
+    def init(self):
+        cursor = self.conn.cursor()
+
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS cases (
+            id TEXT PRIMARY KEY,
+            created_at TEXT
+        )
+        """)
+
+        cursor.execute("""
+        CREATE TABLE IF NOT EXISTS scans (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            case_id TEXT,
+            timestamp TEXT,
+            scan_json TEXT,
+            FOREIGN KEY(case_id) REFERENCES cases(id)
+        )
+        """)
+
+        self.conn.commit()
+
+    def create_case(self, case_id: str):
+        cursor = self.conn.cursor()
+        cursor.execute(
+            "INSERT INTO cases (id, created_at) VALUES (?, ?)",
+            (case_id, datetime.utcnow().isoformat())
+        )
+        self.conn.commit()
+
+    def add_scan(self, case_id: str, scan_data: dict):
+        cursor = self.conn.cursor()
+        cursor.execute(
+            "INSERT INTO scans (case_id, timestamp, scan_json) VALUES (?, ?, ?)",
+            (
+                case_id,
+                datetime.utcnow().isoformat(),
+                json.dumps(scan_data)
+            )
+        )
+        self.conn.commit()
+
+    def get_case(self, case_id: str):
+        cursor = self.conn.cursor()
+        cursor.execute("SELECT * FROM cases WHERE id = ?", (case_id,))
+        case = cursor.fetchone()
+
+        cursor.execute("SELECT * FROM scans WHERE case_id = ?", (case_id,))
+        scans = cursor.fetchall()
+
+        return {
+            "case": dict(case) if case else None,
+            "scans": [dict(s) for s in scans]
+        }

tracevector-2.5.0/tvx/version.py

@@ -0,0 +1,2 @@
+VERSION = "1.0.0"
+BUILD = "stable"