## What it is

Slick Browser is a deliberately simple day-to-day utility for people who spend time inside directory trees: sysadmins, analysts, students, educators, and anyone doing structure reviews, forensics, project template shaping, or routine data management.

Design principle: quick and painless. Build a tree. Export HTML. Open in a real browser. Done.

The exported report is a single HTML file containing a clickable directory map. Folders are collapsed by default and expand on demand. Files are clickable via `file://` links.

Primary use
Directory forensics + mapping
Output
Standalone HTML report
Philosophy
Minimal UI, maximum clarity
Typical users
IT / IR / students / devs

### Why it exists

- Structure reviews without manually clicking through file managers.
- Project templating: export a canonical tree and compare against a standard.
- Forensics triage: map a directory quickly, preserve the view, share it.
- Documentation: generate a living “shape of the repo” snapshot as a report artifact.
- Education: demonstrate directory hygiene, naming, and hierarchy in a visible format.

## At a glance

Core controls

- Path: Select the root directory.
- Depth: Limit recursion depth.
- Exclude: Filter out patterns (globs).
- Item cap: Safety limit for huge trees.
- Export: Save the report as HTML.

Dependencies

None (stdlib only). Requires Python 3.9+ with Tk support.

Recommended environment

- Linux / Windows / macOS (any OS with Python + Tk)
- A modern browser (Firefox/Chrome) for viewing reports

## Installation

This project is intentionally lightweight. No pip installs required.

Run

    python3 slick.py

Linux note: Some minimal Python installs do not include Tk by default.

    sudo apt install python3-tk

If Slick launches, you’re done. If Tk is missing, install the OS package above.

## Workflow

1. Select a root directory (Path).
2. Set Depth (how far down the tree to map).
3. Set Exclude patterns to ignore noise directories/files.
4. Export to HTML.
5. Open the exported report in a real browser.

### Export output behavior

- Folders are rendered as `<details>` nodes: collapsed by default.
- Files are clickable via `file://` links (OS/browser policy dependent).
- Output is a single portable HTML file: easy to archive, share, or attach to reports.

## Exclude filter

The exclude filter supports glob patterns, separated by commas or pipes. It matches both the item name and the relative path.

Example patterns

    .git, node_modules, __pycache__, *.pyc, .cache
    .cache|.local/share/Trash|*.log
    dist, build, *.tmp, *.bak

Practical tip: exclude high-churn folders to keep reports readable and fast.

## Depth and item cap

Depth keeps exports purposeful. Item cap prevents accidental “export the entire planet” events.

- Depth: controls recursion depth (0 = root only).
- Item cap: stops output after N items for stability.

For most daily work: Depth 2–4 is the sweet spot.

## Use cases

- Incident response: map suspicious directories, preserve a snapshot for case notes.
- Repo standardization: export tree for each project and compare to a canonical structure.
- Hand-off documentation: provide a “where things live” report with onboarding materials.
- Archive validation: ensure backups contain expected hierarchy before long-term storage.
- Education: teach directory patterns, naming conventions, and separation of concerns.

## Security and privacy

Slick Browser reads filesystem metadata (names/paths) to generate the tree. It does not upload anything. The output report is local unless you choose to share it.

- Local-only: no network calls required for operation.
- Data exposed: file and folder names (and relative paths).
- Be mindful: exported HTML is a map. Treat it like any internal documentation artifact.

Best practice: export from a dedicated analysis copy of sensitive data, not a live environment.

## Limitations

- Browser policies: some browsers restrict `file://` link behavior depending on settings.
- Very large trees: use Depth, Exclude, and Item Cap for performance and readability.
- Names only: the report focuses on structure, not file contents.

## Engineering notes

Slick Browser is intentionally boring in the best way: standard library only, predictable output, and no embedded HTML renderer to freeze the UI.

- Filesystem scan: uses fast directory iteration to gather entries.
- Output: generates deterministic HTML for archival and diff-friendly review.
- UI: small control surface to reduce friction and reduce operator error.

“Minimal surface area” reduces the chance of a tool becoming the problem during analysis.

## Roadmap (optional ideas)

The app is intentionally basic. These are optional extensions if you ever want “just enough more.”

- Include file sizes and modified timestamps (toggleable).
- Add client-side search within the exported HTML report.
- Export JSON alongside HTML for tooling pipelines.
- Add a “compare two trees” report mode (baseline vs current).