mdbub 0.3.7__py3-none-any.whl

mdbub/commands/quickmode_config.py

@@ -0,0 +1,141 @@
+"""
+quickmode_config.py - Loads and manages Quick Mode UI configuration (colors, symbols, caps, etc.)
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import toml
+
+# Default UI constants
+QUICKMODE_DEFAULTS = {
+    # Semantic ANSI color and highlight codes for terminal prints
+    # Semantic color roles (legacy single-value keys for backward compatibility)
+    "COLOR_PRINTS_CLEAR": "\033[H\033[J",  # Clear screen
+    "COLOR_PRINTS_RESET": "\033[0m",  # Reset
+    "COLOR_PRINTS_BLINK": "blink",  # Rich blink style (not ANSI)
+    # Foreground/background split for all roles (preferred)
+    "COLOR_PRINTS_ACCENT_FG": "\033[36m",
+    "COLOR_PRINTS_ACCENT_BG": "",
+    "COLOR_PRINTS_HIGHLIGHT_FG": "",
+    "COLOR_PRINTS_HIGHLIGHT_BG": "\033[44m",
+    "COLOR_PRINTS_TEXT_FG": "\033[97m",
+    "COLOR_PRINTS_TEXT_BG": "",
+    "COLOR_PRINTS_DIM_FG": "\033[90m",
+    "COLOR_PRINTS_DIM_BG": "",
+    "COLOR_PRINTS_WARNING_FG": "\033[33m",
+    "COLOR_PRINTS_WARNING_BG": "",
+    "COLOR_PRINTS_SUCCESS_FG": "\033[32m",
+    "COLOR_PRINTS_SUCCESS_BG": "",
+    "COLOR_PRINTS_ERROR_FG": "\033[31m",
+    "COLOR_PRINTS_ERROR_BG": "",
+    "COLOR_PRINTS_STATUS_BAR_FG": "\u001b[93m",
+    "COLOR_PRINTS_STATUS_BAR_BG": "",
+    "COLOR_PRINTS_BREADCRUMB_BAR_FG": "\u001b[36m",
+    "COLOR_PRINTS_BREADCRUMB_BAR_BG": "",
+    "COLOR_PRINTS_CHILD_HIGHLIGHT_FG": "\u001b[90m",
+    "COLOR_PRINTS_CHILD_HIGHLIGHT_BG": "",  # Child highlight (default: dim gray, no bg)
+    # UI timings
+    "STATUS_MESSAGE_TIMEOUT_SHORT": 1.0,
+    "STATUS_MESSAGE_TIMEOUT": 2.0,
+    "STATUS_MESSAGE_TIMEOUT_LONG": 4.0,
+    # Layout
+    "MAX_VISIBLE_CHILDREN": 4,
+    # Length caps
+    "MAX_NODE_LABEL_VIZ_LENGTH": 2048,
+    "MAX_BREADCRUMB_NODE_VIZ_LENGTH": 15,
+    "MAX_CHILDNODE_VIZ_LENGTH": 20,
+    # Colors
+    "COLOR_BREADCRUMBS": "dim white",
+    "COLOR_BREADCRUMBS_ROOT": "bold cyan",
+    "COLOR_BREADCRUMBS_CURRENT": "bold white",
+    "COLOR_CURRENT_NODE": "bold white",
+    "COLOR_SELECTED_CHILD": "grey23 on dim cyan",
+    "COLOR_CHILD": "dim cyan",
+    "COLOR_PAGINATION": "yellow",
+    "COLOR_POSITION": "dim white",
+    "COLOR_STATUS": "green",
+    "COLOR_HOTKEYS": "cyan",
+    "COLOR_ERROR": "red",
+    "COLOR_WARNING": "yellow",
+    "COLOR_SUCCESS": "green",
+    # Symbols
+    "SYMBOL_BULLET": "●",
+    "SYMBOL_BRANCH": "└─",
+    "SYMBOL_ROOT": "◉",
+    "SYMBOL_MORE_LEFT": "◀ more",
+    "SYMBOL_MORE_RIGHT": "more ▶",
+    "SYMBOL_CHILDNODE_OPENWRAP": "⦇",
+    "SYMBOL_CHILDNODE_CLOSEWRAP": "⦈",
+    "SYMBOL_BREADCRUMBNODE_OPENWRAP": "【",
+    "SYMBOL_BREADCRUMBNODE_CLOSEWRAP": "】",
+}
+
+CONFIG_FILENAME = "mdbub.toml"
+SESSION_FILENAME = "session.json"
+
+APPNAME = "mdbub"
+
+
+def get_session_path() -> Path:
+    return get_xdg_config_path() / SESSION_FILENAME
+
+
+def save_session(last_file: str, last_node_path: List[int]) -> None:
+    """Persist the last opened file and selected node path to the session file."""
+    session_path = get_session_path()
+    session_path.parent.mkdir(parents=True, exist_ok=True)
+    session = {
+        "last_file": last_file,
+        "last_node_path": last_node_path,
+    }
+    try:
+        with open(session_path, "w", encoding="utf-8") as f:
+            json.dump(session, f)
+    except Exception as e:
+        print(
+            f"[mdbub] Failed to save session: {e}",
+            file=sys.stderr,
+        )
+
+
+def load_session() -> Optional[Dict[str, Any]]:
+    """Load the last session from the session file, if it exists."""
+    session_path = get_session_path()
+    if session_path.exists():
+        try:
+            with open(session_path, "r", encoding="utf-8") as f:
+                session: Dict[str, Any] = json.load(f)
+                return session
+        except Exception as e:
+            print(
+                f"[mdbub] Failed to load session: {e}",
+                file=sys.stderr,
+            )
+    return None
+
+
+def get_xdg_config_path() -> Path:
+    # XDG_CONFIG_HOME or ~/.config/mdbub/
+    base = os.environ.get("XDG_CONFIG_HOME")
+    if base:
+        return Path(base) / APPNAME
+    return Path.home() / ".config" / APPNAME
+
+
+def load_quickmode_config() -> Dict[str, Any]:
+    config_dir = get_xdg_config_path()
+    config_path = config_dir / CONFIG_FILENAME
+    config: Dict[str, Any] = QUICKMODE_DEFAULTS.copy()
+    if config_path.exists():
+        try:
+            user_cfg: Dict[str, Any] = toml.load(config_path)
+            for k, v in user_cfg.items():
+                if k in config:
+                    config[k] = v
+        except Exception as e:
+            print(f"[mdbub] Failed to load quickmode config: {e}", file=sys.stderr)
+    return config  # Always return a dict, never None

mdbub/commands/version.py

@@ -0,0 +1,67 @@
+import os
+import platform
+import sys
+from pathlib import Path
+
+import typer
+
+from mdbub import BUILD_INFO, __version__
+from mdbub.commands.quickmode_config import CONFIG_FILENAME, get_xdg_config_path
+
+
+def main() -> None:
+    """Print version, build info, and config path."""
+    version = __version__
+    build_info = BUILD_INFO
+
+    # Rich output with more details
+    typer.echo("🧠 mdbub - Terminal mindmap tool")
+    typer.echo("Warning: Pre-release version - data may be lost, expect bugs!")
+    typer.echo(f"Version: {version}")
+    typer.echo(f"Build: {build_info}")
+    typer.echo(f"Python: {sys.version.split()[0]} ({platform.python_implementation()})")
+    typer.echo(
+        f"Platform: {platform.system()} {platform.release()} ({platform.machine()})"
+    )
+    typer.echo("")
+    # Installation info
+    try:
+        import mdbub
+
+        install_path = Path(mdbub.__file__).parent.parent.parent
+        typer.echo(f"📦 Installed at: {install_path}")
+    except Exception:
+        typer.echo("📦 Installed at: unknown")
+
+    # check if config for mdbub exists and print path other print "using defaults"
+    config_dir = get_xdg_config_path()
+    config_path = config_dir / CONFIG_FILENAME
+    if config_path.exists():
+        typer.echo(f"🔧 Config: {config_path}")
+    else:
+        typer.echo(f"🔧 Config: {config_path}, Not found (using defaults)")
+
+    # Session info
+    import json
+
+    from mdbub.commands.quickmode_config import SESSION_FILENAME
+
+    session_path = config_dir / SESSION_FILENAME
+    if session_path.exists():
+        try:
+            with open(session_path, "r") as f:
+                session_data = json.load(f)
+            last_file = session_data.get("last_file", "-")
+            typer.echo(f"📝 Session: {session_path}")
+            if last_file != "-" and not (
+                Path(last_file).is_file() and os.access(last_file, os.R_OK)
+            ):
+                typer.echo(f"    Last file: {last_file} (missing or unreadable)")
+            else:
+                typer.echo(f"    Last file: {last_file}")
+            # typer.echo(f"    Last node path: {last_node_path}")
+        except Exception as e:
+            typer.echo(f"📝 Session: {session_path} (error reading: {e})")
+    else:
+        typer.echo(f"📝 Session: {session_path}, Not found")
+    typer.echo("")

mdbub/commands/view.py

@@ -0,0 +1,9 @@
+import typer
+
+app = typer.Typer()
+
+
+@app.command()  # type: ignore[misc]
+def main(filename: str) -> None:
+    """Render mindmap as ASCII/Unicode tree (stub)."""
+    typer.echo(f"[view] Would render {filename} (stub)")

mdbub/core/mindmap.py

@@ -0,0 +1,241 @@
+import logging
+import time
+from typing import Any, Dict, List, Optional, Tuple
+
+MAX_NODE_LABEL_LENGTH = 2048  # Maximum allowed characters for a node label
+
+
+class MindMapNode:
+    def __init__(
+        self,
+        label: str,
+        children: Optional[List["MindMapNode"]] = None,
+        color: Optional[str] = None,
+        icon: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        if len(label) > MAX_NODE_LABEL_LENGTH:
+            logging.warning(
+                f"[mdbub] Node label exceeded {MAX_NODE_LABEL_LENGTH} chars and was "
+                "truncated."
+            )
+            label = label[:MAX_NODE_LABEL_LENGTH] + "... [truncated]"
+        self.label = label
+        self.children = children or []
+        self.color = color
+        self.icon = icon
+        self.metadata = metadata or {}
+        self.parent: Optional[
+            "MindMapNode"
+        ] = None  # Reference to parent node, useful for navigation
+
+    def add_child(self, child: "MindMapNode") -> None:
+        self.children.append(child)
+        child.parent = self  # Set parent reference
+
+    def add_tag(self, tag: str) -> None:
+        """Add a tag to this node's metadata."""
+        if "tags" not in self.metadata:
+            self.metadata["tags"] = []
+        if isinstance(self.metadata["tags"], list) and tag not in self.metadata["tags"]:
+            self.metadata["tags"].append(tag)
+
+    def remove_tag(self, tag: str) -> None:
+        """Remove a tag from this node's metadata."""
+        if "tags" in self.metadata and isinstance(self.metadata["tags"], list):
+            if tag in self.metadata["tags"]:
+                self.metadata["tags"].remove(tag)
+                # Clean up empty tags list
+                if not self.metadata["tags"]:
+                    del self.metadata["tags"]
+
+    def get_tags(self) -> List[str]:
+        """Get all tags for this node."""
+        if "tags" in self.metadata and isinstance(self.metadata["tags"], list):
+            return self.metadata["tags"]
+        return []
+
+    def set_metadata(self, key: str, value: Any) -> None:
+        """Set a metadata key-value pair."""
+        self.metadata[key] = value
+
+    def get_metadata(self, key: str, default: Any = None) -> Any:
+        """Get a metadata value by key."""
+        return self.metadata.get(key, default)
+
+    def to_dict(self) -> Dict[str, Any]:
+        result: Dict[str, Any] = {
+            "label": self.label,
+            "children": [child.to_dict() for child in self.children],
+        }
+        # Only include non-empty values
+        if self.color:
+            result["color"] = self.color
+        if self.icon:
+            result["icon"] = self.icon
+        if self.metadata:
+            result["metadata"] = self.metadata
+        return result
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> "MindMapNode":
+        node = MindMapNode(
+            label=data["label"],
+            color=data.get("color"),
+            icon=data.get("icon"),
+            metadata=data.get("metadata", {}),
+        )
+        for child_data in data.get("children", []):
+            child = MindMapNode.from_dict(child_data)
+            node.add_child(child)
+        return node
+
+
+def parse_markdown_to_mindmap(md: str) -> MindMapNode:
+    """Parse extended markdown into a MindMapNode tree with metadata.
+
+    Metadata format supports:
+    - Tags in the format: #tag1 #tag2
+    - Key-value pairs: @key=value
+    """
+    start_time = time.time()
+    lines = [
+        line.rstrip()
+        for line in md.splitlines()
+        if line.strip() and not line.startswith("<!-- mdbub-format")
+    ]
+    # NOTE: Loosen annotation for release: mypy cannot handle recursive tuple type here.
+    top_nodes: List[Any] = []  # List of (label, metadata, children_tuples, indent)
+    stack: List[Any] = []  # Stack for parent tracking
+
+    logging.info(f"[mdbub] Parsing {len(lines)} lines from markdown...")
+    for line in lines:
+        if not line.lstrip().startswith("-"):
+            continue
+
+        indent = len(line) - len(line.lstrip())
+        content = line.lstrip()[2:].strip()
+
+        # Parse metadata from the label
+        label, metadata = _parse_node_metadata(content)
+
+        if indent == 0:
+            top_nodes.append((label, metadata, [], 0))
+            stack = [top_nodes[-1]]
+        else:
+            # Attach as child to closest parent with lower indent
+            while stack and stack[-1][3] >= indent:
+                stack.pop()
+            if stack:
+                stack[-1][2].append((label, metadata, [], indent))
+                stack.append(stack[-1][2][-1])
+
+    def build_tree(
+        node_tuple: Any,  # TODO: Recursive tuple type; loosened for mypy compatibility
+        depth: int = 0,
+    ) -> MindMapNode:
+        label, metadata, children_tuples, _ = node_tuple
+        if len(label) > MAX_NODE_LABEL_LENGTH:
+            logging.warning(
+                f"[mdbub] Node label exceeded {MAX_NODE_LABEL_LENGTH} chars and was truncated during parsing."
+            )
+            label = label[:MAX_NODE_LABEL_LENGTH] + "... [truncated]"
+        if depth > 100:
+            logging.error(f"[mdbub] Maximum recursion depth reached at node '{label}'")
+            return MindMapNode(label, metadata=metadata)
+
+        node = MindMapNode(label, metadata=metadata)
+
+        # Process tags if present
+        if "tags" in metadata:
+            # Tags are already in the metadata dictionary
+            pass
+
+        for child_tuple in children_tuples:
+            node.add_child(build_tree(child_tuple, depth=depth + 1))
+        return node
+
+    if len(top_nodes) == 1:
+        result = build_tree(top_nodes[0])
+    elif len(top_nodes) > 1:
+        root = MindMapNode("SYNTHETIC ROOT")
+        for node_tuple in top_nodes:
+            root.add_child(build_tree(node_tuple))
+
+        def warn_multi_root() -> None:
+            root._multi_root_warning = True  # type: ignore[attr-defined]  # Custom attribute to signal warning
+
+        warn_multi_root()
+        result = root
+    else:
+        result = MindMapNode("")  # Empty mindmap
+    elapsed = time.time() - start_time
+    logging.info(f"[mdbub] Mindmap parse complete in {elapsed:.3f} seconds.")
+    return result
+
+
+def _parse_node_metadata(content: str) -> Tuple[str, Dict[str, Any]]:
+    """Parse node metadata from content string.
+
+    Returns:
+        tuple: (label, metadata_dict)
+    """
+    import re
+
+    # Initialize metadata dictionary
+    metadata = {}
+
+    # Extract tags (format: #tag)
+    tags = re.findall(r"\s#([\w-]+)", content)
+    if tags:
+        metadata["tags"] = tags
+        # Remove tags from content
+        for tag in tags:
+            content = re.sub(r"\s#" + tag + "\b", "", content)
+
+    # Extract key-value pairs (format: @key=value)
+    kv_pairs = re.findall(r"\s@([\w-]+)=([^\s]+)", content)
+    for key, value in kv_pairs:
+        metadata[key] = value
+        # Remove key-value pair from content
+        content = re.sub(r"\s@" + key + "=" + value + "\b", "", content)
+
+    # Clean up any extra whitespace
+    label = content.strip()
+
+    return label, metadata
+
+
+def mindmap_to_markdown(node: "MindMapNode", level: int = 0) -> str:
+    """Serialize MindMapNode tree to markdown bullets with metadata."""
+    indent = "  " * level
+    lines = []
+    # Build node content with metadata
+    content = node.label
+
+    # Only add tags that are NOT already inline in the label
+    label_lower = node.label.lower()
+    if "tags" in node.metadata and node.metadata["tags"]:
+        tags = node.metadata["tags"]
+        for tag in tags:
+            tag_str = f"#{tag.lower()}"
+            if tag_str not in label_lower:
+                content += f" #{tag}"
+
+    # Only add metadata that is NOT already inline in the label
+    for key, value in node.metadata.items():
+        if key != "tags" and value is not None:
+            if isinstance(value, (list, dict)):
+                continue  # Skip complex structures for now
+            meta_str = f"@{key.lower()}={str(value).lower()}"
+            if meta_str not in label_lower:
+                content += f" @{key}={value}"
+
+    # Emit the current node with its metadata
+    lines.append(f"{indent}- {content}")
+
+    # Process all children recursively
+    for child in node.children:
+        lines.append(mindmap_to_markdown(child, level + 1))
+
+    return "\n".join([line for line in lines if line])

