bhtool 0.1.10__tar.gz

bhtool-0.1.10/.gitignore

@@ -0,0 +1,20 @@
+.DS_Store
+
+# python generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# venv
+.venv
+.idea
+.ruff_cache
+uv.lock
+
+requirements*
+
+node_modules
+package-lock.json

bhtool-0.1.10/.python-version

@@ -0,0 +1 @@
+3.13

bhtool-0.1.10/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: bhtool
+Version: 0.1.10
+Summary: Add your description here
+Author-email: Bosco Ho <apposite@gmail.com>
+Requires-Python: >=3.13
+Requires-Dist: click>=8.1.7
+Requires-Dist: cyclopts>=4.10.2
+Requires-Dist: matplotlib>=3.9.0
+Requires-Dist: microeval>=0.5.0
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: pandas>=2.2.2
+Requires-Dist: path>=16.14.0
+Requires-Dist: pydash>=8.0.3
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: rich>=15.0.0
+Requires-Dist: ruyaml>=0.91.0
+Requires-Dist: semver>=3.0.2
+Description-Content-Type: text/markdown
+
+# bhtool
+
+CLI utilities for version bumping, file conversion, process management, and dev workflows. Python ≥3.12.
+
+**Install:** `uv sync` · `uv pip install -e .` · `uv tool install .` (global)
+
+| Command         | Description                                                       |
+|-----------------|-------------------------------------------------------------------|
+| **bumpver**     | Bump version in pyproject.toml, commit, push, optionally publish  |
+| **a**           | Open macOS apps by partial name (`a chrome`, `a cursor`)          |
+| **clear_chmod** | Strip execute from non-scripts, group/other write                 |
+| **npread**      | Print shape of .npy files                                         |
+| **dfplot**      | Plot parquet/CSV, open figure                                     |
+| **psword**      | Find processes by name; `--kill` to kill                          |
+| **rm_npm**      | Recursively remove node_modules and package-lock.json             |
+| **text2**       | Convert md ↔ html ↔ docx ↔ pug (pandoc)                           |
+| **todict**      | JSON/YAML stdin → Python dict repr                                |
+
+---
+
+# jtools
+
+Node CLI: pug formatting, agent config copy. Usage: `jtools <subcommand>`
+
+**Install:** `cd jtools && npm install`
+
+| Subcommand     | Description                          |
+|----------------|--------------------------------------|
+| **format-pug** | Format pug in ./index.html           |
+| **copy-agent** | Copy ~/.claude/CLAUDE.md → ./AGENT.md |
+
+`npx jtools format-pug` · `npx jtools copy-agent` 

bhtool-0.1.10/README.md

@@ -0,0 +1,32 @@
+# bhtool
+
+CLI utilities for version bumping, file conversion, process management, and dev workflows. Python ≥3.12.
+
+**Install:** `uv sync` · `uv pip install -e .` · `uv tool install .` (global)
+
+| Command         | Description                                                       |
+|-----------------|-------------------------------------------------------------------|
+| **bumpver**     | Bump version in pyproject.toml, commit, push, optionally publish  |
+| **a**           | Open macOS apps by partial name (`a chrome`, `a cursor`)          |
+| **clear_chmod** | Strip execute from non-scripts, group/other write                 |
+| **npread**      | Print shape of .npy files                                         |
+| **dfplot**      | Plot parquet/CSV, open figure                                     |
+| **psword**      | Find processes by name; `--kill` to kill                          |
+| **rm_npm**      | Recursively remove node_modules and package-lock.json             |
+| **text2**       | Convert md ↔ html ↔ docx ↔ pug (pandoc)                           |
+| **todict**      | JSON/YAML stdin → Python dict repr                                |
+
+---
+
+# jtools
+
+Node CLI: pug formatting, agent config copy. Usage: `jtools <subcommand>`
+
+**Install:** `cd jtools && npm install`
+
+| Subcommand     | Description                          |
+|----------------|--------------------------------------|
+| **format-pug** | Format pug in ./index.html           |
+| **copy-agent** | Copy ~/.claude/CLAUDE.md → ./AGENT.md |
+
+`npx jtools format-pug` · `npx jtools copy-agent` 

