devit-cli 0.1.0__py3-none-any.whl

devkit_cli/commands/clean.py

@@ -0,0 +1,130 @@
+"""devkit clean — Remove build artifacts, caches, and junk files."""
+
+import shutil
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+# Directories to delete entirely
+CLEAN_DIRS = [
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
+    "build",
+    "dist",
+    "*.egg-info",
+    ".eggs",
+    "node_modules",
+    ".next",
+    ".nuxt",
+    "htmlcov",
+    "site",
+    ".tox",
+    ".nox",
+]
+
+# Individual file patterns to delete
+CLEAN_FILES = [
+    "*.pyc",
+    "*.pyo",
+    "*.pyd",
+    ".DS_Store",
+    "Thumbs.db",
+    "*.log",
+    "*.tmp",
+    "*.bak",
+    "*.swp",
+    "*.swo",
+    ".coverage",
+    "coverage.xml",
+    "*.orig",
+]
+
+
+def _iter_matches(root: Path, patterns: list[str]):
+    for pat in patterns:
+        yield from root.rglob(pat)
+
+
+@click.command()
+@click.argument("path", default=".", type=click.Path(exists=True, file_okay=False))
+@click.option("--dry-run", is_flag=True, default=False, help="Show what would be removed without deleting.")
+@click.option("-y", "--yes", is_flag=True, default=False, help="Skip confirmation prompt.")
+@click.option("--include-venv", is_flag=True, default=False, help="Also remove .venv/ directory.")
+def clean(path, dry_run, yes, include_venv):
+    """
+    Remove __pycache__, build artifacts, .DS_Store, and other junk.
+
+    \b
+    Examples:
+      devkit clean               # clean current directory
+      devkit clean ./my-project  # clean a specific directory
+      devkit clean --dry-run     # preview only
+    """
+    root = Path(path).resolve()
+    to_remove: list[Path] = []
+
+    dir_patterns = list(CLEAN_DIRS)
+    if include_venv:
+        dir_patterns.append(".venv")
+
+    for item in _iter_matches(root, dir_patterns):
+        if item.is_dir():
+            to_remove.append(item)
+
+    for item in _iter_matches(root, CLEAN_FILES):
+        if item.is_file():
+            to_remove.append(item)
+
+    # De-duplicate: skip children of already-queued dirs
+    to_remove_set = sorted(set(to_remove), key=lambda p: len(p.parts))
+    final: list[Path] = []
+    queued_dirs: list[Path] = []
+    for item in to_remove_set:
+        if any(item.is_relative_to(d) for d in queued_dirs):
+            continue
+        final.append(item)
+        if item.is_dir():
+            queued_dirs.append(item)
+
+    if not final:
+        console.print("[green]✔[/green] Nothing to clean.")
+        return
+
+    table = Table(title=f"Items to remove ({len(final)})", show_lines=False)
+    table.add_column("Type", style="dim", width=5)
+    table.add_column("Path", style="cyan")
+
+    for item in final:
+        kind = "[blue]DIR[/blue]" if item.is_dir() else "FILE"
+        table.add_row(kind, str(item.relative_to(root)))
+
+    console.print(table)
+
+    if dry_run:
+        console.print("[yellow]Dry-run mode — nothing was deleted.[/yellow]")
+        return
+
+    if not yes:
+        click.confirm(f"Delete {len(final)} item(s)?", abort=True)
+
+    removed_count = 0
+    errors = 0
+    for item in final:
+        try:
+            if item.is_dir():
+                shutil.rmtree(item)
+            else:
+                item.unlink()
+            removed_count += 1
+        except Exception as exc:
+            console.print(f"[red]Error removing {item}: {exc}[/red]")
+            errors += 1
+
+    console.print(f"[green]✔[/green] Removed [bold]{removed_count}[/bold] item(s)." +
+                  (f" [red]{errors} error(s).[/red]" if errors else ""))

devkit_cli/commands/env.py

