chore: Fix failing tests (#436)

Author: bobbyiliev

.github/workflows/cli.yml

@@ -49,7 +49,7 @@ jobs:
       working-directory: ${{env.working-directory}}
       run: |
         uv run flake8 ./ --count --select=E9,F63,F7,F82 --show-source --statistics
-        uv run flake8 ./ --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics
+        uv run flake8 ./ --count --exit-zero --max-complexity=10 --max-line-length=95 --statistics
 
     - name: Run Static Checks
       working-directory: ${{env.working-directory}}

cli/.flake8

@@ -1,8 +1,8 @@
 [flake8]
-max-line-length = 88
+max-line-length = 95
 extend-ignore = 
     # E203: whitespace before ':' (conflicts with black)
-    E203,  
+    E203,
     # W503: line break before binary operator (conflicts with black)
     W503,
     # E402: module level import not at top (needed for sys.path manipulation)

cli/README.md

@@ -21,6 +21,7 @@ The CLI will be installed as an editable package.
 ```bash
 linux-cli --help
 ```
+
 ### Options
 *   `--verbose`: Enable verbose output for debugging purposes.
     Example:
@@ -72,9 +73,14 @@ python scripts/generate_command_index.py
 
 That will create `cli/data/commands.json` which `show` and `search` will prefer when present. The test `tests/test_generate_index.py` exercises the generator.
 
-
 ## Development
 
+For development, ensure you have the development dependencies installed:
+
+```bash
+uv sync --frozen --group dev
+```
+
 ### Running Tests
 ```bash
 pytest
@@ -109,4 +115,4 @@ The CLI has its own workflow that runs:
 - Type checking (MyPy)
 - Tests (pytest)
 
-This workflow only triggers on changes to the `cli/` directory.
+This workflow only triggers on changes to the `cli/` directory.

cli/commands/search.py

@@ -1,12 +1,11 @@
-from typing import Dict, List
-
 import json
 from pathlib import Path
+from typing import Dict, List
+
 import typer
 
 from states.global_state import debug, verbose_flag
 
-
 app = typer.Typer(help=("Search available commands by keyword (name or description)."))
 
 

cli/commands/show.py

@@ -1,7 +1,7 @@
-from typing import Dict, TypedDict
-
 import json
 from pathlib import Path
+from typing import Dict, TypedDict
+
 import typer
 
 from states.global_state import debug, verbose_flag

cli/scripts/generate_command_index.py

@@ -5,116 +5,136 @@
 from each markdown file under ebook/en/content. Writes output to cli/data/commands.json
 """
 
-from pathlib import Path
-import re
 import json
+import re
 import sys
+from pathlib import Path
 
 
-def extract_from_markdown(path: Path) -> dict:
-    text = path.read_text(encoding="utf-8")
-    lines = text.splitlines()
-
-    # title: first heading line starting with '#'
-    title = None
+def _extract_title(lines: list[str]) -> str | None:
+    """Extract the first heading line starting with '#'."""
     for ln in lines:
         if ln.strip().startswith("#"):
-            title = ln.strip().lstrip("#").strip()
-            break
+            return ln.strip().lstrip("#").strip()
+    return None
+
 
-    # try to infer command name from code span in title like `ls`
-    name = None
+def _extract_command_name(title: str | None, path: Path) -> str:
+    """Extract command name from title or fallback to filename pattern."""
     if title:
+        # Try to infer command name from code span in title like `ls`
         m = re.search(r"`([a-zA-Z0-9_\-]+)`", title)
         if m:
-            name = m.group(1)
-        else:
-            # fallback: take last token of title
-            tokens = re.findall(r"\w+", title)
-            if tokens:
-                name = tokens[-1].lower()
-
-    # fallback: filename pattern 001-the-ls-command.md -> ls
-    if not name:
-        m = re.search(r"-the-([a-zA-Z0-9_\-]+)-command", path.name)
-        if m:
-            name = m.group(1)
-        else:
-            name = path.stem
+            return m.group(1)
+        # Fallback: take last token of title
+        tokens = re.findall(r"\w+", title)
+        if tokens:
+            return tokens[-1].lower()
+
+    # Fallback: filename pattern 001-the-ls-command.md -> ls
+    m = re.search(r"-the-([a-zA-Z0-9_\-]+)-command", path.name)
+    if m:
+        return m.group(1)
+
+    return path.stem
+
 
-    # description: first paragraph after title
-    desc = ""
+def _extract_description(lines: list[str]) -> str:
+    """Extract first paragraph after title."""
     try:
         idx = 0
         while idx < len(lines) and not lines[idx].strip().startswith("#"):
             idx += 1
-        # move to next line after title
+        # Move to next line after title
         idx += 1
-        # collect lines until empty line
+        # Collect lines until empty line
         para = []
         while idx < len(lines):
-            if lines[idx].strip() == "":
+            line = lines[idx].strip()
+            if line == "":
                 if para:
                     break
                 idx += 1
                 continue
-            if lines[idx].strip().startswith("###") or lines[idx].strip().startswith(
-                "##"
-            ):
+            if line.startswith("###") or line.startswith("##"):
                 if para:
                     break
-            para.append(lines[idx].strip())
+            para.append(line)
             idx += 1
-        desc = " ".join(para).strip()
+        return " ".join(para).strip()
     except Exception:
-        desc = ""
+        return ""
 
-    # usage: look for 'Syntax' or 'Usage' section code block
-    usage = ""
+
+def _extract_usage(text: str) -> str:
+    """Extract usage information from Syntax or Usage sections."""
     usage_match = re.search(
         r"###\s*Syntax\s*:\s*\n(```[\s\S]*?```)", text, flags=re.IGNORECASE
     )
     if usage_match:
-        usage = usage_match.group(1).strip().strip("`")
-    else:
-        m2 = re.search(r"Usage\s*[:|-]\s*(.+)", text, flags=re.IGNORECASE)
-        if m2:
-            usage = m2.group(1).strip()
-
-    # example: prefer first fenced code block under Examples or first code block
-    example = ""
+        return usage_match.group(1).strip().strip("`")
+
+    m2 = re.search(r"Usage\s*[:|-]\s*(.+)", text, flags=re.IGNORECASE)
+    if m2:
+        return m2.group(1).strip()
+
+    return ""
+
+
+def _extract_example(text: str) -> str:
+    """Extract example from Examples section or first code block."""
     examples_section = re.search(
         r"###\s*Examples[:\s]*\n([\s\S]*?)(?:\n###|\n##|$)", text, flags=re.IGNORECASE
     )
-    if examples_section:
-        # find first fenced code block inside
-        fb = re.search(
-            r"```(?:bash|sh|shell|).*?\n([\s\S]*?)```",
-            examples_section.group(1),
-            flags=re.IGNORECASE,
-        )
-        if fb:
-            example = fb.group(1).strip()
-        else:
-            # fallback: first inline code occurrence
-            ic = re.search(r"`([^`]+)`", examples_section.group(1))
-            if ic:
-                example = ic.group(1).strip()
-
-    # notes: capture 'Additional Flags' or remaining list items
-    notes = ""
+    if not examples_section:
+        return ""
+
+    # Find first fenced code block inside
+    fb = re.search(
+        r"```(?:bash|sh|shell|).*?\n([\s\S]*?)```",
+        examples_section.group(1),
+        flags=re.IGNORECASE,
+    )
+    if fb:
+        return fb.group(1).strip()
+
+    # Fallback: first inline code occurrence
+    ic = re.search(r"`([^`]+)`", examples_section.group(1))
+    if ic:
+        return ic.group(1).strip()
+
+    return ""
+
+
+def _extract_notes(text: str) -> str:
+    """Extract notes from Additional Flags/Notes sections or bullet points."""
     notes_section = re.search(
         r"###\s*(Additional Flags|Notes|Notes:|Additional).*?\n([\s\S]*?)(?:\n###|\n##|$)",
         text,
         flags=re.IGNORECASE,
     )
     if notes_section:
-        notes = notes_section.group(2).strip()
-    else:
-        # collect bullet points
-        bullets = re.findall(r"^\s*[-\*]\s+(.+)$", text, flags=re.MULTILINE)
-        if bullets:
-            notes = "; ".join(bullets[:10])
+        return notes_section.group(2).strip()
+
+    # Collect bullet points
+    bullets = re.findall(r"^\s*[-\*]\s+(.+)$", text, flags=re.MULTILINE)
+    if bullets:
+        return "; ".join(bullets[:10])
+
+    return ""
+
+
+def extract_from_markdown(path: Path) -> dict:
+    """Extract command information from a markdown file."""
+    text = path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+
+    title = _extract_title(lines)
+    name = _extract_command_name(title, path)
+    desc = _extract_description(lines)
+    usage = _extract_usage(text)
+    example = _extract_example(text)
+    notes = _extract_notes(text)
 
     return {
         "name": name,

cli/tests/test_cli.py

@@ -49,7 +49,7 @@ def clean_output(text: str) -> str:
         ),
         (("show", "ls"), ("ls", "List"), 0),
         (("--verbose", "show", "ls"), ("[DEBUG] Showing details for command: ls"), 0),
-        (("show", "grep"), ("Search",), 0),
+        (("show", "grep"), ("searches",), 0),
         (
             ("--verbose", "show", "grep"),
             ("[DEBUG] Showing details for command: grep"),

cli/tests/test_generate_index.py

@@ -1,10 +1,10 @@
 #!/usr/bin/env python3
 """Tests for the generator script that builds cli/data/commands.json."""
 
-from pathlib import Path
+import json
 import subprocess
 import sys
-import json
+from pathlib import Path
 
 
 def test_generate_index_creates_file():