bhtool-0.1.10/bhtool/bumpver.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+
+"""Bump version in pyproject.toml, commit, push, and optionally publish to PyPI."""
+
+import re
+import sys
+from path import Path
+from typing import Literal
+
+from bhtool.utils import run
+
+
+def bump_version(part: Literal["major", "minor", "patch"] | None = None, *, publish: bool = True):
+    """Bump version in pyproject.toml, commit, push, and publish."""
+    if part is None:
+        from bhtool.cli import app
+
+        app["bumpver"].help_print()
+        return
+
+    pyproject = Path("pyproject.toml")
+    if not pyproject.exists():
+        print("Could not find pyproject.toml")
+        sys.exit(1)
+
+    text = pyproject.read_text()
+    match = re.search(r'^version = "(\d+)\.(\d+)\.(\d+)"', text, re.MULTILINE)
+    if not match:
+        print("Could not find version in pyproject.toml")
+        sys.exit(1)
+
+    major, minor, patch = int(match.group(1)), int(match.group(2)), int(match.group(3))
+    print(f"Current version: {major}.{minor}.{patch}")
+
+    if part == "major":
+        major, minor, patch = major + 1, 0, 0
+    elif part == "minor":
+        minor, patch = minor + 1, 0
+    else:
+        patch += 1
+
+    new_version = f"{major}.{minor}.{patch}"
+    pyproject.write_text(text.replace(match.group(0), f'version = "{new_version}"'))
+    print(f"Version bumped to {new_version}")
+
+    run(f'git commit -am "Bump version to {new_version}"')
+    run("git push")
+
+    if publish:
+        run("uv build")
+        run(f"uv publish dist/*-{new_version}*")

bhtool-0.1.10/bhtool/clear_chmod.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+
+"""Reclaim for user any files that are not shell scripts"""
+
+from path import Path
+
+from bhtool.utils import run
+
+skip_directories = ["__pycache__", "node_modules", ".git"]
+
+
+def clear_chmod_run():
+    for f in Path(".").iterdir():
+        if f.name.startswith("."):
+            continue
+        if f.is_dir():
+            if f.name in skip_directories:
+                continue
+            run(f'chmod og-w "{f}"')
+        else:
+            if not f.endswith("sh") and not f.endswith("bat"):
+                run(f'chmod a-x "{f}"')
+            run(f'chmod og-w "{f}"')

bhtool-0.1.10/bhtool/cli.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+
+"""Unified bhtool CLI (`b` and `bhtool` on PATH)."""
+
+from typing import Literal
+
+from cyclopts import App
+
+from bhtool.run import open_apps
+from bhtool.bumpver import bump_version
+from bhtool.clear_chmod import clear_chmod_run
+from bhtool.npread import npread_run
+from bhtool.psword import psword_run
+from bhtool.rm_npm import rm_npm_run
+from bhtool.text2 import text2_run
+from bhtool.todict import todict_run
+
+app = App(name="bhtool", help="bhtool utilities")
+
+
+@app.command(name="run")
+def run(*params: str):
+    """Open macOS applications by partial name match."""
+    if not params:
+        app["run"].help_print()
+        return
+    open_apps(*params)
+
+
+@app.command
+def bumpver(part: Literal["major", "minor", "patch"] | None = None, *, publish: bool = True):
+    """Bump version in pyproject.toml, commit, push, and optionally publish to PyPI."""
+    bump_version(part, publish=publish)
+
+
+@app.command
+def clear_chmod():
+    """Remove execute permissions from non-script files and write permissions from group/other."""
+    clear_chmod_run()
+
+
+@app.command
+def npread(*files: str):
+    """Print shape of numpy .npy files."""
+    if not files:
+        app["npread"].help_print()
+        return
+    npread_run(files)
+
+
+@app.command(name="dfplot")
+def dfplot_cmd():
+    """Find and plot parquet files from data/results directory."""
+    from bhtool.dfplot import dfplot_run
+
+    dfplot_run()
+
+
+@app.command
+def psword(*words: str, kill: bool = False):
+    """Find processes by name and optionally kill them."""
+    if not words:
+        app["psword"].help_print()
+        return
+    psword_run(words, kill=kill)
+
+
+@app.command
+def rm_npm():
+    """Recursively remove node_modules directories and package-lock.json files."""
+    rm_npm_run()
+
+
+@app.command
+def text2(in_fname: str, out_fname: str):
+    """Interconvert text-based formats: md, pug, docx, html."""
+    text2_run(in_fname, out_fname)
+
+
+@app.command
+def todict(json: str | None = None, yaml: str | None = None):
+    """Convert JSON or YAML to Python dict format."""
+    todict_run(json=json, yaml=yaml)
+
+
+movies_app = App(
+    name="movies",
+    help="Manage movie directories and files: normalize names with LLM.",
+)
+
+
+@movies_app.command
+def rename(root_dir: str | None = None, execute: bool = False):
+    """Rename movie dirs and files to normalized names using mapping from LLM.
+
+    :param root_dir: Root directory containing movies (positional); default is current working directory.
+    :param execute: If true, perform renames; otherwise dry run (table output).
+    """
+    from bhtool.list_movies import movies_rename_impl
+
+    movies_rename_impl(root_dir=root_dir, execute=execute)
+
+
+app.command(movies_app)
+
+
+def main() -> None:
+    app()