@@ -0,0 +1,156 @@
+"""devkit env — List, export, diff, and set environment variables."""
+
+import os
+import json
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def _load_dotenv(path: Path) -> dict[str, str]:
+    """Parse a .env file into a dict."""
+    result = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "=" in line:
+            key, _, val = line.partition("=")
+            result[key.strip()] = val.strip().strip('"').strip("'")
+    return result
+
+
+@click.group()
+def env():
+    """Manage and inspect environment variables."""
+    pass
+
+
+@env.command("list")
+@click.option("--filter", "filter_str", default=None, metavar="KEYWORD",
+              help="Only show vars containing this keyword (case-insensitive).")
+@click.option("--json", "as_json", is_flag=True, default=False, help="Output as JSON.")
+def env_list(filter_str, as_json):
+    """
+    List all current environment variables.
+
+    \b
+    Examples:
+      devkit env list
+      devkit env list --filter PATH
+      devkit env list --json
+    """
+    vars_dict = dict(os.environ)
+
+    if filter_str:
+        keyword = filter_str.lower()
+        vars_dict = {k: v for k, v in vars_dict.items()
+                     if keyword in k.lower() or keyword in v.lower()}
+
+    if as_json:
+        click.echo(json.dumps(vars_dict, indent=2))
+        return
+
+    table = Table(title=f"Environment Variables ({len(vars_dict)})")
+    table.add_column("Variable", style="cyan", no_wrap=True)
+    table.add_column("Value", style="green", overflow="fold")
+
+    for key in sorted(vars_dict):
+        table.add_row(key, vars_dict[key])
+
+    console.print(table)
+
+
+@env.command("export")
+@click.argument("output", default=".env", metavar="OUTPUT_FILE")
+@click.option("--filter", "filter_str", default=None, metavar="KEYWORD",
+              help="Only export vars containing this keyword.")
+@click.option("--format", "fmt",
+              type=click.Choice(["dotenv", "json", "shell", "powershell", "cmd"]),
+              default="dotenv", show_default=True,
+              help="Output format. 'shell'=bash export, 'powershell'=$env: syntax, 'cmd'=set syntax.")
+def env_export(output, filter_str, fmt):
+    """
+    Export environment variables to a file.
+
+    \b
+    Examples:
+      devkit env export                         # exports all to .env
+      devkit env export prod.env --filter AWS
+      devkit env export vars.json --format json
+      devkit env export vars.ps1  --format powershell   # Windows PowerShell
+      devkit env export vars.bat  --format cmd          # Windows CMD
+    """
+    vars_dict = dict(os.environ)
+    if filter_str:
+        keyword = filter_str.lower()
+        vars_dict = {k: v for k, v in vars_dict.items()
+                     if keyword in k.lower()}
+
+    out = Path(output)
+
+    if fmt == "dotenv":
+        lines = [f'{k}="{v}"' for k, v in sorted(vars_dict.items())]
+        out.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    elif fmt == "json":
+        out.write_text(json.dumps(vars_dict, indent=2), encoding="utf-8")
+    elif fmt == "shell":
+        lines = [f"export {k}={json.dumps(v)}" for k, v in sorted(vars_dict.items())]
+        out.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    elif fmt == "powershell":
+        lines = [f'$env:{k} = {json.dumps(v)}' for k, v in sorted(vars_dict.items())]
+        out.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    elif fmt == "cmd":
+        # Values with special CMD characters are quoted; newlines replaced with space
+        lines = [f"set {k}={v.replace(chr(10), ' ')}" for k, v in sorted(vars_dict.items())]
+        out.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    console.print(f"[green]✔[/green] Exported [bold]{len(vars_dict)}[/bold] variables to [cyan]{out}[/cyan]")
+
+
+@env.command("diff")
+@click.argument("file_a", type=click.Path(exists=True))
+@click.argument("file_b", type=click.Path(exists=True))
+def env_diff(file_a, file_b):
+    """
+    Diff two .env files and show what changed.
+
+    \b
+    Example:
+      devkit env diff .env .env.production
+    """
+    a = _load_dotenv(Path(file_a))
+    b = _load_dotenv(Path(file_b))
+
+    all_keys = sorted(set(a) | set(b))
+
+    table = Table(title=f"Diff: {file_a}  →  {file_b}")
+    table.add_column("Key", style="cyan")
+    table.add_column(Path(file_a).name, style="dim")
+    table.add_column(Path(file_b).name, style="bold")
+    table.add_column("Status", style="bold")
+
+    changed = 0
+    for key in all_keys:
+        va = a.get(key)
+        vb = b.get(key)
+        if va == vb:
+            continue
+        if va is None:
+            status = "[green]+added[/green]"
+        elif vb is None:
+            status = "[red]-removed[/red]"
+        else:
+            status = "[yellow]~changed[/yellow]"
+        table.add_row(key, va or "—", vb or "—", status)
+        changed += 1
+
+    if changed == 0:
+        console.print("[green]✔[/green] Files are identical.")
+    else:
+        console.print(table)
+        console.print(f"[dim]{changed} difference(s)[/dim]")

