utim-cli 2.3.14__tar.gz → 2.3.15__tar.gz

{utim_cli-2.3.14 → utim_cli-2.3.15}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [2.3.15] - 2026-08-29
+
+### 🛠️ Minor Enhancements and Tool Call Bug Fixes
+- Minor enhancements and fixed tool call bugs
+
 ## [2.3.14] - 2026-08-28
 
 ### ⚡ Request Queue & Scaled Free Capacity

{utim_cli-2.3.14/utim_cli.egg-info → utim_cli-2.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.14
+Version: 2.3.15
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev

{utim_cli-2.3.14 → utim_cli-2.3.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.14"
+version = "2.3.15"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"

{utim_cli-2.3.14 → utim_cli-2.3.15}/utim/__init__.py

@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.3.14"
+    __version__ = "2.3.15"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

{utim_cli-2.3.14 → utim_cli-2.3.15}/utim_cli/__init__.py

@@ -5,7 +5,7 @@ try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
     # Fallback during first-install / editable-install edge cases
-    __version__ = "2.3.14"
+    __version__ = "2.3.15"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.14 → utim_cli-2.3.15}/utim_cli/_version.py

@@ -11,6 +11,6 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.3.14"
+VERSION = "2.3.15"
 
 

{utim_cli-2.3.14 → utim_cli-2.3.15}/utim_cli/agent.py

@@ -168,6 +168,13 @@ class ReActAgent:
                     arguments[key] = val
             tool_name = actual_name
 
+        # Collapse duplicated tool names (e.g. 'read_fileread_file', 'read_file read_file',
+        # 'run_commandrun_command') produced by buggy model/proxy tool-call serialization.
+        import re as _re_dup
+        _dup_match = _re_dup.match(r'^([a-zA-Z_]\w*)[\s_]*\1$', tool_name)
+        if _dup_match:
+            tool_name = _dup_match.group(1)
+
         # Map common alias tool names to actual UTIM CLI tool names
         _TOOL_NAME_ALIASES = {
             "shell": "run_command",

{utim_cli-2.3.14 → utim_cli-2.3.15}/utim_cli/crawler/markdown_distiller.py

@@ -1,251 +1,258 @@
-"""Semantic Markdown Distiller for UTIM HyperCrawler.
-
-Transforms raw HTML documents into dense, structured, noise-free Markdown.
-Preserves:
-- Tables (converted to standard GitHub-Flavored Markdown tables)
-- Code blocks (with syntax language identifiers)
-- Headings (#, ##, ###, etc.)
-- Lists (ordered and unordered)
-- Emphasis (bold, italics, inline code)
-- Main article content (stripping navbars, footers, cookie banners, ads, SVGs)
-"""
-
-from __future__ import annotations
-
-import re
-import html as html_lib
-from typing import Optional, Tuple, List
-from bs4 import BeautifulSoup, Comment, NavigableString, Tag
-
-
-# Tags to remove entirely (including their contents)
-_NOISE_TAGS = {
-    "script", "style", "nav", "footer", "header", "aside", "noscript",
-    "iframe", "svg", "canvas", "form", "button", "dialog", "menu",
-}
-
-# Common noise classes / IDs in modern web design
-_NOISE_CLASS_PATTERNS = re.compile(
-    r"(ad[s\-_]|banner|cookie|consent|popup|modal|sidebar|newsletter|social|share|widget|tracking|promo)",
-    re.IGNORECASE,
-)
-
-
-class SemanticMarkdownDistiller:
-    """Converts HTML into token-efficient, highly-structured Markdown for LLMs."""
-
-    def __init__(self, max_length: int = 40000):
-        self.max_length = max_length
-
-    def distill(self, html_content: str, base_url: str = "") -> Tuple[str, str]:
-        """Distills raw HTML into (clean_markdown, page_title)."""
-        if not html_content or not html_content.strip():
-            return "", ""
-
-        try:
-            soup = BeautifulSoup(html_content, "html.parser")
-        except Exception:
-            # Fallback simple regex extraction if parser fails
-            text = re.sub(r"<[^>]+>", " ", html_content)
-            return html_lib.unescape(text).strip()[:self.max_length], ""
-
-        # 1. Extract Page Title
-        title = ""
-        title_el = soup.find("title") or soup.find("h1")
-        if title_el:
-            title = title_el.get_text(strip=True)
-
-        # 2. Strip comments and unwanted noise elements
-        for comment in soup.find_all(string=lambda s: isinstance(s, Comment)):
-            comment.extract()
-
-        for tag_name in _NOISE_TAGS:
-            for el in soup.find_all(tag_name):
-                el.decompose()
-
-        # 3. Strip obvious ad and cookie banner containers
-        for el in soup.find_all(["div", "section", "aside"]):
-            classes = " ".join(el.get("class", [])) if el.get("class") else ""
-            el_id = el.get("id", "")
-            if _NOISE_CLASS_PATTERNS.search(classes) or _NOISE_CLASS_PATTERNS.search(el_id):
-                # Only decompose if it doesn't contain main article/content
-                if not any(k in (classes + el_id).lower() for k in ("article", "content", "main", "post", "entry")):
-                    el.decompose()
-
-        # 4. Target the main content container if present
-        main_content = (
-            soup.find("main")
-            or soup.find("article")
-            or soup.find("div", {"id": re.compile(r"(content|main|article|docs|post)", re.I)})
-            or soup.find("div", {"class": re.compile(r"(content|main|article|docs|post-body)", re.I)})
-            or soup.body
-            or soup
-        )
-
-        # 5. Recursively convert DOM tree to Markdown
-        md_text = self._convert_element(main_content).strip()
-
-        # 6. Normalize whitespace and blank lines
-        md_text = re.sub(r"\n{3,}", "\n\n", md_text)
-
-        if len(md_text) > self.max_length:
-            md_text = md_text[:self.max_length] + "\n\n... [Content truncated for length] ..."
-
-        return md_text, title
-
-    def _convert_element(self, element) -> str:
-        """Recursively converts a BeautifulSoup Tag into Markdown."""
-        if element is None:
-            return ""
-
-        if isinstance(element, NavigableString):
-            text = str(element)
-            # Normalize whitespace within inline text
-            return re.sub(r"[ \t\r\f\v]+", " ", text)
-
-        tag = element.name.lower() if element.name else ""
-
-        # Headings
-        if tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
-            level = int(tag[1])
-            inner = self._get_inner_text(element).strip()
-            if inner:
-                return f"\n\n{'#' * level} {inner}\n\n"
-            return ""
-
-        # Paragraphs & Blocks
-        if tag in ("p", "div", "section", "article"):
-            inner = "".join(self._convert_element(c) for c in element.children).strip()
-            if inner:
-                return f"\n\n{inner}\n\n"
-            return ""
-
-        # Code Blocks (<pre><code> or <pre>)
-        if tag == "pre":
-            code_el = element.find("code")
-            lang = ""
-            if code_el and code_el.get("class"):
-                for c in code_el["class"]:
-                    if c.startswith("language-") or c.startswith("lang-"):
-                        lang = c.split("-", 1)[1]
-                        break
-            code_text = (code_el or element).get_text()
-            return f"\n\n```{lang}\n{code_text.rstrip()}\n```\n\n"
-
-        # Inline Code (<code>)
-        if tag == "code":
-            code_text = element.get_text()
-            if "\n" in code_text:
-                return f"\n\n```\n{code_text.rstrip()}\n```\n\n"
-            return f"`{code_text.strip()}`"
-
-        # Blockquote
-        if tag == "blockquote":
-            inner = "".join(self._convert_element(c) for c in element.children).strip()
-            lines = [f"> {l}" for l in inner.splitlines()]
-            return "\n\n" + "\n".join(lines) + "\n\n"
-
-        # Lists (<ul>, <ol>)
-        if tag in ("ul", "ol"):
-            items = []
-            is_ordered = (tag == "ol")
-            for idx, li in enumerate(element.find_all("li", recursive=False)):
-                prefix = f"{idx + 1}. " if is_ordered else "- "
-                li_text = "".join(self._convert_element(c) for c in li.children).strip()
-                if li_text:
-                    items.append(f"{prefix}{li_text}")
-            if items:
-                return "\n\n" + "\n".join(items) + "\n\n"
-            return ""
-
-        # List item
-        if tag == "li":
-            return "".join(self._convert_element(c) for c in element.children).strip()
-
-        # Tables (<table>) -> Markdown Table
-        if tag == "table":
-            return self._convert_table(element)
-
-        # Emphasis & Formatting
-        if tag in ("strong", "b"):
-            inner = "".join(self._convert_element(c) for c in element.children).strip()
-            return f"**{inner}**" if inner else ""
-
-        if tag in ("em", "i"):
-            inner = "".join(self._convert_element(c) for c in element.children).strip()
-            return f"*{inner}*" if inner else ""
-
-        # Links (<a>)
-        if tag == "a":
-            href = element.get("href", "").strip()
-            inner = "".join(self._convert_element(c) for c in element.children).strip()
-            if href and inner and not href.startswith("javascript:") and not href.startswith("#"):
-                return f"[{inner}]({href})"
-            return inner
-
-        # Images (<img>)
-        if tag == "img":
-            alt = element.get("alt", "").strip()
-            src = element.get("src", "").strip()
-            if src and not src.startswith("data:"):
-                return f"![{alt}]({src})"
-            return f"[{alt}]" if alt else ""
-
-        # Line Break (<br>, <hr>)
-        if tag == "br":
-            return "\n"
-        if tag == "hr":
-            return "\n\n---\n\n"
-
-        # Default: traverse children
-        return "".join(self._convert_element(c) for c in element.children)
-
-    def _get_inner_text(self, tag: Tag) -> str:
-        """Extracts clean text without extra formatting."""
-        return tag.get_text(separator=" ", strip=True)
-
-    def _convert_table(self, table_tag: Tag) -> str:
-        """Converts HTML table into a clean GitHub Flavored Markdown table."""
-        rows = table_tag.find_all("tr")
-        if not rows:
-            return ""
-
-        table_matrix: List[List[str]] = []
-        for r in rows:
-            cols = r.find_all(["th", "td"])
-            col_texts = []
-            for c in cols:
-                # Get text and clean pipe characters to prevent markdown table breakage
-                c_text = "".join(self._convert_element(child) for child in c.children).strip()
-                c_text = c_text.replace("\n", " ").replace("|", "\\|")
-                col_texts.append(c_text)
-            if any(col_texts):
-                table_matrix.append(col_texts)
-
-        if not table_matrix:
-            return ""
-
-        # Normalize column widths
-        max_cols = max(len(r) for r in table_matrix)
-        for r in table_matrix:
-            while len(r) < max_cols:
-                r.append("")
-
-        header_row = table_matrix[0]
-        separator_row = ["---"] * max_cols
-        body_rows = table_matrix[1:] if len(table_matrix) > 1 else []
-
-        lines = [
-            "| " + " | ".join(header_row) + " |",
-            "| " + " | ".join(separator_row) + " |",
-        ]
-        for r in body_rows:
-            lines.append("| " + " | ".join(r) + " |")
-
-        return "\n\n" + "\n".join(lines) + "\n\n"
-
-
-def html_to_markdown(html_content: str, base_url: str = "", max_length: int = 40000) -> Tuple[str, str]:
-    """Convenience function to distill HTML into clean Markdown."""
-    distiller = SemanticMarkdownDistiller(max_length=max_length)
-    return distiller.distill(html_content, base_url=base_url)
+"""Semantic Markdown Distiller for UTIM HyperCrawler.
+
+Transforms raw HTML documents into dense, structured, noise-free Markdown.
+Preserves:
+- Tables (converted to standard GitHub-Flavored Markdown tables)
+- Code blocks (with syntax language identifiers)
+- Headings (#, ##, ###, etc.)
+- Lists (ordered and unordered)
+- Emphasis (bold, italics, inline code)
+- Main article content (stripping navbars, footers, cookie banners, ads, SVGs)
+"""
+
+from __future__ import annotations
+
+import re
+import html as html_lib
+from typing import Optional, Tuple, List
+from bs4 import BeautifulSoup, Comment, NavigableString, Tag
+
+
+# Tags to remove entirely (including their contents)
+_NOISE_TAGS = {
+    "script", "style", "nav", "footer", "header", "aside", "noscript",
+    "iframe", "svg", "canvas", "form", "button", "dialog", "menu",
+}
+
+# Common noise classes / IDs in modern web design
+_NOISE_CLASS_PATTERNS = re.compile(
+    r"(ad[s\-_]|banner|cookie|consent|popup|modal|sidebar|newsletter|social|share|widget|tracking|promo)",
+    re.IGNORECASE,
+)
+
+
+class SemanticMarkdownDistiller:
+    """Converts HTML into token-efficient, highly-structured Markdown for LLMs."""
+
+    def __init__(self, max_length: int = 40000):
+        self.max_length = max_length
+
+    def distill(self, html_content: str, base_url: str = "") -> Tuple[str, str]:
+        """Distills raw HTML into (clean_markdown, page_title)."""
+        if not html_content or not html_content.strip():
+            return "", ""
+
+        try:
+            soup = BeautifulSoup(html_content, "html.parser")
+        except Exception:
+            # Fallback simple regex extraction if parser fails
+            text = re.sub(r"<[^>]+>", " ", html_content)
+            return html_lib.unescape(text).strip()[:self.max_length], ""
+
+        # 1. Extract Page Title
+        title = ""
+        title_el = soup.find("title") or soup.find("h1")
+        if title_el:
+            title = title_el.get_text(strip=True)
+
+        # 2. Strip comments and unwanted noise elements
+        for comment in soup.find_all(string=lambda s: isinstance(s, Comment)):
+            comment.extract()
+
+        for tag_name in _NOISE_TAGS:
+            for el in soup.find_all(tag_name):
+                el.decompose()
+
+        # 3. Strip obvious ad and cookie banner containers
+        for el in soup.find_all(["div", "section", "aside"]):
+            # Defensive: BeautifulSoup can yield tags with attrs=None for
+            # malformed/void elements. Guard before calling .get() so a single
+            # bad tag (common in GitHub/React-rendered HTML) doesn't kill the
+            # entire distillation pass with AttributeError: 'NoneType' has no
+            # attribute 'get'.
+            if not el.attrs:
+                continue
+            classes = " ".join(el.get("class", [])) if el.get("class") else ""
+            el_id = el.get("id", "")
+            if _NOISE_CLASS_PATTERNS.search(classes) or _NOISE_CLASS_PATTERNS.search(el_id):
+                # Only decompose if it doesn't contain main article/content
+                if not any(k in (classes + el_id).lower() for k in ("article", "content", "main", "post", "entry")):
+                    el.decompose()
+
+        # 4. Target the main content container if present
+        main_content = (
+            soup.find("main")
+            or soup.find("article")
+            or soup.find("div", {"id": re.compile(r"(content|main|article|docs|post)", re.I)})
+            or soup.find("div", {"class": re.compile(r"(content|main|article|docs|post-body)", re.I)})
+            or soup.body
+            or soup
+        )
+
+        # 5. Recursively convert DOM tree to Markdown
+        md_text = self._convert_element(main_content).strip()
+
+        # 6. Normalize whitespace and blank lines
+        md_text = re.sub(r"\n{3,}", "\n\n", md_text)
+
+        if len(md_text) > self.max_length:
+            md_text = md_text[:self.max_length] + "\n\n... [Content truncated for length] ..."
+
+        return md_text, title
+
+    def _convert_element(self, element) -> str:
+        """Recursively converts a BeautifulSoup Tag into Markdown."""
+        if element is None:
+            return ""
+
+        if isinstance(element, NavigableString):
+            text = str(element)
+            # Normalize whitespace within inline text
+            return re.sub(r"[ \t\r\f\v]+", " ", text)
+
+        tag = element.name.lower() if element.name else ""
+
+        # Headings
+        if tag in ("h1", "h2", "h3", "h4", "h5", "h6"):
+            level = int(tag[1])
+            inner = self._get_inner_text(element).strip()
+            if inner:
+                return f"\n\n{'#' * level} {inner}\n\n"
+            return ""
+
+        # Paragraphs & Blocks
+        if tag in ("p", "div", "section", "article"):
+            inner = "".join(self._convert_element(c) for c in element.children).strip()
+            if inner:
+                return f"\n\n{inner}\n\n"
+            return ""
+
+        # Code Blocks (<pre><code> or <pre>)
+        if tag == "pre":
+            code_el = element.find("code")
+            lang = ""
+            if code_el and code_el.get("class"):
+                for c in code_el["class"]:
+                    if c.startswith("language-") or c.startswith("lang-"):
+                        lang = c.split("-", 1)[1]
+                        break
+            code_text = (code_el or element).get_text()
+            return f"\n\n```{lang}\n{code_text.rstrip()}\n```\n\n"
+
+        # Inline Code (<code>)
+        if tag == "code":
+            code_text = element.get_text()
+            if "\n" in code_text:
+                return f"\n\n```\n{code_text.rstrip()}\n```\n\n"
+            return f"`{code_text.strip()}`"
+
+        # Blockquote
+        if tag == "blockquote":
+            inner = "".join(self._convert_element(c) for c in element.children).strip()
+            lines = [f"> {l}" for l in inner.splitlines()]
+            return "\n\n" + "\n".join(lines) + "\n\n"
+
+        # Lists (<ul>, <ol>)
+        if tag in ("ul", "ol"):
+            items = []
+            is_ordered = (tag == "ol")
+            for idx, li in enumerate(element.find_all("li", recursive=False)):
+                prefix = f"{idx + 1}. " if is_ordered else "- "
+                li_text = "".join(self._convert_element(c) for c in li.children).strip()
+                if li_text:
+                    items.append(f"{prefix}{li_text}")
+            if items:
+                return "\n\n" + "\n".join(items) + "\n\n"
+            return ""
+
+        # List item
+        if tag == "li":
+            return "".join(self._convert_element(c) for c in element.children).strip()
+
+        # Tables (<table>) -> Markdown Table
+        if tag == "table":
+            return self._convert_table(element)
+
+        # Emphasis & Formatting
+        if tag in ("strong", "b"):
+            inner = "".join(self._convert_element(c) for c in element.children).strip()
+            return f"**{inner}**" if inner else ""
+
+        if tag in ("em", "i"):
+            inner = "".join(self._convert_element(c) for c in element.children).strip()
+            return f"*{inner}*" if inner else ""
+
+        # Links (<a>)
+        if tag == "a":
+            href = element.get("href", "").strip()
+            inner = "".join(self._convert_element(c) for c in element.children).strip()
+            if href and inner and not href.startswith("javascript:") and not href.startswith("#"):
+                return f"[{inner}]({href})"
+            return inner
+
+        # Images (<img>)
+        if tag == "img":
+            alt = element.get("alt", "").strip()
+            src = element.get("src", "").strip()
+            if src and not src.startswith("data:"):
+                return f"![{alt}]({src})"
+            return f"[{alt}]" if alt else ""
+
+        # Line Break (<br>, <hr>)
+        if tag == "br":
+            return "\n"
+        if tag == "hr":
+            return "\n\n---\n\n"
+
+        # Default: traverse children
+        return "".join(self._convert_element(c) for c in element.children)
+
+    def _get_inner_text(self, tag: Tag) -> str:
+        """Extracts clean text without extra formatting."""
+        return tag.get_text(separator=" ", strip=True)
+
+    def _convert_table(self, table_tag: Tag) -> str:
+        """Converts HTML table into a clean GitHub Flavored Markdown table."""
+        rows = table_tag.find_all("tr")
+        if not rows:
+            return ""
+
+        table_matrix: List[List[str]] = []
+        for r in rows:
+            cols = r.find_all(["th", "td"])
+            col_texts = []
+            for c in cols:
+                # Get text and clean pipe characters to prevent markdown table breakage
+                c_text = "".join(self._convert_element(child) for child in c.children).strip()
+                c_text = c_text.replace("\n", " ").replace("|", "\\|")
+                col_texts.append(c_text)
+            if any(col_texts):
+                table_matrix.append(col_texts)
+
+        if not table_matrix:
+            return ""
+
+        # Normalize column widths
+        max_cols = max(len(r) for r in table_matrix)
+        for r in table_matrix:
+            while len(r) < max_cols:
+                r.append("")
+
+        header_row = table_matrix[0]
+        separator_row = ["---"] * max_cols
+        body_rows = table_matrix[1:] if len(table_matrix) > 1 else []
+
+        lines = [
+            "| " + " | ".join(header_row) + " |",
+            "| " + " | ".join(separator_row) + " |",
+        ]
+        for r in body_rows:
+            lines.append("| " + " | ".join(r) + " |")
+
+        return "\n\n" + "\n".join(lines) + "\n\n"
+
+
+def html_to_markdown(html_content: str, base_url: str = "", max_length: int = 40000) -> Tuple[str, str]:
+    """Convenience function to distill HTML into clean Markdown."""
+    distiller = SemanticMarkdownDistiller(max_length=max_length)
+    return distiller.distill(html_content, base_url=base_url)