bhtool-0.1.10/bhtool/dfplot.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+
+"""Plot parquet files"""
+
+from path import Path
+
+import matplotlib as mpl
+import pandas
+from matplotlib import pyplot as plt
+from pandas.plotting import register_matplotlib_converters
+
+from bhtool.utils import open_path
+
+register_matplotlib_converters()
+
+
+def plot_df_columns_as_scatter(df):
+    mpl.rcParams["xtick.labelsize"] = 6
+    mpl.rcParams["ytick.labelsize"] = 6
+
+    xlim = [df["time"].min(), df["time"].max()]
+    cols = [c for c in df.columns.values if c != "time"]
+    colors = plt.rcParams["axes.prop_cycle"].by_key()["color"]
+    fig, axes = plt.subplots(len(cols), 1, sharex=True, figsize=(7, len(cols) * 1))
+    for i, col in enumerate(cols):
+        ax = axes[i]
+        color = colors[i % len(colors)]
+        ax.scatter(
+            df["time"].values,
+            df[col].values,
+            label=col,
+            s=3,
+            c=color,
+        )
+
+        ax.set_title(col, color=color, fontdict={"fontsize": 10}, pad=0, loc="right")
+
+        ax_color = (0.4, 0.4, 0.4)
+
+        ax.tick_params(axis="x", colors=ax_color)
+        ax.tick_params(axis="y", colors=ax_color)
+        ax.yaxis.label.set_color(ax_color)
+        ax.xaxis.label.set_color(ax_color)
+
+        grid_box_border_color = (0.9, 0.9, 0.9)
+        ax.spines["bottom"].set_color(grid_box_border_color)
+        ax.spines["top"].set_color(grid_box_border_color)
+        ax.spines["right"].set_color(grid_box_border_color)
+        ax.spines["left"].set_color(grid_box_border_color)
+
+    plt.subplots_adjust(hspace=0.4)
+    plt.xlim(xlim)
+
+
+def resample_df(df, interval="1s"):
+    df = df.set_index("time")
+    df.sort_index(inplace=True)
+    df = df.resample(interval).mean()
+    df.dropna(how="all", inplace=True)
+    df.reset_index(inplace=True)
+    return df
+
+
+def _first_data_results_dir() -> Path:
+    for p in Path().walkdirs():
+        parts = p.parts()
+        if len(parts) >= 2 and parts[-2] == "data" and parts[-1] == "results":
+            return p
+    raise FileNotFoundError("Could not find a directory matching **/data/results")
+
+
+def dfplot_run():
+    d = _first_data_results_dir()
+    print(f"Found (**/data/results) directory: {d}")
+
+    n = len(list(d.walkfiles("*.parquet")))
+    print(f"Loading {n} parquet files...")
+
+    df = pandas.read_parquet(d)
+
+    if isinstance(df.index, pandas.DatetimeIndex):
+        df = resample_df(df, "1s")
+
+    out_f = Path("data_logger_results.png")
+    print(f"Saving {out_f}")
+    mpl.use("Agg")
+    plot_df_columns_as_scatter(df)
+    plt.savefig(out_f)
+
+    open_path(out_f)

