lava-cmd 0.1.0__tar.gz

lava_cmd-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,26 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Build
+        run: |
+          pip install build
+          python -m build
+
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

lava_cmd-0.1.0/.gitignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Environments
+.venv/
+venv/
+.env
+
+# macOS
+.DS_Store
+
+# Tools
+.claude/
+.ruff_cache/
+.mypy_cache/

lava_cmd-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: lava-cmd
+Version: 0.1.0
+Summary: A CLI toolkit for interacting with Obsidian vaults
+Requires-Python: >=3.10
+Requires-Dist: networkx
+Requires-Dist: platformdirs
+Requires-Dist: python-frontmatter
+Requires-Dist: rank-bm25
+Requires-Dist: rich
+Requires-Dist: textual
+Requires-Dist: toml
+Requires-Dist: typer

lava_cmd-0.1.0/lava/__init__.py

@@ -0,0 +1,3 @@
+"""lava — A CLI toolkit for interacting with Obsidian vaults."""
+
+__version__ = "0.1.0"

lava_cmd-0.1.0/lava/_app.py

@@ -0,0 +1,17 @@
+"""lava — app singleton, console, and shared constants."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from lava import __version__ as _LAVA_VERSION
+
+app = typer.Typer(
+    name="lava",
+    help="A CLI toolkit for interacting with Obsidian vaults.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+console = Console()

lava_cmd-0.1.0/lava/_helpers.py

@@ -0,0 +1,68 @@
+"""lava — shared helpers used across multiple command modules."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.prompt import Prompt
+
+from lava import config as cfg
+from lava import vault as vlt
+from lava import ui
+from lava._app import console
+
+
+def _cwd(vault_path: Path) -> Path:
+    """Return the current working directory within the vault."""
+    rel = cfg.get_vault_cwd()
+    if not rel:
+        return vault_path
+    candidate = vault_path / rel
+    if candidate.exists() and candidate.is_dir():
+        return candidate
+    # cwd no longer valid (folder deleted), reset to root
+    cfg.set_vault_cwd("")
+    return vault_path
+
+
+def _cwd_label(vault_path: Path) -> str:
+    cwd = _cwd(vault_path)
+    if cwd == vault_path:
+        return f"[bold orange1]{vault_path.name}[/bold orange1] [dim]/[/dim]"
+    rel = cwd.relative_to(vault_path)
+    parts = rel.parts
+    trail = "/".join(f"[orange1]{p}[/orange1]" for p in parts)
+    return f"[dim]{vault_path.name}/[/dim]{trail} [dim]/[/dim]"
+
+
+def _pick_move_destination(vault_path: Path, source: Path) -> str | None:
+    """Interactive folder picker + optional rename."""
+    folders = vlt.list_folders(vault_path)
+
+    console.print(f"\n[bold orange1]Move:[/bold orange1] [white]{source.stem}[/white]\n")
+    console.print(f"  [dim] 0.[/dim]  [white]/ (vault root)[/white]")
+    for i, folder in enumerate(folders, 1):
+        rel = folder.relative_to(vault_path)
+        console.print(f"  [dim]{i:2}.[/dim]  [white]{rel}[/white]")
+
+    choice = Prompt.ask("\nDestination folder", default="0")
+    try:
+        idx = int(choice)
+    except ValueError:
+        ui.print_error("Invalid choice.")
+        return None
+
+    if idx == 0:
+        folder_path = vault_path
+    elif 1 <= idx <= len(folders):
+        folder_path = folders[idx - 1]
+    else:
+        ui.print_error("Invalid choice.")
+        return None
+
+    new_name = Prompt.ask("New name", default=source.stem)
+
+    rel_folder = folder_path.relative_to(vault_path)
+    if str(rel_folder) == ".":
+        return new_name
+    return str(rel_folder / new_name)

lava_cmd-0.1.0/lava/_tui_editor.py