mdbub/core/mindmap_utils.py

@@ -0,0 +1,33 @@
+from typing import List
+
+from .mindmap import MindMapNode
+
+
+def get_node_by_path(root: MindMapNode, path: List[int]) -> MindMapNode:
+    node = root
+    for idx in path:
+        node = node.children[idx]
+    return node
+
+
+def get_breadcrumbs(root: MindMapNode, path: List[int]) -> List[str]:
+    node = root
+    labels = [node.label]
+    for idx in path:
+        node = node.children[idx]
+        labels.append(node.label)
+    return labels
+
+
+def add_child(node: MindMapNode, label: str = "New Child") -> MindMapNode:
+    child = MindMapNode(label)
+    node.children.append(child)
+    return child
+
+
+def add_sibling(
+    parent: MindMapNode, idx: int, label: str = "New Sibling"
+) -> MindMapNode:
+    sibling = MindMapNode(label)
+    parent.children.insert(idx + 1, sibling)
+    return sibling

mdbub/symbols.py

@@ -0,0 +1,68 @@
+"""
+# WRAPPER SYMBOL OPTIONS
+# -------------------------------------------------------------------------------------
+# These symbols can be used for SYMBOL_CHILDNODE_OPENWRAP, SYMBOL_CHILDNODE_CLOSEWRAP,
+# SYMBOL_BREADCRUMBNODE_OPENWRAP, and SYMBOL_BREADCRUMBNODE_CLOSEWRAP
+#
+# TRADITIONAL BRACKETS
+# -------------------------------------------------------------------------------------
+# Parentheses:        (   )
+# Square brackets:    [   ]
+# Curly braces:       {   }
+# Angle brackets:     <   >
+#
+# ASIAN STYLE BRACKETS
+# -------------------------------------------------------------------------------------
+# Japanese corner brackets:    「   」
+# White corner brackets:       『   』
+# Black lenticular brackets:   【   】
+# White lenticular brackets:   〖   〗
+# Tortoise shell brackets:     〔   〕
+# Double angle brackets:       《   》
+# CJK brackets:                〈   〉
+# Fullwidth brackets:          （   ）
+# Fullwidth curly braces:      ｛   ｝
+# Fullwidth square brackets:   ［   ］
+#
+# MATHEMATICAL AND SPECIAL BRACKETS
+# -------------------------------------------------------------------------------------
+# Mathematical angle brackets:  ⟨   ⟩
+# Double square brackets:       ⟦   ⟧
+# Floor brackets:               ⌊   ⌋
+# Ceiling brackets:             ⌈   ⌉
+# Z notation:                   ⦇   ⦈
+# Angle with dot:               ⦑   ⦒
+# Square with ticks:            ⦋   ⦌
+# Double-struck brackets:       ⟦   ⟧
+#
+# DECORATIVE SYMBOLS (PAIRED)
+# -------------------------------------------------------------------------------------
+# Stars:                         ✧   ✧
+# Black stars:                   ★   ★
+# Arrows:                        →   ←
+# Heavy arrows:                  ➤   ➤
+# Triangle arrows:               ▶   ◀
+# Dots/bullets:                  •   •
+# Diamonds:                      ◆   ◆
+# White diamonds:                ◇   ◇
+# Circles:                       ○   ○
+# Black circles:                 ●   ●
+# Flowers:                       ✿   ✿
+# Cherry blossoms:               ❀   ❀
+# Sparkles:                      ✨   ✨
+# Quotes:                        "   "
+# Typographic quotes:            "   "
+# French quotes (guillemets):    «   »
+# Single guillemets:             ‹   ›
+#
+# REVERSED BRACKETS (RIGHT-TO-LEFT)
+# -------------------------------------------------------------------------------------
+# Reversed Japanese corner:      」  「
+# Reversed white corner:         』  『
+# Reversed double angle:         》  《
+# Reversed black lenticular:     】  【
+# Reversed white lenticular:     〗  〖
+# Reversed square:               ]   [
+# Reversed curly:                }   {
+# Reversed parentheses:          )   (
+"""