bhtool-0.1.10/bhtool/list_movies.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+
+import asyncio
+import json
+import logging
+import re
+import textwrap
+
+from dotenv import load_dotenv
+from path import Path
+from rich.console import Console
+from rich.table import Table
+
+from microeval.llm import get_llm_client
+
+_pkg_root = Path(__file__).parent
+
+load_dotenv(_pkg_root / ".env")
+
+logger = logging.getLogger(__name__)
+
+MOVIE_MAPPING_FILE = _pkg_root / "movie_mapping.json"
+
+
+NORMALIZE_SYSTEM_PROMPT = textwrap.dedent("""
+    You normalize movie and TV directory and file names for a media library.
+
+    Rules:
+    - Output the title in Title Case.
+    - Keep the year as (YYYY) at the end when present; infer from the name
+      if needed.
+    - For TV series: preserve season markers at the end if present (e.g. S1,
+      S2, S01, S02, Season 1, Season 2). Keep them at the end of the
+      normalized name.
+    - Strip release/quality tags: [1080p], [720p], [WEBRip], [BluRay],
+      [YTS.MX], codec names, group names, etc.
+    - For files: normalize only the base name (before the extension); the
+      extension stays unchanged in the output.
+    - Preserve the original spelling of the title; only fix casing and
+      punctuation.
+    - Return valid JSON only, no markdown or extra text.
+""").strip()
+
+NORMALIZE_USER_PROMPT_TEMPLATE = textwrap.dedent("""
+    Convert these names to normalized form. Return a single JSON object with
+    two keys:
+    - "directories": list of {{"original": "<dir name>",
+      "normalized": "<normalized dir name>"}}
+    - "files": list of {{"original": "<filename with extension>",
+      "normalized": "<normalized base name without extension>"}}
+
+    Directory names:
+    {dir_list}
+
+    File names:
+    {file_list}
+""").strip()
+
+
+def _parse_llm_json_object(result: dict) -> dict | None:
+    text = (result.get("text") or "").strip()
+    if not text:
+        return None
+    fence = re.search(r"```(?:json)?\s*([\s\S]*?)```", text)
+    if fence:
+        text = fence.group(1).strip()
+    try:
+        data = json.loads(text)
+        return data if isinstance(data, dict) else None
+    except json.JSONDecodeError:
+        pass
+    start, end = text.find("{"), text.rfind("}")
+    if start != -1 and end > start:
+        try:
+            data = json.loads(text[start : end + 1])
+            return data if isinstance(data, dict) else None
+        except json.JSONDecodeError:
+            return None
+    return None
+
+
+async def normalize_names_with_llm(dir_names, file_names, service="openai"):
+    if not dir_names and not file_names:
+        return {"directories": [], "files": []}
+
+    dir_list = "\n".join(f"- {n}" for n in dir_names) or "(none)"
+    file_list = "\n".join(f"- {n}" for n in file_names) or "(none)"
+    user_content = NORMALIZE_USER_PROMPT_TEMPLATE.format(
+        dir_list=dir_list,
+        file_list=file_list,
+    )
+    messages = [
+        {"role": "system", "content": NORMALIZE_SYSTEM_PROMPT},
+        {"role": "user", "content": user_content},
+    ]
+
+    logger.info("Initializing LLM (service=%s)", service)
+    async with get_llm_client(service) as client:
+        logger.info("Calling LLM (service=%s) for normalize mapping", service)
+        result = await client.get_completion(messages)
+        logger.info("LLM response received (%s chars)", len(result.get("text", "")))
+    if result.get("text", "").strip().startswith("Error:"):
+        raise RuntimeError(result["text"])
+
+    data = _parse_llm_json_object(result)
+    if not data:
+        raise RuntimeError("LLM response could not be parsed as JSON")
+    return {"directories": data.get("directories", []), "files": data.get("files", [])}
+
+
+def run_normalize_with_llm(root_dir, service="openai"):
+    root = Path(root_dir)
+    video_suffixes = {".avi", ".mkv", ".mp4", ".m4v", ".mov", ".wmv", ".webm"}
+    skip_names = {".DS_Store", "list_movies.py", "pyproject.toml", ".venv", ".ruff_cache", "__pycache__"}
+    dir_names = []
+    file_names = []
+    for p in root.iterdir():
+        if p.name.startswith(".") or p.name in skip_names:
+            continue
+        if p.is_dir():
+            dir_names.append(p.name)
+        elif p.suffix.lower() in video_suffixes:
+            file_names.append(p.name)
+    dir_names.sort()
+    file_names.sort()
+    return asyncio.run(normalize_names_with_llm(dir_names, file_names, service))
+
+
+def rename_movies(root_dir, dry_run=True, mapping=None):
+    root = Path(root_dir)
+    if mapping is None:
+        mapping = {"directories": [], "files": []}
+    dirs = mapping["directories"]
+    files = mapping["files"]
+    renamed_count = 0
+    skipped_count = 0
+    table_rows = [] if dry_run else None
+
+    for e in dirs:
+        old_name, new_name = e["original"], e["normalized"]
+        if old_name == new_name:
+            continue
+        old_path = root / old_name
+        new_path = root / new_name
+        if not old_path.exists():
+            skipped_count += 1
+            if table_rows is not None:
+                table_rows.append(("DIR", old_name, new_name, "skip (not found)"))
+            elif dry_run:
+                print(f"⚠️  SKIP: {old_name} (not found)")
+            continue
+        if new_path.exists():
+            skipped_count += 1
+            if table_rows is not None:
+                table_rows.append(("DIR", old_name, new_name, "skip (exists)"))
+            elif dry_run:
+                print(f"⚠️  SKIP: {old_name} → {new_name} (target exists)")
+            continue
+        if dry_run:
+            if table_rows is not None:
+                table_rows.append(("DIR", old_name, new_name, "would rename"))
+            else:
+                print(f"📁 WOULD RENAME: {old_name}")
+                print(f"            TO: {new_name}")
+        else:
+            old_path.rename(new_path)
+            print(f"✅ RENAMED: {old_name}")
+            print(f"        TO: {new_name}")
+            renamed_count += 1
+
+    for e in files:
+        old_name, new_name = e["original"], e["normalized"]
+        old_path = root / old_name
+        suffix = Path(old_name).suffix
+        new_path = root / (new_name + suffix)
+        if old_name == new_name + suffix:
+            continue
+        if not old_path.exists():
+            skipped_count += 1
+            if table_rows is not None:
+                table_rows.append(("FILE", old_name, new_name + suffix, "skip (not found)"))
+            elif dry_run:
+                print(f"⚠️  SKIP: {old_name} (not found)")
+            continue
+        if new_path.exists():
+            skipped_count += 1
+            if table_rows is not None:
+                table_rows.append(("FILE", old_name, new_name + suffix, "skip (exists)"))
+            elif dry_run:
+                print(f"⚠️  SKIP: {old_name} → {new_name}{suffix} (target exists)")
+            continue
+        if dry_run:
+            if table_rows is not None:
+                table_rows.append(("FILE", old_name, new_name + suffix, "would rename"))
+            else:
+                print(f"📄 WOULD RENAME: {old_name}")
+                print(f"            TO: {new_name}{suffix}")
+        else:
+            old_path.rename(new_path)
+            print(f"✅ RENAMED: {old_name}")
+            print(f"        TO: {new_name}{suffix}")
+            renamed_count += 1
+
+    if table_rows is not None:
+        console = Console()
+        tbl = Table(title="Rename (dry run)", show_header=True, header_style="bold")
+        tbl.add_column("Type", style="dim")
+        tbl.add_column("From")
+        tbl.add_column("To")
+        tbl.add_column("Status")
+        for row in table_rows:
+            tbl.add_row(*row)
+        console.print(tbl)
+        console.print(f"\n[dim]{len(table_rows)} items[/dim]")
+    elif not dry_run:
+        print("\n" + "=" * 80)
+        print(f"COMPLETE: {renamed_count} items renamed, {skipped_count} skipped")
+        print("=" * 80)
+
+
+def _root_dir(movies_dir: str | None = None) -> Path:
+    if movies_dir is not None:
+        return Path(movies_dir)
+    return Path.cwd()
+
+
+def movies_rename_impl(root_dir: str | None = None, execute: bool = False):
+    import logging
+    import os
+    import sys
+
+    logging.basicConfig(level=logging.INFO, format="%(message)s", stream=sys.stderr)
+    root = _root_dir(root_dir)
+    svc = os.environ.get("LLM_SERVICE", "openai")
+    print(f"Getting mapping from LLM (service={svc})...\n")
+    mapping = run_normalize_with_llm(root, svc)
+    MOVIE_MAPPING_FILE.write_text(json.dumps(mapping, indent=2))
+    print(f"Saved to {MOVIE_MAPPING_FILE}\n")
+    if execute:
+        print("⚠️  PERFORMING ACTUAL RENAME")
+        rename_movies(root, dry_run=False, mapping=mapping)
+    else:
+        rename_movies(root, dry_run=True, mapping=mapping)

