envbot 1.0.0__py3-none-any.whl

cli.py

@@ -0,0 +1,481 @@
+"""
+cli.py
+Entry point for the envbot CLI.
+
+Usage
+-----
+  envbot "mongodb connection string"
+  envbot "openai key" --k 5
+  envbot "azure storage" --show-source
+  envbot --reindex
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    BarColumn,
+    TaskProgressColumn,
+    TimeElapsedColumn,
+)
+from rich.rule import Rule
+from rich import box
+
+app = typer.Typer(
+    name="envbot",
+    help="Local AI-powered environment variable search assistant.",
+    add_completion=False,
+    invoke_without_command=True,
+)
+
+console = Console(highlight=False)
+err_console = Console(stderr=True, highlight=False)
+
+# ── Branding ──────────────────────────────────────────────────────────────────
+
+BANNER = r"""
+                      _           _
+   ___ _ ____   _____| |__   ___ | |_
+  / _ | '_ \ \ / / __| '_ \ / _ \| __|
+ |  __| | | \ V /| (__| |_) | (_) | |_
+  \___|_| |_|\_/  \___|_.__/ \___/ \__|
+"""
+
+ACCENT    = "bright_cyan"
+SUCCESS   = "bright_green"
+WARN      = "bright_yellow"
+ERR       = "bright_red"
+DIM       = "dim white"
+HIGHLIGHT = "bold bright_magenta"
+
+
+def _print_banner() -> None:
+    """Print the envbot ASCII art banner inside a styled panel."""
+    banner_text = Text(BANNER, style=f"bold {ACCENT}")
+    tagline = Text(
+        "  AI-powered .env variable search assistant\n",
+        style=f"italic {DIM}",
+    )
+    content = Text.assemble(banner_text, tagline)
+    console.print(
+        Panel(
+            content,
+            border_style=ACCENT,
+            box=box.DOUBLE_EDGE,
+            padding=(0, 2),
+        )
+    )
+
+
+# ── Reindex pipeline ─────────────────────────────────────────────────────────
+
+def _do_reindex() -> None:
+    """Full reindex pipeline: scan -> parse -> embed -> save."""
+    from scanner import scan_and_copy
+    from parser import parse_all
+    from indexer import build_index
+
+    console.print()
+    console.print(Rule("[bold bright_cyan] REINDEX PIPELINE [/bold bright_cyan]", style=ACCENT))
+    console.print()
+
+    with Progress(
+        SpinnerColumn("dots", style=f"bold {WARN}"),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(bar_width=30, style=DIM, complete_style=ACCENT, finished_style=SUCCESS),
+        TaskProgressColumn(),
+        TimeElapsedColumn(),
+        console=console,
+        transient=False,
+    ) as progress:
+
+        # Step 1: Scan
+        task_scan = progress.add_task(
+            f"[{WARN}]Scanning drives for .env files...", total=100
+        )
+        progress.update(task_scan, advance=10)
+        meta = scan_and_copy()
+        progress.update(task_scan, completed=100,
+                        description=f"[{SUCCESS}]Scanned -- {len(meta)} env file(s) found")
+
+        # Step 2: Parse
+        task_parse = progress.add_task(
+            f"[{WARN}]Parsing environment variables...", total=100
+        )
+        progress.update(task_parse, advance=10)
+        records = parse_all()
+        progress.update(task_parse, completed=100,
+                        description=f"[{SUCCESS}]Parsed -- {len(records)} variables extracted")
+
+        if not records:
+            progress.stop()
+            err_console.print(
+                Panel(
+                    "[bold]No variables found.[/bold]\n"
+                    "Make sure your configured drives contain .env files.",
+                    title="Error",
+                    border_style=ERR,
+                    box=box.ROUNDED,
+                )
+            )
+            raise typer.Exit(code=1)
+
+        # Step 3: Embed & index
+        task_embed = progress.add_task(
+            f"[{WARN}]Generating embeddings & building FAISS index...", total=100
+        )
+        progress.update(task_embed, advance=5)
+        build_index(records)
+        progress.update(task_embed, completed=100,
+                        description=f"[{SUCCESS}]Indexed -- {len(records)} vectors saved")
+
+    console.print()
+    console.print(
+        Panel(
+            f"[bold {SUCCESS}]Reindexing complete![/bold {SUCCESS}]\n"
+            f"[{DIM}]Your environment variables are ready to search.",
+            border_style=SUCCESS,
+            box=box.ROUNDED,
+            padding=(0, 2),
+        )
+    )
+
+
+# ── Configuration wizard ─────────────────────────────────────────────────────
+
+def run_config_wizard() -> None:
+    import json
+    import string
+    import os
+    from pathlib import Path
+
+    CONFIG_FILE = Path.home() / ".envbot_config.json"
+
+    _print_banner()
+
+    console.print(
+        Rule("[bold bright_cyan] CONFIGURATION [/bold bright_cyan]", style=ACCENT)
+    )
+    console.print()
+
+    # Load existing config if available
+    existing_config = None
+    if CONFIG_FILE.exists():
+        try:
+            existing_config = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+
+    if existing_config:
+        cfg_table = Table(
+            box=box.SIMPLE_HEAVY,
+            show_header=True,
+            header_style=f"bold {ACCENT}",
+            border_style=DIM,
+            padding=(0, 2),
+        )
+        cfg_table.add_column("Setting", style=f"bold {WARN}")
+        cfg_table.add_column("Value", style=f"bold white")
+
+        drives_str = ", ".join(existing_config.get("scan_drives", []))
+        stored_str = existing_config.get("data_dir", "")
+        cfg_table.add_row("Scan Drives", drives_str)
+        cfg_table.add_row("Storage Path", stored_str)
+
+        console.print(
+            Panel(cfg_table, title="[bold]Current Configuration[/bold]",
+                  border_style=ACCENT, box=box.ROUNDED, padding=(1, 2))
+        )
+        console.print()
+
+        use_existing = typer.confirm("Use this configuration for reindexing?", default=True)
+        if use_existing:
+            return
+
+    console.print()
+
+    # Step 1: Detect available drives / directories
+    is_windows = sys.platform.startswith("win")
+    selected_drives = []
+
+    if is_windows:
+        drives = []
+        for letter in string.ascii_uppercase:
+            drive_path = f"{letter}:\\"
+            if os.path.exists(drive_path):
+                drives.append(drive_path)
+
+        drive_table = Table(box=box.SIMPLE, show_header=False, border_style=DIM)
+        drive_table.add_column("Drive", style=f"bold {ACCENT}")
+        for d in drives:
+            drive_table.add_row(d)
+        console.print(
+            Panel(drive_table, title=f"[bold {ACCENT}]Available Drives[/bold {ACCENT}]",
+                  border_style=ACCENT, box=box.ROUNDED, padding=(0, 2))
+        )
+        console.print()
+
+        while not selected_drives:
+            drives_input = typer.prompt(
+                "Enter drive letter(s) to scan (comma-separated, e.g. C, D)",
+                default="D"
+            )
+            for part in drives_input.split(","):
+                letter = part.strip().upper().replace(":", "").replace("\\", "")
+                if not letter:
+                    continue
+                drive_path = f"{letter}:\\"
+                if os.path.exists(drive_path):
+                    if drive_path not in selected_drives:
+                        selected_drives.append(drive_path)
+                else:
+                    console.print(f"[{WARN}]  Drive {letter}: does not exist or is not ready.[/{WARN}]")
+
+            if not selected_drives:
+                console.print(f"[{ERR}]  Please select at least one valid drive.[/{ERR}]")
+    else:
+        default_dir = str(Path.home())
+        console.print(
+            Panel(
+                f"[{DIM}]Platform: [bold]{sys.platform}[/bold]\n"
+                f"Enter one or more directory paths to scan recursively.",
+                title=f"[bold {ACCENT}]Directory Selection[/bold {ACCENT}]",
+                border_style=ACCENT,
+                box=box.ROUNDED,
+                padding=(0, 2),
+            )
+        )
+        console.print()
+
+        while not selected_drives:
+            paths_input = typer.prompt(
+                "Enter directory path(s) to scan (comma-separated)",
+                default=default_dir
+            )
+            for part in paths_input.split(","):
+                path_str = part.strip()
+                if not path_str:
+                    continue
+                path_obj = Path(path_str).expanduser()
+                if path_obj.exists() and path_obj.is_dir():
+                    res_path = str(path_obj.resolve())
+                    if res_path not in selected_drives:
+                        selected_drives.append(res_path)
+                else:
+                    console.print(f"[{WARN}]  Directory '{path_str}' does not exist or is not a folder.[/{WARN}]")
+
+            if not selected_drives:
+                console.print(f"[{ERR}]  Please select at least one valid directory to scan.[/{ERR}]")
+
+    console.print()
+
+    # Step 2: Storage path
+    default_storage = str(Path.home() / ".envbot_data")
+    valid_storage = False
+    selected_storage = ""
+
+    while not valid_storage:
+        storage_input = typer.prompt(
+            "Enter path to store envbot data",
+            default=default_storage
+        )
+        storage_path = Path(storage_input.strip())
+        try:
+            storage_path.mkdir(parents=True, exist_ok=True)
+            test_file = storage_path / ".write_test"
+            test_file.touch()
+            test_file.unlink()
+            selected_storage = str(storage_path.resolve())
+            valid_storage = True
+        except (PermissionError, OSError) as e:
+            console.print(f"[{ERR}]  Cannot write to '{storage_path}': {e}[/{ERR}]")
+            console.print("  Please enter a different path.")
+
+    # Save config
+    new_config = {
+        "scan_drives": selected_drives,
+        "data_dir": selected_storage
+    }
+    CONFIG_FILE.write_text(json.dumps(new_config, indent=2), encoding="utf-8")
+
+    console.print()
+    # Summary table
+    summary = Table(box=box.SIMPLE_HEAVY, show_header=True,
+                    header_style=f"bold {ACCENT}", border_style=DIM, padding=(0, 2))
+    summary.add_column("Setting", style=f"bold {WARN}")
+    summary.add_column("Value", style=f"bold white")
+    summary.add_row("Scan Drives", ", ".join(selected_drives))
+    summary.add_row("Storage Path", selected_storage)
+
+    console.print(
+        Panel(summary, title=f"[bold {SUCCESS}]Configuration Saved[/bold {SUCCESS}]",
+              border_style=SUCCESS, box=box.DOUBLE_EDGE, padding=(1, 2))
+    )
+    console.print()
+
+
+# ── Search result rendering ───────────────────────────────────────────────────
+
+def _render_results(
+    results: list,
+    show_source: bool,
+    show_value: bool,
+) -> None:
+    """Render search results in a beautiful Rich table."""
+    import re
+    from scanner import COPIED_DIR
+
+    def _get_value(source_file: str, var_name: str) -> str:
+        copied_path = COPIED_DIR / source_file
+        if not copied_path.exists():
+            return "<file not found>"
+        try:
+            content = copied_path.read_text(encoding="utf-8", errors="replace")
+        except Exception:
+            return "<error reading file>"
+
+        pattern = re.compile(
+            r"^\s*(?:export\s+)?" + re.escape(var_name) + r"\s*=\s*(.*)$",
+            re.MULTILINE
+        )
+        match = pattern.search(content)
+        if not match:
+            return "<not found>"
+
+        val = match.group(1).strip()
+        if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+            val = val[1:-1]
+        return val
+
+    # Build the results table
+    table = Table(
+        box=box.ROUNDED,
+        show_header=True,
+        header_style=f"bold {ACCENT}",
+        border_style=ACCENT,
+        padding=(0, 1),
+        title=f"[bold {ACCENT}]Search Results[/bold {ACCENT}]",
+        title_style=f"bold {ACCENT}",
+        caption=f"[{DIM}]{len(results)} result(s) found",
+        caption_style=DIM,
+    )
+
+    table.add_column("#", style=f"bold {DIM}", justify="right", width=3)
+    table.add_column("Variable", style=f"bold {SUCCESS}", min_width=15)
+    if show_value:
+        table.add_column("Value", style=f"bold {WARN}", min_width=15)
+    if show_source:
+        table.add_column("Source", style=f"{DIM}", min_width=20)
+
+    for i, r in enumerate(results, 1):
+        row = [str(i), r.variable_name]
+        if show_value:
+            row.append(_get_value(r.source_file, r.variable_name))
+        if show_source:
+            row.append(r.source_path)
+        table.add_row(*row)
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+# ── Main callback ─────────────────────────────────────────────────────────────
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    query: Optional[str] = typer.Argument(
+        None, help="Natural language search query."
+    ),
+    k: int = typer.Option(
+        3, "--k", "-k", help="Number of results to return.", min=1, max=100
+    ),
+    show_source: bool = typer.Option(
+        False, "--show-source", help="Print the source .env file path."
+    ),
+    show_value: bool = typer.Option(
+        False, "--show-value", "-v", help="Print the variable value (read on-the-fly)."
+    ),
+    reindex: bool = typer.Option(
+        False, "--reindex", help="Rescan configured drives and rebuild the search index."
+    ),
+) -> None:
+    # ── Reindex ────────────────────────────────────────────────────────────
+    if reindex:
+        run_config_wizard()
+        _do_reindex()
+        raise typer.Exit()
+
+    # ── No query supplied -> print help ────────────────────────────────────
+    if not query:
+        _print_banner()
+        console.print(ctx.get_help())
+        raise typer.Exit()
+
+    # ── Search ─────────────────────────────────────────────────────────────
+    try:
+        from search import search
+
+        with Progress(
+            SpinnerColumn("dots", style=f"bold {ACCENT}"),
+            TextColumn(f"[{ACCENT}]Searching for '[bold]{query}[/bold]'..."),
+            console=console,
+            transient=True,
+        ) as progress:
+            progress.add_task("searching", total=None)
+            results = search(query.strip(), k=k)
+
+    except FileNotFoundError as exc:
+        err_console.print(
+            Panel(
+                f"[bold]{exc}[/bold]",
+                title="Index Not Found",
+                border_style=ERR,
+                box=box.ROUNDED,
+            )
+        )
+        raise typer.Exit(code=1)
+    except Exception as exc:
+        err_console.print(
+            Panel(
+                f"[bold]{exc}[/bold]",
+                title="Search Error",
+                border_style=ERR,
+                box=box.ROUNDED,
+            )
+        )
+        raise typer.Exit(code=1)
+
+    if not results:
+        console.print(
+            Panel(
+                f"No matches found for '[bold]{query}[/bold]'.\n"
+                f"[{DIM}]Try a different search term or run --reindex.",
+                border_style=WARN,
+                box=box.ROUNDED,
+            )
+        )
+        raise typer.Exit()
+
+    _render_results(results, show_source, show_value)
+
+
+def entry() -> None:
+    """Setuptools entry point wrapper."""
+    app()
+
+
+if __name__ == "__main__":
+    entry()

envbot-1.0.0.dist-info/METADATA

@@ -0,0 +1,304 @@
+Metadata-Version: 2.4
+Name: envbot
+Version: 1.0.0
+Summary: Local AI-powered environment variable search assistant
+Home-page: https://github.com/ravindraogg/envbot
+Author: Ravi
+Keywords: env environment variables search ai faiss semantic dotenv cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sentence-transformers>=2.7.0
+Requires-Dist: faiss-cpu>=1.8.0
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: numpy>=2.1.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# envbot
+
+**Local AI-powered environment variable search assistant.**
+
+Stop digging through dozens of `.env` files scattered across your projects. `envbot` indexes all your environment variables and lets you find them instantly using natural language search -- powered by sentence embeddings and FAISS.
+
+```
+envbot "mongodb connection string"
+```
+
+```
+                                Search Results
++--------------------------------------------------------------------------+
+|   # | Variable        | Value                        | Source            |
+|-----+-----------------+------------------------------+-------------------|
+|   1 | MONGO_URI       | mongodb+srv://user:pass@c... | D:\App\.env       |
+|   2 | DATABASE_URL    | mongodb://localhost:27017/... | D:\Api\.env       |
+|   3 | DB_CONNECTION   | mongodb://admin@cluster0...  | D:\Svc\.env       |
++--------------------------------------------------------------------------+
+                           3 result(s) found
+```
+
+---
+
+## Features
+
+- **AI-Powered Semantic Search** -- Understands what you mean, not just exact matches. Search for `"stripe payment key"` and it finds `STRIPE_SECRET_KEY`.
+- **Multi-Drive / Multi-Directory Scanning** -- Scan one or more drives (Windows) or directories (macOS/Linux) in a single index.
+- **Cross-Platform** -- Works on Windows, macOS, and Linux.
+- **Interactive Configuration Wizard** -- No config files to edit manually. The CLI guides you through setup.
+- **Zero-Leak Security** -- Variable values are **never stored** in the index. They are only read on-the-fly when you explicitly request them with `-v`.
+- **Beautiful CLI** -- Rich terminal UI with progress bars, spinners, tables, and color-coded output.
+- **Fast** -- FAISS vector search returns results in milliseconds after the initial model load.
+
+---
+
+## Installation
+
+### Prerequisites
+
+- **Python 3.11+** is required.
+- **pip** (comes with Python).
+
+### Option 1: Install from PyPI
+
+```bash
+pip install envbot
+```
+
+### Option 2: Install from GitHub
+
+```bash
+pip install git+https://github.com/your-username/envbot.git
+```
+
+### Option 3: Install from Source
+
+```bash
+git clone https://github.com/your-username/envbot.git
+cd envbot
+pip install .
+```
+
+> **Note:** On first run, `envbot` will automatically download the `all-MiniLM-L6-v2` sentence transformer model (~80 MB). This happens only once.
+
+---
+
+## Quick Start
+
+### Step 1: Configure & Index
+
+Run the reindex command. The interactive wizard will guide you:
+
+```bash
+envbot --reindex
+```
+
+You will be prompted to:
+
+1. **Select drives/directories to scan** -- Choose which drives (Windows: `C, D, E`) or directories (Linux/macOS: `/home/user/projects`) to scan for `.env` files.
+2. **Set storage path** -- Choose where to store the copied `.env` files and the FAISS index. Defaults to `~/.envbot_data`.
+
+The wizard saves your preferences to `~/.envbot_config.json`. On subsequent runs, it will ask if you want to reuse the saved configuration.
+
+### Step 2: Search
+
+```bash
+envbot "database"
+```
+
+That's it! You'll see a table of matching environment variable names.
+
+---
+
+## Usage
+
+All options must be placed **before** the search query.
+
+### Basic Search
+
+```bash
+envbot "openai api key"
+```
+
+### Show Variable Values (`-v`)
+
+Read and display the actual value from the `.env` file on-the-fly:
+
+```bash
+envbot -v "stripe"
+```
+
+### Show Source File Path (`--show-source`)
+
+See which `.env` file each variable came from:
+
+```bash
+envbot --show-source "database"
+```
+
+### Change Number of Results (`-k`)
+
+By default, 3 results are returned. Get more:
+
+```bash
+envbot -k 10 "api key"
+```
+
+### Combine All Flags
+
+```bash
+envbot -v --show-source -k 5 "mongodb"
+```
+
+### Rebuild the Index
+
+Re-scan all configured drives and rebuild the search database:
+
+```bash
+envbot --reindex
+```
+
+### View Help
+
+```bash
+envbot --help
+```
+
+---
+
+## How It Works
+
+```
++------------------+     +------------------+     +------------------+
+|  1. SCAN         | --> |  2. PARSE        | --> |  3. EMBED        |
+|  Recursively     |     |  Extract variable |     |  Generate vector |
+|  find .env files |     |  names (no values)|     |  embeddings via  |
+|  across drives   |     |  from all files   |     |  SentenceTransf. |
++------------------+     +------------------+     +------------------+
+                                                         |
+                                                         v
++------------------+     +------------------+     +------------------+
+|  6. DISPLAY      | <-- |  5. RANK         | <-- |  4. INDEX        |
+|  Rich table with |     |  Cosine similar. |     |  Store vectors   |
+|  colors & values |     |  via FAISS       |     |  in FAISS index  |
++------------------+     +------------------+     +------------------+
+```
+
+### Architecture
+
+| File          | Purpose                                                 |
+|---------------|---------------------------------------------------------|
+| `cli.py`      | Entry point, argument parsing, Rich UI rendering        |
+| `scanner.py`  | Recursively walks drives/directories for `.env` files   |
+| `parser.py`   | Extracts variable names from copied `.env` files        |
+| `indexer.py`  | Generates embeddings and builds the FAISS vector index  |
+| `search.py`   | Encodes queries and performs FAISS similarity search     |
+
+### Security Model
+
+- **Values are never stored** in the FAISS index or metadata files.
+- Only variable **names** and **source file paths** are persisted.
+- When you use `-v`, values are read on-the-fly from the local copy at search time.
+- Copied `.env` files are stored in your configured data directory (default: `~/.envbot_data/copied_envs/`).
+
+---
+
+## Configuration
+
+Your configuration is stored at `~/.envbot_config.json`:
+
+```json
+{
+  "scan_drives": ["D:\\", "E:\\"],
+  "data_dir": "C:\\Users\\you\\.envbot_data"
+}
+```
+
+| Key            | Description                                      |
+|----------------|--------------------------------------------------|
+| `scan_drives`  | List of drives (Windows) or directories to scan  |
+| `data_dir`     | Where the index, metadata, and copies are stored |
+
+You can edit this file manually or re-run `envbot --reindex` to use the wizard.
+
+---
+
+## Command Reference
+
+| Command                                        | Description                          |
+|------------------------------------------------|--------------------------------------|
+| `envbot "query"`                               | Search for matching variables        |
+| `envbot -v "query"`                            | Search and show values               |
+| `envbot --show-source "query"`                 | Search and show source file paths    |
+| `envbot -k 10 "query"`                         | Return up to 10 results              |
+| `envbot -v --show-source -k 5 "query"`         | All flags combined                   |
+| `envbot --reindex`                             | Configure drives and rebuild index   |
+| `envbot --help`                                | Show help message                    |
+
+---
+
+## Requirements
+
+| Package               | Version    | Purpose                        |
+|-----------------------|------------|--------------------------------|
+| `sentence-transformers` | >= 2.7.0 | Semantic text embeddings       |
+| `faiss-cpu`           | >= 1.8.0   | Vector similarity search       |
+| `typer`               | >= 0.12.0  | CLI framework                  |
+| `rich`                | >= 13.7.0  | Terminal UI (tables, spinners) |
+| `python-dotenv`       | >= 1.0.0   | .env file parsing              |
+| `numpy`               | >= 2.1.0   | Numerical operations           |
+| `torch`               | >= 2.0.0   | ML backend for transformers    |
+
+---
+
+## Platform Support
+
+| Platform       | Status      | Drive/Path Format         |
+|----------------|-------------|---------------------------|
+| Windows 10/11  | Supported   | `C:\`, `D:\`, `E:\`       |
+| macOS          | Supported   | `/Users/you/projects`     |
+| Linux          | Supported   | `/home/you/projects`      |
+
+---
+
+## Troubleshooting
+
+### "FAISS index not found" error
+
+You need to build the index first:
+
+```bash
+envbot --reindex
+```
+
+### Slow first search
+
+The first search takes a few seconds because the AI model needs to load into memory. Subsequent searches in the same session are instant.
+
+### Permission errors on Windows
+
+If you see `PermissionError: [WinError 5]`, make sure the storage path is set to a user-writable directory (the default `~/.envbot_data` should work). Re-run `envbot --reindex` to reconfigure.
+
+---
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

envbot-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+cli.py,sha256=ptA5eaymVwO3saANsOC8-mpZUvxxU9QiWedBio2fXgE,16239
+indexer.py,sha256=OqcsJ0_TezEHpgiLpHFvrJFPYYl5qHfIV47BdTyeILk,7412
+parser.py,sha256=vHYqJwJ9ke1qkhcAoinOq1oLfU-5vo58vhak8slTbMc,2229
+scanner.py,sha256=PBv9ABXl-64krnGxQpNSTGE1Vg7N1w7PDAtpTMIyfR8,4365
+search.py,sha256=_Q5lKAKYuvUBomfCCOIrQTZlccFhxioixpp7mDnGD7c,3567
+envbot-1.0.0.dist-info/licenses/LICENSE,sha256=Ucf2A_iir0c2aTbnUNBXd1M1-_plnHrxy-mv2_Wflfs,1061
+envbot-1.0.0.dist-info/METADATA,sha256=8GZa7EIDTqcOE0ZukXCMnUkK5bsv9tIv4bSygrJH_rA,10128
+envbot-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+envbot-1.0.0.dist-info/entry_points.txt,sha256=Xe5cFNsZfSA28KLgxT_8uGHsoHQwMGSHg853BvRiblM,37
+envbot-1.0.0.dist-info/top_level.txt,sha256=IP_R7JTzFR6DHIcNZRzUDtn7cvQxt291Cua0VXVxng4,34
+envbot-1.0.0.dist-info/RECORD,,

envbot-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

envbot-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+envbot = cli:entry

envbot-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ravi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

envbot-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,5 @@
+cli
+indexer
+parser
+scanner
+search

indexer.py

@@ -0,0 +1,187 @@
+"""
+indexer.py
+Generates semantic search text for each variable, embeds with
+all-MiniLM-L6-v2, builds a FAISS index, and persists everything to disk.
+"""
+
+import json
+import re
+from pathlib import Path
+
+import faiss
+import numpy as np
+import os
+
+os.environ["TRANSFORMERS_NO_TF"] = "1"
+os.environ["USE_TF"] = "0"
+
+from sentence_transformers import SentenceTransformer
+
+from scanner import DATA_DIR
+from parser import parse_all
+
+# ── Paths ─────────────────────────────────────────────────────────────────────
+
+FAISS_INDEX_PATH = DATA_DIR / "index.faiss"
+ENV_METADATA_PATH = DATA_DIR / "env_metadata.json"
+
+MODEL_NAME = "all-MiniLM-L6-v2"
+
+# ── Semantic expansion map ────────────────────────────────────────────────────
+# Maps token fragments (lowercase) that appear in variable names to extra
+# semantic context words injected into the search text.
+_EXPANSION: dict[str, str] = {
+    "openai":    "openai gpt llm chatgpt ai language model token",
+    "gpt":       "gpt openai language model chatgpt llm",
+    "anthropic": "anthropic claude ai llm language model",
+    "gemini":    "gemini google ai llm language model",
+    "mongo":     "mongodb mongo database nosql connection string db",
+    "database":  "database db sql connection url string",
+    "db":        "database db sql connection url string",
+    "postgres":  "postgresql postgres relational database sql connection",
+    "mysql":     "mysql relational database sql connection string",
+    "redis":     "redis cache in-memory key-value store connection",
+    "azure":     "azure microsoft cloud storage blob connection string",
+    "aws":       "aws amazon cloud s3 bucket credentials access key",
+    "gcp":       "gcp google cloud platform credentials service account",
+    "s3":        "s3 amazon aws bucket object storage",
+    "firebase":  "firebase google realtime database auth",
+    "supabase":  "supabase postgres database backend auth",
+    "stripe":    "stripe payment gateway api key billing",
+    "paypal":    "paypal payment gateway api key billing",
+    "twilio":    "twilio sms messaging phone api key",
+    "sendgrid":  "sendgrid email smtp delivery api key",
+    "mailgun":   "mailgun email smtp delivery api key",
+    "smtp":      "smtp email mail server host port",
+    "email":     "email smtp mail server sender credentials",
+    "jwt":       "jwt json web token secret auth authentication",
+    "secret":    "secret key token authentication signing",
+    "auth":      "auth authentication authorization token login",
+    "api":       "api key token access credentials",
+    "key":       "key secret token credentials api",
+    "token":     "token auth key bearer access secret",
+    "password":  "password credential login secret",
+    "private":   "private key secret credential",
+    "public":    "public key access endpoint",
+    "url":       "url uri endpoint host connection string",
+    "uri":       "uri url endpoint connection string database",
+    "host":      "host hostname server address url",
+    "port":      "port number server address network",
+    "storage":   "storage bucket blob files cloud",
+    "cdn":       "cdn content delivery network static assets",
+    "webhook":   "webhook callback url endpoint event",
+    "slack":     "slack workspace channel api token webhook",
+    "github":    "github git repository token oauth",
+    "google":    "google oauth credentials client id secret",
+    "facebook":  "facebook oauth credentials app id secret",
+    "twitter":   "twitter x oauth api key bearer token",
+    "debug":     "debug logging development mode flag",
+    "env":       "environment mode staging production development",
+    "next":      "nextjs next.js react frontend",
+    "react":     "react frontend javascript spa",
+    "node":      "nodejs node javascript runtime",
+    "flask":     "flask python web framework",
+    "django":    "django python web framework",
+    "log":       "logging log level debug info",
+    "region":    "region zone cloud datacenter location",
+    "bucket":    "bucket s3 storage cloud object files",
+    "endpoint":  "endpoint url api host address",
+    "connection":"connection string url database",
+    "cert":      "certificate ssl tls security",
+    "ssl":       "ssl tls certificate security https",
+    "tls":       "tls ssl certificate security https",
+}
+
+
+def _human_readable(var_name: str) -> str:
+    """
+    OPENAI_API_KEY  →  'openai api key'
+    Convert UPPER_SNAKE_CASE to lowercase spaced words.
+    """
+    words = var_name.lower().replace("-", "_").split("_")
+    return " ".join(w for w in words if w)
+
+
+def _expand(human: str) -> str:
+    """
+    Inject extra semantic tokens based on word fragments in the variable name.
+    Returns a deduplicated enriched string.
+    """
+    tokens = set(human.split())
+    extras: list[str] = [human]
+
+    for fragment, expansion in _EXPANSION.items():
+        if fragment in human:
+            extras.append(expansion)
+
+    combined = " ".join(extras)
+    # Deduplicate words while preserving order
+    seen: set[str] = set()
+    result: list[str] = []
+    for word in combined.split():
+        if word not in seen:
+            seen.add(word)
+            result.append(word)
+    return " ".join(result)
+
+
+def build_search_text(var_name: str) -> str:
+    human = _human_readable(var_name)
+    return _expand(human)
+
+
+# ── Core indexing ─────────────────────────────────────────────────────────────
+
+def build_index(records: list[dict] | None = None) -> None:
+    """
+    Build (or rebuild) the FAISS index from parsed records.
+    Persists index.faiss and env_metadata.json to DATA_DIR.
+    """
+    if records is None:
+        records = parse_all()
+
+    if not records:
+        raise RuntimeError("No env variable records found. Run scan first.")
+
+    print("  Loading SentenceTransformer...")
+    model = SentenceTransformer(MODEL_NAME)
+    print("  Model loaded")
+
+    print(f"  Generating embeddings for {len(records)} variables...")
+    texts = [build_search_text(r["variable_name"]) for r in records]
+    embeddings: np.ndarray = model.encode(
+        texts,
+        batch_size=128,
+        show_progress_bar=False,
+        convert_to_numpy=True,
+        normalize_embeddings=True,   # cosine sim via inner product
+    )
+
+    dim = embeddings.shape[1]
+    index = faiss.IndexFlatIP(dim)   # Inner Product = cosine on normalised vecs
+    index.add(embeddings.astype(np.float32))
+
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    faiss.write_index(index, str(FAISS_INDEX_PATH))
+
+    # Strip any 'value' field before persisting (security)
+    safe_records = [
+        {
+            "variable_name": r["variable_name"],
+            "source_file":   r["source_file"],
+            "source_path":   r["source_path"],
+        }
+        for r in records
+    ]
+    ENV_METADATA_PATH.write_text(
+        json.dumps(safe_records, indent=2), encoding="utf-8"
+    )
+
+    print(
+        f"  Index built - {index.ntotal} vectors, dim={dim}.\n"
+        f"  Saved to {FAISS_INDEX_PATH}"
+    )
+
+
+if __name__ == "__main__":
+    build_index()

parser.py

@@ -0,0 +1,77 @@
+"""
+parser.py
+Reads all copied .env files from D:\\ENVBOT_DATA\\copied_envs,
+extracts variable names (never values), and returns structured records.
+"""
+
+import re
+from pathlib import Path
+
+from scanner import COPIED_DIR, METADATA_FILE
+import json
+
+# Matches   SOME_VAR=...  or  export SOME_VAR=...
+# Captures only the variable name.
+_VAR_RE = re.compile(r"^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=", re.MULTILINE)
+
+
+def _load_metadata() -> dict[str, str]:
+    """Return mapping  copied_filename → original_path."""
+    if not METADATA_FILE.exists():
+        return {}
+    raw = json.loads(METADATA_FILE.read_text(encoding="utf-8"))
+    return {Path(r["copied_path"]).name: r["original_path"] for r in raw}
+
+
+def parse_all() -> list[dict]:
+    """
+    Parse every .txt file in COPIED_DIR.
+    Returns list of:
+      {
+        "variable_name": "OPENAI_API_KEY",
+        "source_file":   "Projects_App1_env.txt",
+        "source_path":   "D:\\Projects\\App1\\.env"
+      }
+    Values are NEVER stored.
+    """
+    path_map = _load_metadata()
+    records: list[dict] = []
+
+    if not COPIED_DIR.exists():
+        return records
+
+    for txt_file in sorted(COPIED_DIR.glob("*.txt")):
+        try:
+            content = txt_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+
+        original_path = path_map.get(txt_file.name, "unknown")
+
+        for match in _VAR_RE.finditer(content):
+            var_name = match.group(1)
+            records.append(
+                {
+                    "variable_name": var_name,
+                    "source_file": txt_file.name,
+                    "source_path": original_path,
+                }
+            )
+
+    # Deduplicate: same variable from same source file → keep one entry
+    seen: set[tuple[str, str]] = set()
+    deduped: list[dict] = []
+    for r in records:
+        key = (r["variable_name"], r["source_file"])
+        if key not in seen:
+            seen.add(key)
+            deduped.append(r)
+
+    return deduped
+
+
+if __name__ == "__main__":
+    entries = parse_all()
+    print(f"Parsed {len(entries)} unique variable entries.")
+    for e in entries[:10]:
+        print(f"  {e['variable_name']}  ←  {e['source_path']}")

scanner.py

@@ -0,0 +1,140 @@
+"""
+scanner.py
+Recursively scans D:\\ for .env files, copies them to D:\\ENVBOT_DATA\\copied_envs,
+and writes metadata.json.
+"""
+
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+
+# ── Constants ────────────────────────────────────────────────────────────────
+
+CONFIG_FILE = Path.home() / ".envbot_config.json"
+
+def _load_config() -> dict:
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+    return {
+        "scan_drives": ["D:\\"],
+        "data_dir": str(Path.home() / ".envbot_data")
+    }
+
+_config = _load_config()
+SCAN_DRIVES = _config["scan_drives"]
+DATA_DIR = Path(_config["data_dir"])
+COPIED_DIR = DATA_DIR / "copied_envs"
+METADATA_FILE = DATA_DIR / "metadata.json"
+
+TARGET_NAMES = {
+    ".env",
+    ".env.local",
+    ".env.development",
+    ".env.production",
+    ".env.test",
+}
+
+IGNORED_DIRS = {
+    "node_modules",
+    ".git",
+    ".next",
+    "dist",
+    "build",
+    "venv",
+    ".venv",
+    "__pycache__",
+}
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _safe_name(original: Path) -> str:
+    """
+    Convert D:\\Projects\\App1\\.env  →  Projects_App1_env.txt
+    Strips the drive letter, replaces path separators and dots with underscores,
+    collapses leading underscores, appends .txt.
+    """
+    parts = list(original.parts)
+    if original.drive:
+        parts = parts[1:]
+
+    # Join with underscore, strip leading dots from each part
+    sanitised = "_".join(p.lstrip(".").replace(".", "_") for p in parts if p)
+    sanitised = sanitised.replace("\\", "_").replace("/", "_").replace(":", "_")
+    sanitised = sanitised.strip("_") or "unknown"
+    return sanitised + ".txt"
+
+
+def _walk_env_files(root: Path):
+    """Yield Path objects for every matching .env file under root."""
+    try:
+        entries = list(root.iterdir())
+    except (PermissionError, OSError):
+        return
+
+    for entry in entries:
+        try:
+            if entry.is_symlink():
+                continue
+            if entry.is_dir():
+                if entry.name in IGNORED_DIRS:
+                    continue
+                yield from _walk_env_files(entry)
+            elif entry.is_file() and entry.name in TARGET_NAMES:
+                yield entry
+        except (PermissionError, OSError):
+            continue
+
+
+# ── Public API ────────────────────────────────────────────────────────────────
+
+def scan_and_copy() -> list[dict]:
+    """
+    Scan D:\\ for .env files, copy them into COPIED_DIR, write metadata.json.
+    Returns the metadata list.
+    """
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    COPIED_DIR.mkdir(parents=True, exist_ok=True)
+
+    metadata: list[dict] = []
+    seen_names: dict[str, int] = {}
+
+    for drive in SCAN_DRIVES:
+        scan_root = Path(drive)
+        for env_file in _walk_env_files(scan_root):
+            base_name = _safe_name(env_file)
+
+            # Deduplicate: if name already used, append counter
+            if base_name in seen_names:
+                seen_names[base_name] += 1
+                stem = base_name[: -len(".txt")]
+                base_name = f"{stem}_{seen_names[base_name]}.txt"
+            else:
+                seen_names[base_name] = 0
+
+            dest = COPIED_DIR / base_name
+
+            try:
+                shutil.copy2(env_file, dest)
+            except (PermissionError, OSError):
+                continue
+
+            metadata.append(
+                {
+                    "original_path": str(env_file),
+                    "copied_path": str(dest),
+                    "discovered_time": datetime.now(timezone.utc).isoformat(),
+                }
+            )
+
+    METADATA_FILE.write_text(json.dumps(metadata, indent=2), encoding="utf-8")
+    return metadata
+
+
+if __name__ == "__main__":
+    records = scan_and_copy()
+    print(f"Discovered and copied {len(records)} .env file(s).")

search.py

@@ -0,0 +1,119 @@
+"""
+search.py
+Loads the persisted FAISS index and metadata, encodes a query,
+and returns the top-K matching variable names with optional source info.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from functools import lru_cache
+
+import faiss
+import numpy as np
+import os
+
+os.environ["TRANSFORMERS_NO_TF"] = "1"
+os.environ["USE_TF"] = "0"
+
+from sentence_transformers import SentenceTransformer
+
+from scanner import DATA_DIR
+from indexer import FAISS_INDEX_PATH, ENV_METADATA_PATH, MODEL_NAME
+
+DEFAULT_K = 3
+
+
+# ── Lazy singletons ───────────────────────────────────────────────────────────
+
+@lru_cache(maxsize=1)
+def _get_model() -> SentenceTransformer:
+    return SentenceTransformer(MODEL_NAME)
+
+
+@lru_cache(maxsize=1)
+def _get_index() -> faiss.Index:
+    if not FAISS_INDEX_PATH.exists():
+        raise FileNotFoundError(
+            f"FAISS index not found at {FAISS_INDEX_PATH}. "
+            "Run `envbot --reindex` first."
+        )
+    return faiss.read_index(str(FAISS_INDEX_PATH))
+
+
+@lru_cache(maxsize=1)
+def _get_metadata() -> list[dict]:
+    if not ENV_METADATA_PATH.exists():
+        raise FileNotFoundError(
+            f"Metadata not found at {ENV_METADATA_PATH}. "
+            "Run `envbot --reindex` first."
+        )
+    return json.loads(ENV_METADATA_PATH.read_text(encoding="utf-8"))
+
+
+# ── Public search API ─────────────────────────────────────────────────────────
+
+class SearchResult:
+    __slots__ = ("variable_name", "source_file", "source_path")
+
+    def __init__(self, variable_name: str, source_file: str, source_path: str) -> None:
+        self.variable_name = variable_name
+        self.source_file = source_file
+        self.source_path = source_path
+
+
+def search(query: str, k: int = DEFAULT_K) -> list[SearchResult]:
+    """
+    Embed *query*, run FAISS inner-product search, return up to *k* results.
+    Deduplicates on variable_name: if the same name appears in multiple
+    source files, each unique (name, path) pair is kept, but we avoid
+    returning the exact same variable+path combo more than once.
+    """
+    model = _get_model()
+    index = _get_index()
+    metadata = _get_metadata()
+
+    if index.ntotal == 0:
+        return []
+
+    # Encode and normalise query
+    vec: np.ndarray = model.encode(
+        [query],
+        convert_to_numpy=True,
+        normalize_embeddings=True,
+    ).astype(np.float32)
+
+    # Retrieve more candidates so dedup doesn't leave us short
+    fetch_k = min(k * 4, index.ntotal)
+    _, indices = index.search(vec, fetch_k)
+
+    results: list[SearchResult] = []
+    seen: set[tuple[str, str]] = set()
+
+    for idx in indices[0]:
+        if idx < 0 or idx >= len(metadata):
+            continue
+        rec = metadata[idx]
+        key = (rec["variable_name"], rec["source_path"])
+        if key in seen:
+            continue
+        seen.add(key)
+        results.append(
+            SearchResult(
+                variable_name=rec["variable_name"],
+                source_file=rec["source_file"],
+                source_path=rec["source_path"],
+            )
+        )
+        if len(results) >= k:
+            break
+
+    return results
+
+
+if __name__ == "__main__":
+    import sys
+    q = " ".join(sys.argv[1:]) or "mongodb connection string"
+    for r in search(q):
+        print(r.variable_name, "←", r.source_path)