devkit_cli/commands/find.py

@@ -0,0 +1,122 @@
+"""devkit find — Fast file search with filters."""
+
+import os
+import stat
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+def _bytes_to_human(n: int) -> str:
+    for unit in ("B", "KB", "MB", "GB"):
+        if n < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} TB"
+
+
+def _parse_size(s: str) -> int:
+    """Parse size strings like '10kb', '2mb', '500' (bytes)."""
+    s = s.strip().lower()
+    multipliers = {"kb": 1024, "mb": 1024**2, "gb": 1024**3, "b": 1}
+    for suffix, mult in multipliers.items():
+        if s.endswith(suffix):
+            return int(float(s[: -len(suffix)]) * mult)
+    return int(s)
+
+
+@click.command()
+@click.argument("pattern", default="*")
+@click.option("-d", "--dir", "search_dir", default=".", show_default=True,
+              type=click.Path(exists=True, file_okay=False),
+              help="Root directory to search.")
+@click.option("-e", "--ext", multiple=True,
+              help="Filter by extension(s), e.g. -e py -e js")
+@click.option("--min-size", default=None, help="Minimum file size, e.g. 10kb.")
+@click.option("--max-size", default=None, help="Maximum file size, e.g. 5mb.")
+@click.option("--newer-than", default=None, metavar="DAYS",
+              help="Files modified within last N days.")
+@click.option("--older-than", default=None, metavar="DAYS",
+              help="Files modified more than N days ago.")
+@click.option("-l", "--limit", default=100, show_default=True,
+              help="Maximum results to display.")
+@click.option("--dirs-only", is_flag=True, default=False,
+              help="Match directories instead of files.")
+def find(pattern, search_dir, ext, min_size, max_size, newer_than, older_than, limit, dirs_only):
+    """
+    Search for files by name pattern with optional filters.
+
+    \b
+    Examples:
+      devkit find "*.py"
+      devkit find "config" -e toml -e ini
+      devkit find "*" --min-size 1mb --newer-than 7
+      devkit find --dirs-only "src"
+    """
+    root = Path(search_dir).resolve()
+    min_bytes = _parse_size(min_size) if min_size else None
+    max_bytes = _parse_size(max_size) if max_size else None
+    newer_cutoff = (datetime.now() - timedelta(days=int(newer_than))).timestamp() if newer_than else None
+    older_cutoff = (datetime.now() - timedelta(days=int(older_than))).timestamp() if older_than else None
+
+    table = Table(title=f"Search: [cyan]{pattern}[/cyan] in [dim]{root}[/dim]",
+                  show_lines=False, expand=False)
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Path", style="cyan")
+    if not dirs_only:
+        table.add_column("Size", justify="right", style="green")
+        table.add_column("Modified", style="dim")
+
+    results: list[Path] = []
+
+    for item in root.rglob(pattern):
+        if dirs_only and not item.is_dir():
+            continue
+        if not dirs_only and not item.is_file():
+            continue
+
+        if ext and item.suffix.lstrip(".").lower() not in [e.lstrip(".").lower() for e in ext]:
+            continue
+
+        try:
+            st = item.stat()
+        except OSError:
+            continue
+
+        if not dirs_only:
+            if min_bytes is not None and st.st_size < min_bytes:
+                continue
+            if max_bytes is not None and st.st_size > max_bytes:
+                continue
+
+        mtime = st.st_mtime
+        if newer_cutoff and mtime < newer_cutoff:
+            continue
+        if older_cutoff and mtime > older_cutoff:
+            continue
+
+        results.append(item)
+        if len(results) >= limit:
+            break
+
+    if not results:
+        console.print("[yellow]No matches found.[/yellow]")
+        return
+
+    for i, item in enumerate(results, 1):
+        rel = item.relative_to(root)
+        if dirs_only:
+            table.add_row(str(i), str(rel))
+        else:
+            st = item.stat()
+            mtime_str = datetime.fromtimestamp(st.st_mtime).strftime("%Y-%m-%d %H:%M")
+            table.add_row(str(i), str(rel), _bytes_to_human(st.st_size), mtime_str)
+
+    console.print(table)
+    console.print(f"[dim]{len(results)} result(s) — limit {limit}[/dim]")