@@ -0,0 +1,54 @@
+"""Textual-based TUI editor for lava."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import Footer, Header, TextArea
+
+
+class LavaEditorApp(App):
+    """A minimal TUI editor for editing vault notes."""
+
+    TITLE = "lava editor"
+    BINDINGS = [
+        Binding("ctrl+s", "save", "Save", show=True),
+        Binding("ctrl+q", "save_quit", "Save & Quit", show=True),
+        Binding("ctrl+c", "quit_no_save", "Quit without saving", show=True),
+    ]
+
+    def __init__(self, path: Path) -> None:
+        super().__init__()
+        self._path = path
+        self._content = path.read_text(encoding="utf-8") if path.exists() else ""
+        self._saved = False
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield TextArea(self._content, id="editor", language="markdown")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.title = f"lava — {self._path.name}"
+        self.query_one("#editor", TextArea).focus()
+
+    def action_save(self) -> None:
+        content = self.query_one("#editor", TextArea).text
+        self._path.write_text(content, encoding="utf-8")
+        self._saved = True
+        self.notify(f"Saved {self._path.name}", severity="information")
+
+    def action_save_quit(self) -> None:
+        self.action_save()
+        self.exit()
+
+    def action_quit_no_save(self) -> None:
+        self.exit()
+
+
+def run_tui_editor(path: Path) -> None:
+    """Launch the Textual TUI editor for a file."""
+    app = LavaEditorApp(path)
+    app.run()

lava_cmd-0.1.0/lava/commands/config_cmds.py

@@ -0,0 +1,310 @@
+"""lava — Configuration commands: dir_app, config_app, version, uninstall."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from pathlib import Path
+from typing import Annotated, Optional
+
+import typer
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from lava import config as cfg
+from lava import ui
+from lava._app import app, console, _LAVA_VERSION
+from lava.ui import C_PRIMARY
+
+
+dir_app = typer.Typer(
+    name="dir",
+    help="Manage the active vault directory.",
+    invoke_without_command=True,
+    no_args_is_help=False,
+)
+
+config_app = typer.Typer(
+    name="config",
+    help="View and edit lava configuration.",
+    invoke_without_command=True,
+    no_args_is_help=False,
+)
+
+
+@dir_app.callback(invoke_without_command=True)
+def dir_callback(
+    ctx: typer.Context,
+    history: Annotated[bool, typer.Option("--history", help="Show recent vaults")] = False,
+    list_vaults: Annotated[bool, typer.Option("--list", help="Show recent vaults (alias for --history)")] = False,
+    pick: Annotated[bool, typer.Option("--pick", help="Pick vault from history")] = False,
+    clear: Annotated[bool, typer.Option("--clear", help="Unset the active vault path")] = False,
+) -> None:
+    """Manage the active vault directory."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if clear:
+        cfg.set_vault_path("")
+        ui.print_success("Vault path cleared.")
+        return
+
+    if history or list_vaults:
+        _dir_history()
+        return
+
+    if pick:
+        _dir_pick()
+        return
+
+    _dir_set_prompt()
+
+
+def _dir_set_prompt() -> None:
+    """Interactively set the active vault path."""
+    current = cfg.get_vault_path()
+    if current:
+        console.print(f"[dim]Current vault:[/dim] [orange1]{current}[/orange1]")
+    else:
+        console.print("[dim]No vault set.[/dim]")
+
+    console.print(
+        f"\n  [dim]Enter a path, or [/dim][bold white]f[/bold white][dim] to browse folders[/dim]"
+    )
+    raw = Prompt.ask("[orange1]Vault path[/orange1]", default="").strip()
+
+    if not raw:
+        return
+
+    if raw.lower() == "f":
+        location = _pick_fs_folder()
+        if location is None:
+            return
+        resolved = str(location)
+    else:
+        resolved = str(Path(raw).expanduser().resolve())
+
+    if not Path(resolved).exists():
+        ui.print_error(f"Path does not exist: {resolved}")
+        raise typer.Exit(1)
+
+    cfg.set_vault_path(resolved)
+    cfg.add_to_history(resolved)
+    ui.print_success(f"Vault set to: {resolved}")
+
+
+def _dir_history() -> None:
+    config = cfg.load_config()
+    history = config.get("vault", {}).get("history", [])
+    if not history:
+        console.print("[dim]No vault history.[/dim]")
+        return
+
+    table = Table(title="Recent Vaults", header_style="bold orange1")
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Path", style="white")
+    current = cfg.get_vault_path()
+    for i, p in enumerate(history, 1):
+        marker = " [gold1](active)[/gold1]" if p == current else ""
+        table.add_row(str(i), p + marker)
+    console.print(table)
+
+    choice = Prompt.ask("Switch to vault # (or Enter to skip)", default="").strip()
+    if not choice:
+        return
+    try:
+        idx = int(choice) - 1
+        selected = history[idx]
+    except (ValueError, IndexError):
+        ui.print_error("Invalid selection.")
+        return
+    cfg.set_vault_path(selected)
+    cfg.add_to_history(selected)
+    ui.print_success(f"Vault set to: {selected}")
+
+
+def _dir_pick() -> None:
+    config = cfg.load_config()
+    history = config.get("vault", {}).get("history", [])
+    if not history:
+        ui.print_error("No vault history to pick from.")
+        raise typer.Exit(1)
+
+    console.print("[bold orange1]Recent vaults:[/bold orange1]")
+    for i, p in enumerate(history, 1):
+        console.print(f"  [dim]{i}.[/dim] {p}")
+
+    choice = Prompt.ask("Pick a vault number", default="1")
+    try:
+        idx = int(choice) - 1
+        selected = history[idx]
+    except (ValueError, IndexError):
+        ui.print_error("Invalid selection.")
+        raise typer.Exit(1)
+
+    cfg.set_vault_path(selected)
+    cfg.add_to_history(selected)
+    ui.print_success(f"Vault set to: {selected}")
+
+
+def _pick_fs_folder() -> Path | None:
+    """Navigate the real filesystem level-by-level (folders only) and return chosen path."""
+    current = Path.home()
+
+    while True:
+        subdirs = sorted(
+            [p for p in current.iterdir() if p.is_dir() and not p.name.startswith(".")],
+            key=lambda p: p.name.lower(),
+        )
+
+        console.print(f"\n[bold {C_PRIMARY}]{current}[/bold {C_PRIMARY}]\n")
+        console.print(f"  [dim] 0.[/dim]  [dim]✓ use this folder[/dim]")
+        if current != current.anchor:
+            console.print(f"  [dim] b.[/dim]  [dim].. (go up)[/dim]")
+        for i, d in enumerate(subdirs, 1):
+            console.print(f"  [dim]{i:2}.[/dim]  [orange1]{d.name}/[/orange1]")
+        console.print()
+
+        choice = Prompt.ask("Pick folder or #", default="").strip().lower()
+        if not choice:
+            return None
+        if choice == "0":
+            return current
+        if choice == "b" and current != Path(current.anchor):
+            current = current.parent
+            continue
+        try:
+            idx = int(choice)
+            if 1 <= idx <= len(subdirs):
+                current = subdirs[idx - 1]
+            else:
+                ui.print_error("Invalid choice.")
+        except ValueError:
+            ui.print_error("Invalid choice.")
+
+
+@dir_app.command("init")
+def dir_init(
+    path: Annotated[Optional[str], typer.Argument(help="Path for the new vault. Omit to create in current directory.")] = None,
+    pick: Annotated[bool, typer.Option("--pick", help="Navigate filesystem to pick location")] = False,
+) -> None:
+    """Create a new vault directory and set it as the active vault."""
+    if pick:
+        location = _pick_fs_folder()
+        if location is None:
+            raise typer.Exit(0)
+        vault_name = Prompt.ask("[orange1]Vault name[/orange1]").strip()
+        if not vault_name:
+            raise typer.Exit(0)
+        resolved = location / vault_name
+    elif path:
+        resolved = Path(path).expanduser().resolve()
+    else:
+        vault_name = Prompt.ask("[orange1]Vault name[/orange1]").strip()
+        if not vault_name:
+            raise typer.Exit(0)
+        resolved = Path.cwd() / vault_name
+
+    if resolved.exists() and any(resolved.iterdir()):
+        ui.print_error(f"Directory already exists and is not empty: {resolved}")
+        raise typer.Exit(1)
+
+    resolved.mkdir(parents=True, exist_ok=True)
+
+    cfg.set_vault_path(str(resolved))
+    cfg.add_to_history(str(resolved))
+
+    console.print(f"\n[bold {C_PRIMARY}]Vault created:[/bold {C_PRIMARY}] {resolved}")
+    console.print(f"[dim]Active vault set. Run [white]lava new[/white] to get started.[/dim]")
+
+
+@dir_app.command("set")
+def dir_set(
+    path: Annotated[str, typer.Argument(help="Vault path, or 'current' for cwd")],
+) -> None:
+    """Set the active vault path."""
+    if path.lower() == "current":
+        resolved = str(Path.cwd())
+    else:
+        resolved = str(Path(path).expanduser().resolve())
+
+    if not Path(resolved).exists():
+        ui.print_error(f"Path does not exist: {resolved}")
+        raise typer.Exit(1)
+
+    cfg.set_vault_path(resolved)
+    cfg.add_to_history(resolved)
+    ui.print_success(f"Vault set to: {resolved}")
+
+
+@config_app.callback(invoke_without_command=True)
+def config_callback(
+    ctx: typer.Context,
+    edit: Annotated[bool, typer.Option("--edit", help="Open config in $EDITOR")] = False,
+) -> None:
+    """View or edit the lava configuration."""
+    if ctx.invoked_subcommand is not None:
+        return
+
+    config = cfg.load_config()
+
+    if edit:
+        config_path = cfg.get_config_path()
+        editor = config.get("editor", "") or os.environ.get("EDITOR", "")
+        if editor:
+            subprocess.run([editor, str(config_path)])
+        else:
+            console.print(f"[orange1]Config file:[/orange1] {config_path}")
+            console.print("[dim]Set $EDITOR or lava config set editor <editor> to open it.[/dim]")
+        return
+
+    ui.config_panel(config)
+
+
+@config_app.command("set")
+def config_set(
+    key: Annotated[Optional[str], typer.Argument(help="Dotted config key (e.g. pagination, editor)")] = None,
+    value: Annotated[Optional[str], typer.Argument(help="Value to set")] = None,
+    link_folder: Annotated[bool, typer.Option("--link-folder", is_flag=True, help="Set the links folder to the current working directory.")] = False,
+    link_folder_path: Annotated[Optional[str], typer.Option("--link-folder-path", help="Set the links folder to a specific path.")] = None,
+) -> None:
+    """Set a config value, or configure the links folder."""
+    if link_folder_path is not None:
+        cfg.set_dotted_key("links_folder", link_folder_path)
+        ui.print_success(f"Links folder set to: {link_folder_path}")
+        return
+
+    if link_folder:
+        path_val = cfg.get_vault_cwd() or "."
+        cfg.set_dotted_key("links_folder", path_val)
+        ui.print_success(f"Links folder set to: {path_val}")
+        return
+
+    if key is None or value is None:
+        ui.print_error("Usage: lava config set <key> <value>  or  lava config set --link-folder")
+        raise typer.Exit(1)
+
+    try:
+        cfg.set_dotted_key(key, value)
+        ui.print_success(f"Config updated: {key} = {value}")
+    except Exception as e:
+        ui.print_error(str(e))
+        raise typer.Exit(1)
+
+
+@app.command("version", rich_help_panel="Configuration")
+def cmd_version() -> None:
+    """Show the installed lava version."""
+    console.print(f"lava [orange1]{_LAVA_VERSION}[/orange1]")
+
+
+@app.command("uninstall", rich_help_panel="Other")
+def cmd_uninstall() -> None:
+    """Uninstall lava from the current Python environment."""
+    confirmed = Confirm.ask(
+        f"Uninstall [orange1]lava {_LAVA_VERSION}[/orange1] from this environment?",
+        default=False,
+    )
+    if not confirmed:
+        raise typer.Exit(0)
+    subprocess.run(["pip", "uninstall", "lava", "-y"], check=True)