bhtool-0.1.10/bhtool/npread.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+
+"""Print shape of numpy .npy file"""
+
+import numpy
+
+
+def npread_run(files: tuple[str, ...]):
+    for arg in files:
+        m = numpy.load(arg)
+        print("Numpy shape", m.shape)

bhtool-0.1.10/bhtool/psword.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+
+"""Find processes with name"""
+
+from bhtool.utils import run, run_output
+
+
+def psword_run(words: tuple[str, ...], kill: bool = False):
+    for word in words:
+        txt = run_output(f"ps aux | grep {word}")
+        for line in txt.splitlines():
+            tokens = line.split()
+            i_process = tokens[1]
+            cmd = " ".join(tokens[10:])
+            if len(cmd) > 80:
+                cmd = cmd[:80] + "..."
+            if "psword" in line:
+                continue
+            if kill:
+                print(f"kill target ({cmd})")
+                run(f"kill -9 {i_process}")
+            else:
+                print(f"process {i_process}: {cmd}")

bhtool-0.1.10/bhtool/rm_npm.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+
+"""Remove node_modules and package-lock.json from directories"""
+
+from path import Path
+
+from bhtool.utils import walk_paths
+
+
+def rm_npm_run():
+    print("Checking for npm modules", Path(".").resolve())
+
+    node_modules = []
+    package_locks = []
+    for d in walk_paths("."):
+        if d.name.endswith("node_modules"):
+            node_modules.append(d)
+        if d.name.endswith("package-lock.json"):
+            package_locks.append(d)
+
+    for f in reversed(package_locks):
+        print("remove file", f)
+        f.unlink()
+
+    for d in reversed(node_modules):
+        print("remove directory", d)
+        d.rmtree()

