@heretek-ai/epistemic-swarm 0.4.7 → 0.4.8

package/skills/epistemic_search/scripts/search.py

@@ -4,30 +4,127 @@ Zero-API-Key Web Search Engine for IUMBTEMS.
 DuckDuckGo HTML/lite parser with domain filtering and Claude Code XML formatting.
 """
 
-import sys
 import json
 import re
-import urllib.request
+import sys
 import urllib.parse
-from typing import List, Dict, Optional
+import urllib.request
+from html.parser import HTMLParser
+from typing import Dict, List, Optional, Tuple
+from xml.sax.saxutils import escape as xml_escape
 
 USER_AGENT = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
 
-def search_duckduckgo(
+
+class DDGLiteParser(HTMLParser):
+    """Linear, non-backtracking HTML parser for DuckDuckGo Lite search results.
+
+    DuckDuckGo Lite emits one table row per result: an ``<a class="result-link">``
+    holding the title and a ``<td class="result-snippet">`` holding the summary.
+    Results are assembled **per row** so that:
+
+    * a missing link or snippet cannot desynchronise every later result (the old
+      ``zip(links, snippets)`` pairing shifted all subsequent rows), and
+    * nested markup inside a snippet — including a nested
+      ``<a class="result-link">`` — never hijacks capture state (the old parser
+      reset its buffer mid-snippet and then never recorded the snippet at all).
+
+    Captured text is stored decoded (``convert_charrefs`` default); escaping is
+    done at emit time by :func:`format_xml`.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.results: List[Dict[str, str]] = []
+        self._row_href: Optional[str] = None
+        self._row_title: List[str] = []
+        self._row_snippet: List[str] = []
+        self._capture: Optional[str] = None  # "title" | "snippet" | None
+        self._depth = 0  # nesting depth of the tag that opened the capture
+
+    def handle_starttag(self, tag: str, attrs: List[Tuple[str, Optional[str]]]):
+        attr_dict = {k: v or "" for k, v in attrs}
+        classes = attr_dict.get("class", "").split()
+
+        if tag == "tr":
+            self.flush()
+            return
+
+        # While capturing a snippet, nested markup (including a nested
+        # result-link) stays inside the snippet. Only track nested <td> so the
+        # capture still ends at the *outer* </td>.
+        if self._capture == "snippet":
+            if tag == "td":
+                self._depth += 1
+            return
+
+        # Likewise for a title: a nested <a> must not close the capture early.
+        if self._capture == "title":
+            if tag == "a":
+                self._depth += 1
+            return
+
+        if tag == "a" and "result-link" in classes:
+            # Row-less fallback: a new result-link implies the previous result
+            # is complete even if no <tr> ever bounded it.
+            if self._row_href is not None:
+                self.flush()
+            self._capture = "title"
+            self._depth = 1
+            self._row_href = attr_dict.get("href", "")
+            self._row_title = []
+        elif tag == "td" and "result-snippet" in classes:
+            self._capture = "snippet"
+            self._depth = 1
+            self._row_snippet = []
+
+    def handle_endtag(self, tag: str):
+        if self._capture == "title" and tag == "a":
+            self._depth -= 1
+            if self._depth <= 0:
+                self._capture = None
+        elif self._capture == "snippet" and tag == "td":
+            self._depth -= 1
+            if self._depth <= 0:
+                self._capture = None
+        elif tag == "tr":
+            self.flush()
+
+    def handle_data(self, data: str):
+        if self._capture == "title":
+            self._row_title.append(data)
+        elif self._capture == "snippet":
+            self._row_snippet.append(data)
+
+    def flush(self):
+        """Emit the in-progress row, if any. Call after ``feed()`` completes."""
+        if self._row_href is not None:
+            self.results.append({
+                "href": self._row_href,
+                "title": "".join(self._row_title).strip(),
+                "snippet": "".join(self._row_snippet).strip(),
+            })
+        self._row_href = None
+        self._row_title = []
+        self._row_snippet = []
+        self._capture = None
+        self._depth = 0
+
+
+def _build_search_query(
     query: str,
     allowed_domains: Optional[List[str]] = None,
     blocked_domains: Optional[List[str]] = None,
-    max_results: int = 10
-) -> List[Dict[str, str]]:
-    """Execute search query against DuckDuckGo Lite without API keys."""
+) -> str:
     effective_query = query.strip()
     if allowed_domains:
-        domain_filters = " " + " OR ".join(f"site:{d}" for d in allowed_domains)
-        effective_query += domain_filters
+        effective_query += " " + " OR ".join(f"site:{d}" for d in allowed_domains)
     if blocked_domains:
-        domain_filters = " " + " ".join(f"-site:{d}" for d in blocked_domains)
-        effective_query += domain_filters
+        effective_query += " " + " ".join(f"-site:{d}" for d in blocked_domains)
+    return effective_query
 
+
+def _fetch_ddg_html(effective_query: str) -> str:
     url = "https://lite.duckduckgo.com/lite/"
     data = urllib.parse.urlencode({"q": effective_query}).encode("utf-8")
     headers = {
@@ -36,112 +133,143 @@ def search_duckduckgo(
         "Accept-Language": "en-US,en;q=0.5",
         "Referer": "https://lite.duckduckgo.com/",
     }
-
     req = urllib.request.Request(url, data=data, headers=headers)
     try:
         with urllib.request.urlopen(req, timeout=15) as resp:
-            html = resp.read().decode("utf-8", errors="replace")
+            return resp.read().decode("utf-8", errors="replace")
     except Exception as e:
         sys.stderr.write(f"[epistemic-search] Network error fetching search results: {e}\n")
+        return ""
+
+
+def _parse_clean_url(href: str) -> str:
+    m = re.search(r"uddg=([^&]+)", href)
+    if m:
+        return urllib.parse.unquote(m.group(1))
+    return href
+
+
+def _is_domain_allowed(
+    hostname: str,
+    allowed_domains: Optional[List[str]] = None,
+    blocked_domains: Optional[List[str]] = None,
+) -> bool:
+    if allowed_domains and not any(hostname == d or hostname.endswith("." + d) for d in allowed_domains):
+        return False
+    if blocked_domains and any(hostname == d or hostname.endswith("." + d) for d in blocked_domains):
+        return False
+    return True
+
+
+def search_duckduckgo(
+    query: str,
+    allowed_domains: Optional[List[str]] = None,
+    blocked_domains: Optional[List[str]] = None,
+    max_results: int = 10,
+) -> List[Dict[str, str]]:
+    """Execute search query against DuckDuckGo Lite without API keys."""
+    effective_query = _build_search_query(query, allowed_domains, blocked_domains)
+    html = _fetch_ddg_html(effective_query)
+    if not html:
         return []
 
-    # Parse result links and snippets from DuckDuckGo Lite table rows
-    links = re.findall(
-        r"<a[^>]*href=['\"]([^'\"]+)['\"][^>]*class=['\"]result-link['\"][^>]*>(.*?)</a>",
-        html,
-        re.DOTALL
-    )
-    snippets = re.findall(
-        r"<td[^>]+class=['\"]result-snippet['\"][^>]*>(.*?)</td>",
-        html,
-        re.DOTALL
-    )
+    parser = DDGLiteParser()
+    parser.feed(html)
+    parser.flush()
 
     results = []
-    for (href, title_html), snip_html in zip(links, snippets):
-        # Unwrap DuckDuckGo redirect if present
-        m = re.search(r"uddg=([^&]+)", href)
-        if m:
-            clean_url = urllib.parse.unquote(m.group(1))
-        else:
-            clean_url = href
-
+    for row in parser.results:
+        clean_url = _parse_clean_url(row["href"])
         if not clean_url.startswith("http"):
             continue
 
-        clean_title = re.sub(r"<[^>]+>", "", title_html).strip()
-        clean_snippet = re.sub(r"<[^>]+>", "", snip_html).strip()
-
-        # Check domain filtering manually in case DDG syntax didn't catch all
         parsed_url = urllib.parse.urlparse(clean_url)
         hostname = parsed_url.hostname or ""
-        if allowed_domains and not any(hostname == d or hostname.endswith("." + d) for d in allowed_domains):
-            continue
-        if blocked_domains and any(hostname == d or hostname.endswith("." + d) for d in blocked_domains):
+        if not _is_domain_allowed(hostname, allowed_domains, blocked_domains):
             continue
 
         results.append({
-            "title": clean_title,
+            "title": row["title"],
             "url": clean_url,
-            "snippet": clean_snippet
+            "snippet": row["snippet"],
         })
-
         if len(results) >= max_results:
             break
 
     return results
 
+
 def format_xml(results: List[Dict[str, str]]) -> str:
-    """Format results as Claude Code <search_results> XML."""
+    """Format results as Claude Code <search_results> XML.
+
+    Every field is XML-escaped at emit time. The parser stores decoded text, so
+    without this a snippet like ``A &amp; B`` becomes ``A & B`` and produces
+    malformed markup (bare ``&``); URLs containing query strings have the same
+    problem.
+    """
     lines = ["<search_results>"]
     for r in results:
         lines.append("  <result>")
-        lines.append(f"    <title>{urllib.parse.quote(r['title'])}</title>")
-        lines.append(f"    <url>{r['url']}</url>")
-        lines.append(f"    <snippet>{r['snippet']}</snippet>")
+        lines.append(f"    <title>{xml_escape(r['title'])}</title>")
+        lines.append(f"    <url>{xml_escape(r['url'])}</url>")
+        lines.append(f"    <snippet>{xml_escape(r['snippet'])}</snippet>")
         lines.append("  </result>")
     lines.append("</search_results>")
     return "\n".join(lines)
 
-def main():
-    query = ""
-    allowed_domains = None
-    blocked_domains = None
-    output_json = False
 
-    # Check stdin first
-    if not sys.stdin.isatty():
+def _read_stdin_payload() -> Tuple[str, Optional[List[str]], Optional[List[str]]]:
+    if sys.stdin.isatty():
+        return "", None, None
+    try:
+        data = sys.stdin.read().strip()
+        if not data:
+            return "", None, None
         try:
-            stdin_data = sys.stdin.read().strip()
-            if stdin_data:
-                try:
-                    payload = json.loads(stdin_data)
-                    query = payload.get("query", "")
-                    allowed_domains = payload.get("allowed_domains")
-                    blocked_domains = payload.get("blocked_domains")
-                except json.JSONDecodeError:
-                    query = stdin_data
-        except Exception:
-            pass
-
-    # Command line args override
-    args = sys.argv[1:]
+            payload = json.loads(data)
+            return (
+                payload.get("query", ""),
+                payload.get("allowed_domains"),
+                payload.get("blocked_domains"),
+            )
+        except json.JSONDecodeError:
+            return data, None, None
+    except Exception:
+        return "", None, None
+
+
+def _parse_cli_args(
+    args: List[str],
+    default_query: str = "",
+    default_allowed: Optional[List[str]] = None,
+    default_blocked: Optional[List[str]] = None,
+) -> Tuple[str, Optional[List[str]], Optional[List[str]], bool]:
+    query = default_query
+    allowed = default_allowed
+    blocked = default_blocked
+    output_json = False
     idx = 0
     while idx < len(args):
         arg = args[idx]
         if arg == "--json":
             output_json = True
         elif arg == "--allowed-domain" and idx + 1 < len(args):
-            allowed_domains = allowed_domains or []
-            allowed_domains.append(args[idx + 1])
+            allowed = (allowed or []) + [args[idx + 1]]
             idx += 1
         elif arg == "--blocked-domain" and idx + 1 < len(args):
-            blocked_domains = blocked_domains or []
-            blocked_domains.append(args[idx + 1])
+            blocked = (blocked or []) + [args[idx + 1]]
             idx += 1
         elif not query and not arg.startswith("--"):
             query = arg
         idx += 1
+    return query, allowed, blocked, output_json
+
+
+def main():
+    std_query, std_allowed, std_blocked = _read_stdin_payload()
+    query, allowed, blocked, output_json = _parse_cli_args(
+        sys.argv[1:], std_query, std_allowed, std_blocked
+    )
 
     if not query:
         sys.stderr.write("Usage: search.py [options] <query>\nOr pipe JSON: echo '{\"query\":\"...\"}' | search.py\n")
@@ -149,8 +277,8 @@ def main():
 
     results = search_duckduckgo(
         query=query,
-        allowed_domains=allowed_domains,
-        blocked_domains=blocked_domains
+        allowed_domains=allowed,
+        blocked_domains=blocked,
     )
 
     if output_json:
@@ -158,5 +286,6 @@ def main():
     else:
         print(format_xml(results))
 
+
 if __name__ == "__main__":
     main()

package/skills/epistemic_search/scripts/webcache.py

@@ -277,7 +277,7 @@ def main(argv):
     handler = {"gate": cmd_gate, "archive": cmd_archive, "stats": cmd_stats}.get(mode)
     if handler is None:
         log(f"unknown mode: {mode}")
-        return 0
+        return 1
     try:
         out = handler(stdin_data)
     except Exception as e:

package/skills/grilling/socratic_tree.py

@@ -5,6 +5,7 @@ Implements Matt Pocock-style design tree traversal to isolate the active decisio
 """
 
 import sys
+import os
 import json
 import argparse
 from pathlib import Path
@@ -84,7 +85,8 @@ class DesignTree:
         return len(self.compute_frontier()) == 0 and all(n.is_settled() for n in self.nodes.values())
 
     def export_frontier_json(self, output_path: Path):
-        output_path.parent.mkdir(parents=True, exist_ok=True)
+        safe_path = Path(os.path.realpath(str(output_path)))
+        safe_path.parent.mkdir(parents=True, exist_ok=True)
         data = {
             "objective": self.objective,
             "is_complete": self.is_complete(),
@@ -93,12 +95,13 @@ class DesignTree:
                 k: v.settled_answer for k, v in self.nodes.items() if v.is_settled()
             }
         }
-        with open(output_path, "w", encoding="utf-8") as f:
+        with open(safe_path, "w", encoding="utf-8") as f:
             json.dump(data, f, indent=2)
 
     @classmethod
     def load_from_json(cls, file_path: Path) -> 'DesignTree':
-        with open(file_path, "r", encoding="utf-8") as f:
+        safe_path = Path(os.path.realpath(str(file_path)))
+        with open(safe_path, "r", encoding="utf-8") as f:
             data = json.load(f)
         tree = cls(objective=data["objective"])
         for k, v in data.get("nodes", {}).items():
@@ -106,15 +109,31 @@ class DesignTree:
         return tree
 
 
+def _display_frontier(tree: DesignTree, frontier: list) -> None:
+    print(f"\n🎯 Objective: {tree.objective}")
+    print(f"📊 Total Nodes: {len(tree.nodes)} | Settled: {sum(1 for n in tree.nodes.values() if n.is_settled())}")
+    if not frontier:
+        if tree.nodes and tree.is_complete():
+            print("✅ Frontier is EMPTY. All prerequisite branches are fully settled!")
+        else:
+            print("ℹ️ No active frontier nodes. Define new decision nodes to begin grilling.")
+    else:
+        print(f"\n⚡ Current Active Frontier ({len(frontier)} questions ready):")
+        for idx, node in enumerate(frontier, 1):
+            print(f"\n❓ Q{idx} [{node.node_id}] - {node.title}")
+            print(f"   {node.question}")
+            print(f"   ➡️ Recommended: {node.recommended}")
+
+
 def main():
     parser = argparse.ArgumentParser(description="Epistemic Swarm Socratic Decision Tree")
     parser.add_argument("--objective", type=str, help="Research objective")
     parser.add_argument("--file", type=str, default=".research/frontier.json", help="Path to frontier.json")
     parser.add_argument("--show-frontier", action="store_true", help="Print the current decision frontier")
     parser.add_argument("--settle", nargs=2, metavar=("NODE_ID", "ANSWER"), help="Settle a decision node")
-    
+
     args = parser.parse_args()
-    frontier_path = Path(args.file)
+    frontier_path = Path(os.path.realpath(str(args.file)))
 
     if frontier_path.exists():
         tree = DesignTree.load_from_json(frontier_path)
@@ -130,19 +149,8 @@ def main():
 
     frontier = tree.compute_frontier()
     if args.show_frontier or not args.settle:
-        print(f"\n🎯 Objective: {tree.objective}")
-        print(f"📊 Total Nodes: {len(tree.nodes)} | Settled: {sum(1 for n in tree.nodes.values() if n.is_settled())}")
-        if not frontier:
-            if tree.nodes and tree.is_complete():
-                print("✅ Frontier is EMPTY. All prerequisite branches are fully settled!")
-            else:
-                print("ℹ️ No active frontier nodes. Define new decision nodes to begin grilling.")
-        else:
-            print(f"\n⚡ Current Active Frontier ({len(frontier)} questions ready):")
-            for idx, node in enumerate(frontier, 1):
-                print(f"\n❓ Q{idx} [{node.node_id}] - {node.title}")
-                print(f"   {node.question}")
-                print(f"   ➡️ Recommended: {node.recommended}")
+        _display_frontier(tree, frontier)
+
 
 if __name__ == "__main__":
     main()

package/skills/research_cache/hasher.py

@@ -14,10 +14,14 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, Any, Optional, Tuple
 
+DEFAULT_RESEARCH_DIR = ".research"
+BASE_DIR_HELP = "Base .research directory"
+
 class SourceHasher:
     def __init__(self, base_dir: Optional[Path] = None):
-        self.base_dir = base_dir or Path(".research")
-        self.sources_dir = self.base_dir / "sources"
+        target = base_dir or Path(DEFAULT_RESEARCH_DIR)
+        self.base_dir = Path(os.path.realpath(str(target)))
+        self.sources_dir = Path(os.path.realpath(str(self.base_dir / "sources")))
         self.sources_dir.mkdir(parents=True, exist_ok=True)
 
     @staticmethod
@@ -70,15 +74,28 @@ class SourceHasher:
         return None
 
     def _resolve_hash_file(self, hash_prefix: str, extension: str) -> Optional[Path]:
-        """Resolves exact or prefix hash to disk path."""
-        exact_path = self.sources_dir / f"{hash_prefix}{extension}"
+        """Resolves exact or prefix hash to disk path.
+
+        ``hash_prefix`` is untrusted (it arrives from an LLM tool call), so the
+        result is required to stay inside ``sources_dir``. Containment is checked
+        inline rather than via ``runner.path_safety`` because this module is
+        mirrored into the standalone ``research-cache`` plugin, which has no
+        ``runner`` package on its path.
+        """
+        if not re.match(r"^[a-fA-F0-9]+$", hash_prefix):
+            return None
+        exact_path = Path(os.path.realpath(str(self.sources_dir / f"{hash_prefix}{extension}")))
+        if exact_path.parent != self.sources_dir:
+            return None
         if exact_path.exists():
             return exact_path
 
         # If prefix match
         matches = list(self.sources_dir.glob(f"{hash_prefix}*{extension}"))
         if len(matches) == 1:
-            return matches[0]
+            candidate = Path(os.path.realpath(str(matches[0])))
+            if candidate.parent == self.sources_dir:
+                return candidate
         return None
 
     @staticmethod
@@ -143,20 +160,21 @@ def main():
     cache_parser.add_argument("--title", default="Untitled", help="Document Title")
     cache_parser.add_argument("--tier", default="WEB_DOCUMENT", help="Source tier")
     cache_parser.add_argument("--content", help="Raw text content (or read from stdin)")
-    cache_parser.add_argument("--dir", default=".research", help="Base .research directory")
+    cache_parser.add_argument("--dir", default=DEFAULT_RESEARCH_DIR, help=BASE_DIR_HELP)
 
     # Verify command
     verify_parser = subparsers.add_parser("verify", help="Verify a verbatim quote")
     verify_parser.add_argument("--hash", required=True, help="Document SHA-256 hash")
     verify_parser.add_argument("--quote", required=True, help="Verbatim quote to check")
-    verify_parser.add_argument("--dir", default=".research", help="Base .research directory")
+    verify_parser.add_argument("--dir", default=DEFAULT_RESEARCH_DIR, help=BASE_DIR_HELP)
 
     # List command
     list_parser = subparsers.add_parser("list", help="List cached sources")
-    list_parser.add_argument("--dir", default=".research", help="Base .research directory")
+    list_parser.add_argument("--dir", default=DEFAULT_RESEARCH_DIR, help=BASE_DIR_HELP)
 
     args = parser.parse_args()
-    hasher = SourceHasher(base_dir=Path(args.dir if hasattr(args, "dir") else ".research"))
+    dir_val = getattr(args, "dir", DEFAULT_RESEARCH_DIR) or DEFAULT_RESEARCH_DIR
+    hasher = SourceHasher(base_dir=Path(os.path.realpath(str(dir_val))))
 
     if args.command == "cache":
         content = args.content

package/skills/swarm_config/configure.py

@@ -10,6 +10,8 @@ import json
 from pathlib import Path
 from typing import Dict, Any
 
+DEFAULT_RESEARCH_DIR = ".research"
+
 DEFAULT_CONFIG: Dict[str, Any] = {
     "search_engine": "duckduckgo",
     "max_iterations": 2,
@@ -17,7 +19,7 @@ DEFAULT_CONFIG: Dict[str, Any] = {
     "mode": "research",  # "research", "audit", "scout", "hybrid", "brainstorm"
     "cache_raw_markdown": True,
     "license_whitelist": ["MIT", "Apache-2.0", "BSD-3-Clause", "ISC"],
-    "output_dir": ".research",
+    "output_dir": DEFAULT_RESEARCH_DIR,
     # Scope allocation policy (Stream F): "dag" = legacy dependency-first
     # order; "auction" = Frontier Markets (highest expected-information-gain
     # bid first). Default "dag" preserves existing behavior exactly.
@@ -37,11 +39,11 @@ DEFAULT_CONFIG: Dict[str, Any] = {
 }
 
 
-def get_config_path(base_dir: str = ".research") -> Path:
+def get_config_path(base_dir: str = DEFAULT_RESEARCH_DIR) -> Path:
     return Path(base_dir) / "config.json"
 
 
-def load_config(base_dir: str = ".research") -> Dict[str, Any]:
+def load_config(base_dir: str = DEFAULT_RESEARCH_DIR) -> Dict[str, Any]:
     cfg_file = get_config_path(base_dir)
     if not cfg_file.exists():
         return dict(DEFAULT_CONFIG)
@@ -58,7 +60,7 @@ def load_config(base_dir: str = ".research") -> Dict[str, Any]:
         return dict(DEFAULT_CONFIG)
 
 
-def save_config(cfg: Dict[str, Any], base_dir: str = ".research") -> Path:
+def save_config(cfg: Dict[str, Any], base_dir: str = DEFAULT_RESEARCH_DIR) -> Path:
     target_dir = Path(base_dir)
     target_dir.mkdir(parents=True, exist_ok=True)
     cfg_file = target_dir / "config.json"
@@ -136,27 +138,7 @@ def run_interactive(cfg: Dict[str, Any]) -> Dict[str, Any]:
     return cfg
 
 
-def main():
-    cfg = load_config()
-    args = sys.argv[1:]
-
-    if not args or "--show" in args:
-        display_config(cfg)
-        if not args:
-            print("To edit settings, run:")
-            print("  python3 skills/swarm_config/configure.py --interactive")
-            print(
-                "  python3 skills/swarm_config/configure.py --engine duckduckgo --depth 3 --mode audit\n"
-            )
-        return
-
-    if "--interactive" in args or "-i" in args:
-        cfg = run_interactive(cfg)
-        cfg_path = save_config(cfg)
-        print(f"✅ Configuration saved to {cfg_path}")
-        display_config(cfg)
-        return
-
+def _parse_cli_updates(args: list, cfg: Dict[str, Any]) -> bool:
     idx = 0
     modified = False
     while idx < len(args):
@@ -188,13 +170,35 @@ def main():
                 pass
             idx += 1
         idx += 1
+    return modified
+
 
+def main():
+    cfg = load_config()
+    args = sys.argv[1:]
+
+    if not args or "--show" in args:
+        display_config(cfg)
+        if not args:
+            print("To edit settings, run:")
+            print("  python3 skills/swarm_config/configure.py --interactive")
+            print(
+                "  python3 skills/swarm_config/configure.py --engine duckduckgo --depth 3 --mode audit\n"
+            )
+        return
+
+    if "--interactive" in args or "-i" in args:
+        cfg = run_interactive(cfg)
+        cfg_path = save_config(cfg)
+        print(f"✅ Configuration saved to {cfg_path}")
+        display_config(cfg)
+        return
+
+    modified = _parse_cli_updates(args, cfg)
     if modified:
         cfg_path = save_config(cfg)
         print(f"✅ Configuration updated and saved to {cfg_path}")
-        display_config(cfg)
-    else:
-        display_config(cfg)
+    display_config(cfg)
 
 
 if __name__ == "__main__":