devkit_cli/commands/info.py

@@ -0,0 +1,119 @@
+"""devkit info — Display system, Python, and environment information."""
+
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+
+import click
+import psutil
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.columns import Columns
+
+console = Console()
+
+
+def _bytes_to_human(n: int) -> str:
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024:
+            return f"{n:.1f} {unit}"
+        n /= 1024
+    return f"{n:.1f} PB"
+
+
+def _detect_env() -> tuple[str, str]:
+    """Return (env_type, env_path)."""
+    conda = os.environ.get("CONDA_DEFAULT_ENV")
+    if conda:
+        return "conda", conda
+    venv = os.environ.get("VIRTUAL_ENV")
+    if venv:
+        return "venv", venv
+    return "none", "—"
+
+
+@click.command()
+@click.option("--json", "as_json", is_flag=True, default=False, help="Output as JSON.")
+def info(as_json):
+    """
+    Show system info: OS, Python, CPU, memory, disk, and active environment.
+
+    \b
+    Examples:
+      devkit info
+      devkit info --json
+    """
+    # --- Gather data ---
+    uname = platform.uname()
+    vm = psutil.virtual_memory()
+    disk = psutil.disk_usage(Path.cwd().anchor)
+    cpu_count = psutil.cpu_count(logical=True)
+    cpu_phys = psutil.cpu_count(logical=False)
+    cpu_freq = psutil.cpu_freq()
+    env_type, env_path = _detect_env()
+
+    data = {
+        "os": f"{uname.system} {uname.release}",
+        "machine": uname.machine,
+        "hostname": uname.node,
+        "python_version": sys.version.split()[0],
+        "python_impl": platform.python_implementation(),
+        "python_path": sys.executable,
+        "cpu_logical": cpu_count,
+        "cpu_physical": cpu_phys,
+        "cpu_freq_mhz": f"{cpu_freq.current:.0f} MHz" if cpu_freq else "n/a",
+        "mem_total": _bytes_to_human(vm.total),
+        "mem_used": _bytes_to_human(vm.used),
+        "mem_pct": f"{vm.percent}%",
+        "disk_total": _bytes_to_human(disk.total),
+        "disk_used": _bytes_to_human(disk.used),
+        "disk_pct": f"{disk.percent}%",
+        "env_type": env_type,
+        "env_path": env_path,
+        "cwd": str(Path.cwd()),
+    }
+
+    if as_json:
+        import json
+        click.echo(json.dumps(data, indent=2))
+        return
+
+    # --- Rich tables ---
+    def kv_table(title: str, rows: list[tuple[str, str]]) -> Table:
+        t = Table(title=title, show_header=False, box=None, padding=(0, 2))
+        t.add_column("Key", style="dim", no_wrap=True)
+        t.add_column("Value", style="bold")
+        for k, v in rows:
+            t.add_row(k, v)
+        return t
+
+    sys_table = kv_table("System", [
+        ("OS", data["os"]),
+        ("Arch", data["machine"]),
+        ("Hostname", data["hostname"]),
+        ("CWD", data["cwd"]),
+    ])
+
+    py_table = kv_table("Python", [
+        ("Version", data["python_version"]),
+        ("Impl", data["python_impl"]),
+        ("Executable", data["python_path"]),
+        ("Env Type", data["env_type"]),
+        ("Env Path", data["env_path"]),
+    ])
+
+    hw_table = kv_table("Hardware", [
+        ("CPU (logical)", str(data["cpu_logical"])),
+        ("CPU (physical)", str(data["cpu_physical"])),
+        ("CPU Freq", data["cpu_freq_mhz"]),
+        ("RAM Total", data["mem_total"]),
+        ("RAM Used", f"{data['mem_used']} ({data['mem_pct']})"),
+        ("Disk Total", data["disk_total"]),
+        ("Disk Used", f"{data['disk_used']} ({data['disk_pct']})"),
+    ])
+
+    console.print(Panel("[bold cyan]devkit info[/bold cyan]", expand=False))
+    console.print(Columns([sys_table, py_table, hw_table], equal=False, expand=False))