bhtool-0.1.10/bhtool/run.py

@@ -0,0 +1,23 @@
+#!/usr/bin/env python3
+
+"""Quick open applications in Darwin"""
+
+from path import Path
+
+from bhtool.utils import run
+
+search_dirs = [Path("/Applications"), Path.home() / "MyApps"]
+
+
+def open_apps(*params: str):
+    params = list(params)
+    use_app = params[0].lower()
+    for search_dir in search_dirs:
+        names = [p.stem.lower() for p in search_dir.glob("*")]
+        if match_app := next((name for name in names if use_app in name), None):
+            params[0] = match_app
+            break
+
+    params = [f'"{p}"' for p in params]
+    cmd = "open -a " + " ".join(params)
+    run(cmd)

bhtool-0.1.10/bhtool/text2.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+
+"""cli convert between md|html|docx|pug"""
+
+from path import Path
+
+from bhtool.utils import run, run_output
+
+
+def convert_md_to_html(md, html):
+    run(f"pandoc --from markdown --to html '{md}' -o '{html}'")
+    txt = run_output(f"beautify {html}")
+    Path(html).write_text(txt)
+
+
+def convert_md_to_docx(md, docx):
+    run(f"pandoc --from markdown --to docx '{md}' -o '{docx}'")
+
+
+def convert_docx_to_md(docx, md):
+    run(f"pandoc --from docx --to markdown '{docx}' -o '{md}'")
+
+
+def convert_html_to_pug(html, pug):
+    run(f"html2pug < {html} > {pug}")
+
+
+def convert_pug_to_html(pug, html):
+    temp_pug = Path(pug).with_suffix(".temp.pug")
+    Path(pug).copy2(temp_pug)
+    temp_html = temp_pug.with_suffix(".html")
+    if temp_html.exists():
+        temp_html.unlink()
+    run(f"pug {temp_pug}  ")
+    txt = run_output(f"beautify {temp_html}")
+    Path(html).write_text(txt)
+
+
+def convert_html_to_md(html, md):
+    run(f"pandoc --from html --to markdown {html} -o {md}")
+
+
+def text2_run(in_fname: str, out_fname: str):
+    in_fname = Path(in_fname)
+    out_fname = Path(out_fname)
+
+    in_ext = in_fname.suffix.lower()
+    out_ext = out_fname.suffix.lower()
+    if (in_ext, out_ext) == (".md", ".pug"):
+        temp_html_fname = in_fname.with_suffix(".temp.html")
+        convert_md_to_html(in_fname, temp_html_fname)
+        convert_html_to_pug(temp_html_fname, out_fname)
+    elif (in_ext, out_ext) == (".pug", ".md"):
+        temp_html_fname = in_fname.with_suffix(".temp.html")
+        convert_pug_to_html(in_fname, temp_html_fname)
+        convert_html_to_md(temp_html_fname, out_fname)
+    elif (in_ext, out_ext) == (".pug", ".html"):
+        convert_pug_to_html(in_fname, out_fname)
+    elif (in_ext, out_ext) == (".md", ".html"):
+        convert_md_to_html(in_fname, out_fname)
+    elif (in_ext, out_ext) == (".md", ".docx"):
+        convert_md_to_docx(in_fname, out_fname)
+    elif (in_ext, out_ext) == (".docx", ".md"):
+        convert_docx_to_md(in_fname, out_fname)
+    else:
+        print(f"Error: can't handle .suffix: {in_fname} -> {out_fname}")
+
+    print(f">>> Made {out_fname}")

