Fix emoji substitution in Rich output and add coordinate formatting

Rich's emoji feature was converting patterns like `:fiji:` in Maven
coordinates to flag emojis (🇫🇯). This affected logging and console
output, making coordinates difficult to read and breaking text parsing.

Changes:
- Set RichHandler markup=False to disable emoji/markup in log messages
- Add Coordinate.rich() method for styled coordinate formatting
- Update coord2str() with rich parameter for semantic coloring
  - groupId: bold cyan, artifactId: bold, version: green
  - Colons: dim (prevents emoji substitution as side effect)
- Update search.py and versions.py to use Coordinate.rich()
- Add tests in color.t verifying emoji prevention with :bear: pattern
- Update docs/output-subsystem.md with markup behavior explanation

The dim colons in rich formatting break emoji patterns (e.g., `:bear:`
becomes `[dim]:[/]bear[dim]:[/]` which Rich doesn't recognize as 🐻).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: ctrueden

docs/output-subsystem.md

@@ -183,6 +183,45 @@ Provides structured logging with Rich formatting.
   - `2+`: DEBUG (with `-vv` or more)
 - Uses stderr console from `get_err_console()`
 
+#### Rich Markup in Log Messages
+
+**RichHandler is configured with `markup=False`**, which has important implications:
+
+**✅ What IS enabled** (built-in RichHandler features):
+- Log level colors (DEBUG=blue, INFO=green, WARNING=yellow, ERROR=red)
+- Module:line formatting when verbose >= 2 (`show_path=True`)
+- Rich tracebacks for better exception formatting
+- Nice layout and styling
+
+**❌ What is NOT enabled** (markup processing in message content):
+- Rich markup tags like `[red]text[/]`, `[bold]text[/]` - will be shown literally
+- Emoji substitution like `:emoji_name:` (e.g., `:fire:`, `:fiji:`) - will be shown literally
+
+**Rationale:**
+1. **Prevents collisions with user data**: Maven coordinates like `sc.fiji:fiji:2.17.0` contain the pattern `:fiji:` which Rich would interpret as the Fiji flag emoji 🇫🇯 if markup were enabled
+2. **Keeps logs simple**: Log messages should be plain text for debugging and grepping
+3. **No need for markup in logs**: RichHandler already provides sufficient styling via log levels
+
+**Example:**
+```python
+import logging
+_log = logging.getLogger(__name__)
+
+# ✅ Good: Plain text logging
+_log.debug("Processing sc.fiji:fiji:2.17.0")
+_log.info("Added 3 dependencies")
+
+# ❌ Don't use markup in log messages (won't work)
+_log.debug("[cyan]Processing[/] sc.fiji:fiji:2.17.0")  # Tags shown literally
+
+# ✅ For styled user messages, use console.print() instead
+from ..util.console import get_console
+_console = get_console()
+_console.print("[cyan]Processing:[/] sc.fiji:fiji:2.17.0")
+```
+
+**Note:** If you need to include text with literal square brackets (e.g., `[settings]` section names) in console output, use `rich.markup.escape()` to prevent misinterpretation as markup tags.
+
 **`get_log(name="jgo") -> logging.Logger`**
 - Get a logger instance for a module
 - All module loggers should be children of "jgo" root logger
@@ -444,6 +483,7 @@ After refactoring and testing, here's the **verified clean output approach**:
 - ✅ Warnings about potential issues
 - ✅ Errors with context
 - ✅ Debug information
+- ⚠️ **Note**: Log messages do NOT support Rich markup (see [Rich Markup in Log Messages](#rich-markup-in-log-messages))
 
 #### Systematic Approach
 

src/jgo/cli/commands/search.py

@@ -218,9 +218,10 @@ def _display_results(results: list[dict]) -> None:
         version = result["latest_version"]
 
         # Basic format: coordinate and latest version
-        coordinate = f"{group_id}:{artifact_id}"
-        _console.print(f"{i}. {coordinate}")
-        _console.print(f"   Latest version: {version}")
+        from ...parse.coordinate import Coordinate
+
+        coord = Coordinate(group_id, artifact_id, version)
+        _console.print(f"{i}. {coord.rich()}")
 
         if verbose:
             # Show additional details in verbose mode

src/jgo/cli/commands/versions.py

@@ -72,15 +72,17 @@ def execute(args: ParsedArgs, config: dict) -> int:
         # Get available versions
         metadata = project.metadata
         if not metadata or not metadata.versions:
-            _console.print(f"No versions found for {coord.groupId}:{coord.artifactId}")
+            # Use rich() for styled output (emoji-safe)
+            _console.print(f"No versions found for {coord.rich()}")
             return 0
 
         # Use project's smart release/latest resolution
         release_version = project.release
         latest_version = project.latest
 
         # Data output - keep as print() for parseable output
-        print(f"Available versions for {coord.groupId}:{coord.artifactId}:")
+        # Use str() for plain text (no Rich markup)
+        print(f"Available versions for {coord}:")
         for version in metadata.versions:
             marker = ""
             if release_version and version == release_version:

src/jgo/parse/coordinate.py

@@ -63,7 +63,7 @@ class Coordinate:
     placement: Literal["class-path", "module-path"] | None = None
 
     def __str__(self) -> str:
-        """Return string representation using coord2str."""
+        """Return plain string representation using coord2str."""
         return coord2str(
             self.groupId,
             self.artifactId,
@@ -76,6 +76,42 @@ def __str__(self) -> str:
             self.placement,
         )
 
+    def rich(self) -> str:
+        """
+        Return Rich-formatted string representation with semantic colors.
+
+        Uses Rich markup to colorize components based on their semantic meaning:
+        - groupId: bold cyan
+        - artifactId: bold
+        - version: green
+        - packaging: default color
+        - classifier: default color
+        - scope: dim
+        - colons: dim (prevents emoji substitution like :fiji: → 🇫🇯)
+
+        The markup is automatically stripped by Rich when --color=plain is used.
+
+        Returns:
+            Formatted string with Rich markup
+
+        Examples:
+            >>> coord = Coordinate("sc.fiji", "fiji", "2.17.0")
+            >>> coord.rich()
+            '[bold cyan]sc.fiji[/][dim]:[/][bold]fiji[/][dim]:[/][green]2.17.0[/]'
+        """
+        return coord2str(
+            self.groupId,
+            self.artifactId,
+            self.version,
+            self.classifier,
+            self.packaging,
+            self.scope,
+            self.optional,
+            self.raw,
+            self.placement,
+            rich=True,
+        )
+
     @classmethod
     def parse(cls, coordinate: "Coordinate" | str) -> "Coordinate":
         """
@@ -248,6 +284,7 @@ def coord2str(
     optional: bool = False,
     raw: bool | None = None,
     placement: str | None = None,
+    rich: bool = False,
 ) -> str:
     """
     Convert Maven coordinate components to a string.
@@ -262,41 +299,57 @@ def coord2str(
         optional: Whether this is an optional dependency
         raw: Whether to use raw/strict resolution (appends ! if True)
         placement: Module path placement ("class-path" or "module-path")
+        rich: If True, format with Rich markup for semantic coloring
 
     Returns:
         A formatted coordinate string (e.g., "g:a:p:c:v:s" or "g:a:v!" for raw)
+        If rich=True, includes Rich markup tags for coloring
     """
-    parts = [groupId, artifactId]
+    tag = lambda s, t: f"[{t}]{s}[/]" if rich and t is not None else s
+
+    rich_g = tag(groupId, "bold cyan")
+    rich_a = tag(artifactId, "bold")
+    rich_v = tag(version, "green")
+    rich_c = tag(classifier, None)
+    rich_p = tag(packaging, None)
+    rich_s = tag(scope, None)
+    opt = tag("(optional)", "dim")
+    colon = tag(":", "dim")  # Prevents emojification (e.g., :fiji: → 🇫🇯)
+    bang = tag("!", "dim")
+    cp = tag("(c)", "dim")
+    mp = tag("(m)", "dim")
+
+    # Start with groupId:artifactId
+    result = f"{rich_g}{colon}{rich_a}"
 
     # Add packaging if present (comes before version in Maven format)
     if packaging:
-        parts.append(packaging)
+        result += f"{colon}{rich_p}"
 
     # Add classifier if present
     if classifier:
-        parts.append(classifier)
+        result += f"{colon}{rich_c}"
 
     # Add version if present
     if version:
-        parts.append(version)
+        result += f"{colon}{rich_v}"
 
     # Add scope if present
     if scope:
-        parts.append(scope)
+        scope_text = rich_s
         if optional:
-            parts[-1] += " (optional)"
-
-    result = ":".join(parts)
+            scope_text += f" {opt}"
+        result += f"{colon}{scope_text}"
 
     # Append placement suffix (before raw flag)
     if placement == "class-path":
-        result += "(c)"
+        result += cp
     elif placement == "module-path":
-        result += "(m)"
+        result += mp
 
     # Append ! for raw/strict resolution (comes last)
     if raw:
-        result += "!"
+        result += bang
 
     return result
 

src/jgo/util/logging.py

@@ -50,7 +50,7 @@ def setup_logging(verbose: int = 0) -> logging.Logger:
         console=console,
         show_time=False,
         show_path=(verbose >= 2),  # Show module:line in debug mode
-        markup=True,  # Allow rich markup in log messages
+        markup=False,  # Disable markup to prevent emoji conversion (e.g., :fiji: → 🇫🇯)
         rich_tracebacks=True,  # Better exception formatting
     )
     handler.setLevel(level)

tests/cli/color.t

@@ -258,3 +258,17 @@ Test --color respects environment variable COLOR.
                                                                                   
   [2]
 
+Test that coordinate formatting prevents emoji substitution.
+Coordinates use dim colons in rich mode to prevent patterns like :bear:
+from being converted to emoji (🐻). Without proper markup, Rich would
+interpret such patterns as emoji codes.
+
+Verify that "bear" appears as text, not emoji (would be 🐻 without escaping).
+If emoji substitution were happening, grep wouldn't find the text "bear".
+And filter to known artifact to avoid brittleness from search result changes.
+
+  $ jgo --color=plain search bear | grep bear | grep com.github.qydq:
+  *. com.github.qydq:bear:* (glob)
+
+  $ jgo --color=rich search bear | grep bear | grep com.github.qydq:
+  *. com.github.qydq:bear:* (glob)

tests/cli/search.t

@@ -32,36 +32,27 @@ Test search with query.
   $ jgo search scijava-ops
   Found 9 artifacts:
 
-  1. org.scijava:scijava-ops-indexer
-     Latest version: [0-9.]+ (re)
+  1. org.scijava:scijava-ops-indexer:1.0.0
 
-  2. org.scijava:scijava-ops-api
-     Latest version: [0-9.]+ (re)
+  2. org.scijava:scijava-ops-api:1.0.0
 
-  3. org.scijava:scijava-ops-engine
-     Latest version: [0-9.]+ (re)
+  3. org.scijava:scijava-ops-engine:1.0.0
 
-  4. org.scijava:scijava-ops-spi
-     Latest version: [0-9.]+ (re)
+  4. org.scijava:scijava-ops-spi:1.0.0
 
-  5. org.scijava:scijava-ops-flim
-     Latest version: [0-9.]+ (re)
+  5. org.scijava:scijava-ops-flim:1.0.0
 
-  6. org.scijava:scijava-ops-opencv
-     Latest version: [0-9.]+ (re)
+  6. org.scijava:scijava-ops-opencv:1.0.0
 
-  7. org.scijava:scijava-ops-image
-     Latest version: [0-9.]+ (re)
+  7. org.scijava:scijava-ops-image:1.0.0
 
-  8. org.scijava:scijava-ops-tutorial
-     Latest version: [0-9.]+ (re)
+  8. org.scijava:scijava-ops-tutorial:1.0.0
 
-  9. org.scijava:scijava-ops-ext-parser
-     Latest version: [0-9.]+ (re)
+  9. org.scijava:scijava-ops-ext-parser:1.0.0
 
 
 
 Test search with --dry-run.
 
   $ jgo --dry-run search jython
-  \[DRY-RUN\] Would search Maven Central for 'jython' with limit 20 (re)
+  [DRY-RUN] Would search Maven Central for 'jython' with limit 20