bhtool-0.1.10/bhtool/todict.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+
+"""Convert json to python dict repr"""
+
+import io
+import sys
+import typing
+from json import load as json_load
+from json import loads as json_loads
+
+from path import Path
+from ruyaml import YAML
+
+indent = "  "
+
+output = io.StringIO()
+
+
+def print_out(*args, **kwargs):
+    print(*args, file=output, **kwargs)
+
+
+def walk_d(o, level=0, skip_first_indent=False):
+    curr_space = indent * level
+    if not skip_first_indent:
+        print_out(curr_space, end="")
+    if isinstance(o, typing.Mapping):
+        print_out("dict(")
+        next_space = "  " * (level + 1)
+        for i, (key, value) in enumerate(o.items()):
+            print_out(next_space, end="")
+            print_out(f"{key}=", end="")
+            if isinstance(value, typing.Mapping):
+                walk_d(value, level + 1, True)
+            else:
+                walk_d(value, level + 1, True)
+        print_out(curr_space, end="")
+        if level > 0:
+            print_out("),", end="")
+        else:
+            print_out(")", end="")
+        print_out()
+    elif isinstance(o, typing.List):
+        print_out("[", end="")
+        print_out()
+        for item in o:
+            walk_d(item, level + 1)
+        print_out(curr_space, end="")
+        print_out("],", end="")
+        print_out()
+    elif isinstance(o, str):
+        print_out(f'"{o}",', end="")
+        print_out()
+    else:
+        print_out(f"{o},", end="")
+        print_out()
+
+
+def todict_run(json: str | None = None, yaml: str | None = None):
+    if json:
+        incoming_json = json_loads(Path(json).read_text())
+    elif yaml:
+        yaml_reader = YAML(typ="safe")
+        yaml_reader.default_flow_style = False
+        incoming_json = yaml_reader.load(Path(yaml).read_text())
+    elif not sys.stdin.isatty():
+        incoming_json = json_load(sys.stdin)
+    else:
+        from bhtool.cli import app
+
+        app["todict"].help_print()
+        return
+    global output
+    output = io.StringIO()
+    walk_d(incoming_json)
+    contents = output.getvalue()
+    output.close()
+    print(contents)

bhtool-0.1.10/bhtool/utils.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+
+"""Shared utilities for bhtool scripts."""
+
+import os
+import platform
+import subprocess
+import sys
+from collections.abc import Iterator
+from path import Path
+
+
+def run(cmd: str, env=None) -> None:
+    """Run a shell command, printing it first. Exits on failure.
+
+    :param cmd: Shell command to run
+    :param env: Optional environment variables dict
+    """
+    print(f">> {cmd}")
+    result = subprocess.run(cmd, shell=True, env=env)
+    if result.returncode != 0:
+        sys.exit(result.returncode)
+
+
+def run_output(cmd: str) -> str:
+    """Run a shell command and return its output as text.
+
+    :param cmd: Shell command to run
+    :return: stdout+stderr output, or empty string on error
+    """
+    try:
+        result = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
+        return result.decode("utf-8", errors="ignore")
+    except subprocess.CalledProcessError:
+        return ""
+
+
+def open_path(filepath: str) -> None:
+    """Open a path with the platform default handler (Finder, explorer, xdg-open)."""
+    p = Path(filepath)
+    system = platform.system()
+    if system == "Darwin":
+        subprocess.run(["open", p], check=False)
+    elif system == "Windows":
+        os.startfile(p)
+    else:
+        subprocess.run(["xdg-open", p], check=False)
+
+
+def walk_paths(root: str) -> Iterator[Path]:
+    """Depth-first walk of ``root`` (files and dirs), using ``path.Path.walk``."""
+    base = Path(root)
+    if base.is_dir():
+        yield from base.walk()

bhtool-0.1.10/jtools/jtools.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+
+const subcommand = process.argv[2];
+
+if (!subcommand) {
+  console.log("Usage: jtools <command>");
+  console.log("");
+  console.log("Commands:");
+  console.log("  format-pug  Format pug in ./index.html (current working dir)");
+  console.log("  copy-agent  Copy ~/.claude/CLAUDE.md to ./AGENT.md");
+  process.exit(0);
+}
+
+if (subcommand === "copy-agent") {
+  const src = path.resolve(process.env.HOME, ".claude/CLAUDE.md");
+  const dest = path.resolve(process.cwd(), "AGENT.md");
+  fs.copyFileSync(src, dest);
+  console.log("copied CLAUDE.md to AGENT.md");
+  process.exit(0);
+}
+
+if (subcommand === "format-pug") {
+  const HTML_FILE = path.resolve(process.cwd(), "index.html");
+  if (!fs.existsSync(HTML_FILE)) {
+    console.error("index.html not found in current directory");
+    process.exit(1);
+  }
+  const OPEN_MARKER = "/* pug */`";
+
+  const content = fs.readFileSync(HTML_FILE, "utf8");
+
+  const openIdx = content.indexOf(OPEN_MARKER);
+  if (openIdx === -1) throw new Error(`marker '${OPEN_MARKER}' not found`);
+
+  const contentStart = openIdx + OPEN_MARKER.length;
+
+  let closeIdx = contentStart;
+  while (closeIdx < content.length) {
+    if (content[closeIdx] === "\\") { closeIdx += 2; continue; }
+    if (content[closeIdx] === "`") break;
+    closeIdx++;
+  }
+
+  const rawPug = content.slice(contentStart, closeIdx);
+
+  const trailMatch = rawPug.match(/\n(\s*)$/);
+  const trailingWs = trailMatch ? "\n" + trailMatch[1] : "\n";
+
+  const lines = rawPug.split("\n");
+  const nonEmpty = lines.filter((l) => l.trim());
+  if (!nonEmpty.length) process.exit(0);
+
+  const baseIndent = Math.min(...nonEmpty.map((l) => l.match(/^(\s*)/)[1].length));
+  const indent = " ".repeat(baseIndent);
+
+  const stripped = lines
+    .map((l) => l.slice(baseIndent))
+    .join("\n")
+    .trim();
+
+  const { default: prettier } = await import("prettier");
+  const { plugin: pugPlugin } = await import("@prettier/plugin-pug");
+
+  const formatted = await prettier.format(stripped, {
+    parser: "pug",
+    plugins: [pugPlugin],
+  });
+
+  const reindented =
+    "\n" +
+    formatted
+      .trimEnd()
+      .split("\n")
+      .map((l) => (l ? indent + l : ""))
+      .join("\n") +
+    trailingWs;
+
+  fs.writeFileSync(
+    HTML_FILE,
+    content.slice(0, contentStart) + reindented + content.slice(closeIdx),
+  );
+
+  console.log("formatted pug in", path.basename(HTML_FILE));
+  process.exit(0);
+}
+
+console.error(`Unknown subcommand: ${subcommand}`);
+console.error("Run 'jtools' for usage.");
+process.exit(1);

bhtool-0.1.10/jtools/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "jtools",
+  "private": true,
+  "type": "module",
+  "bin": {
+    "jtools": "./jtools.js"
+  },
+  "devDependencies": {
+    "@prettier/plugin-pug": "^3.4.2",
+    "prettier": "^3.0.0"
+  }
+}

bhtool-0.1.10/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "bhtool"
+version = "0.1.10"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+authors = [
+    { name = "Bosco Ho", email = "apposite@gmail.com" }
+]
+dependencies = [
+    "path>=16.14.0",
+    "semver>=3.0.2",
+    "numpy>=1.26.4",
+    "click>=8.1.7",
+    "ruyaml>=0.91.0",
+    "pandas>=2.2.2",
+    "matplotlib>=3.9.0",
+    "pydash>=8.0.3",
+    "cyclopts>=4.10.2",
+    "python-dotenv>=1.2.2",
+    "rich>=15.0.0",
+    "microeval>=0.5.0",
+]
+
+[project.scripts]
+b = "bhtool.cli:main"
+bhtool = "bhtool.cli:main"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.11.10",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["bhtool"]
+
+[tool.uv]
+package = true