utim-cli 2.5.2__tar.gz → 2.5.3__tar.gz

{utim_cli-2.5.2 → utim_cli-2.5.3}/CHANGELOG.md

@@ -1,16 +1,19 @@
 # Changelog
 
+## [2.5.3] - 2026-10-20
+
+### ✨ Improvements & Fixes
+- Stability, streaming, and rate-limit handling improvements.
+
 ## [2.5.2] - 2026-10-18
 
 ### 🐛 Fixes
-- **Paid Plan Model Gating & Aliases**: Fixed preflight model registry check in `completion_routes.py` so paid subscribers (Hobby/Pro/Max/Ultra) are never blocked by free-plan error notices. Added `ag/` prefix stripping, separated model tables lookup, and canonical OpenRouter routing for `ag/gemini-3.8-flash-high`.
+- **Paid Plan Model Gating & Aliases**: Fixed preflight model registry check in `completion_routes.py` so paid subscribers (Hobby/Pro/Max/Ultra) are never blocked by free-plan error notices.
 
 ## [2.5.1] - 2026-10-18
 
 ### 🐛 Fixes
 - **Compression Empty-Response Spam**: `_call_compression_model_with_fallback` now always sets `last_error` on empty/stripped content and logs `model=… routing=… empty_hits=…` diagnostics — eliminates the endless `[COMPRESSION FALLBACK FAILURE] Last error: None` loop and surfaces the real reason (429 / empty content / bad shape).
-- **Admin Portal CORS**: `router.py` now always allows `Origin: null` (downloaded `file://` HTML) and `allow_headers=["*"]` + `max_age=600` so `X-UTIM-Master-Key` / `Authorization` preflights for `/api/admin/*` and `/models` no longer fail with `No 'Access-Control-Allow-Origin'`.
-- **Admin Firewall Bypass**: `firewall.py: _FIREWALL_SKIP_PREFIXES` and `cli_auth.py: PUBLIC_PREFIXES` now include `/admin`, `/admin.html`, `/admin_models.html`, `/static` so the browser-served admin panel bypasses proxy-abuse / burst throttling and CLI HMAC `401` (API auth via master-key session is still enforced).
 
 ## [2.5.0] - 2026-10-18
 

{utim_cli-2.5.2/utim_cli.egg-info → utim_cli-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.5.2
+Version: 2.5.3
 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.5.2 → utim_cli-2.5.3}/pyproject.toml

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

{utim_cli-2.5.2 → utim_cli-2.5.3}/utim/__init__.py

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

{utim_cli-2.5.2 → utim_cli-2.5.3}/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.5.2"
+    __version__ = "2.5.3"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.5.2 → utim_cli-2.5.3}/utim_cli/_version.py

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

{utim_cli-2.5.2 → utim_cli-2.5.3}/utim_cli/architecture_indexer.py

@@ -140,66 +140,53 @@ def architecture_lock(project_path: str = ".") -> str:
     _now = _time.time()
     _mem = _ARCH_LOCK_MEM_CACHE.get(proj_id)
     if _mem and (_now - _mem.get("ts", 0) < _ARCH_LOCK_COOLDOWN_S):
-        _cached_dir = _mem.get("arch_dir")
+        _cached_file = _mem.get("arch_file")
         _cached_result = _mem.get("result")
-        if _cached_dir and Path(_cached_dir).exists() and _cached_result:
+        if _cached_file and Path(_cached_file).is_file() and _cached_result:
             # Fresh within the session — return cached output instantly.
             return (
                 "[CACHED — architecture lock already generated this session; NOT re-indexed]\n"
                 + _cached_result
-                + "\n\n⚠️ Do NOT call architecture_lock again this session. "
-                  "Use `read_file` on the component_<domain>.md blueprints listed above."
+                + f"\n\n⚠️ Do NOT call architecture_lock again this session. Read the file at: `{_cached_file}`"
             )
 
     # ── 2. Stable single directory (replaces per-call arch_{uuid} spam) ───────
     arch_dir = proj_dir / "arch_lock"
     arch_dir.mkdir(parents=True, exist_ok=True)
     brain_file = arch_dir / "00_architecture_map.json"
+    arch_file = arch_dir / "architecture.md"
     meta_file = arch_dir / ".arch_lock_meta.json"
 
-    # ── 3. Disk cache: reuse if the graph is fresh AND file tree unchanged ───
+    # ── 3. Disk cache: reuse if the single-file index is fresh AND file tree unchanged
     _tree_hash = _quick_file_tree_hash(abs_path)
     try:
-        if brain_file.exists() and meta_file.exists():
+        if arch_file.is_file() and brain_file.is_file() and meta_file.is_file():
             _meta = json.loads(meta_file.read_text(encoding="utf-8"))
             _age = _now - float(_meta.get("ts", 0))
             _same_tree = _meta.get("tree_hash") == _tree_hash
             if _same_tree and _age < _ARCH_LOCK_DISK_TTL_S:
-                # Rebuild the lightweight return string from the cached dir
-                # without re-walking / re-parsing the entire codebase.
-                _cached_mds = sorted([p.name for p in arch_dir.glob("component_*.md")])
-                if _cached_mds:
-                    # Count files from cached graph
-                    try:
-                        _g = json.loads(brain_file.read_text(encoding="utf-8"))
-                        _n_files = _g.get("total_files", "?")
-                        _ptype = ", ".join(_g.get("project_type", [])) or "Unknown"
-                    except Exception:
-                        _n_files, _ptype = "?", "Unknown"
-                    _bullets = "\n".join(
-                        f"- {m}: [file:///{str((arch_dir / m).absolute()).replace(chr(92), '/')}]"
-                        for m in _cached_mds
-                    )
-                    _result = (
-                        f"✓ Architecture lock (CACHED — reused, not re-indexed) at: {arch_dir}\n"
-                        f"Identified stack: {_ptype} | Indexed files: {_n_files} | Age: {int(_age)}s\n\n"
-                        f"WHAT WAS PROVIDED:\n"
-                        f"1. Structural Dependency Graph: `00_architecture_map.json`\n"
-                        f"2. Architecture Conventions: `conventions_summary.txt`\n"
-                        f"3. Modular Component Blueprints ({len(_cached_mds)} domain modules):\n{_bullets}\n\n"
-                        f"WHY THIS IS NEEDED & NEXT ACTION:\n"
-                        f"- Zero-token structural grounding eliminates hallucinations and token-wasting blind exploration.\n"
-                        f"- NEXT STEP: Use `read_file` on the relevant `component_<domain>.md` blueprint above "
-                        f"matching your task to inspect exact function/class signatures BEFORE editing.\n"
-                        f"- Do NOT call architecture_lock again unless the project file tree has changed."
-                    )
-                    _ARCH_LOCK_MEM_CACHE[proj_id] = {"ts": _now, "arch_dir": str(arch_dir), "result": _result}
-                    return (
-                        "[CACHED — architecture lock reused from disk; NOT re-indexed]\n"
-                        + _result
-                        + "\n\n⚠️ Do NOT call architecture_lock again. "
-                          "Use `read_file` on the component blueprints listed above."
-                    )
+                try:
+                    _g = json.loads(brain_file.read_text(encoding="utf-8"))
+                    _n_files = _g.get("total_files", "?")
+                    _ptype = ", ".join(_g.get("project_type", [])) or "Unknown"
+                except Exception:
+                    _n_files, _ptype = "?", "Unknown"
+                _arch_uri = f"file:///{str(arch_file.absolute()).replace(chr(92), '/')}"
+                _result = (
+                    f"✓ Architecture lock (CACHED — reused, not re-indexed)\n"
+                    f"Identified stack: {_ptype} | Indexed files: {_n_files} | Age: {int(_age)}s\n"
+                    f"Architecture file: `{arch_file}`\n"
+                    f"URI: {_arch_uri}\n\n"
+                    f"NEXT STEP: Read the architecture with `read_file(\"{arch_file}\")` "
+                    f"to inspect exact function/class signatures BEFORE editing.\n"
+                    f"Do NOT call architecture_lock again unless the project file tree has changed."
+                )
+                _ARCH_LOCK_MEM_CACHE[proj_id] = {"ts": _now, "arch_file": str(arch_file), "result": _result}
+                return (
+                    "[CACHED — architecture lock reused from disk; NOT re-indexed]\n"
+                    + _result
+                    + f"\n\n⚠️ Do NOT call architecture_lock again. Read the file at: `{arch_file}`"
+                )
     except Exception:
         pass  # any cache failure → fall through to full index
 
@@ -310,41 +297,84 @@ def architecture_lock(project_path: str = ".") -> str:
             md_block += f"```text\n{snippet}\n```\n"
             clusters[cluster_name].append(md_block)
 
-    # Dynamically generate markdown files based on organic clusters
-    generated_mds = []
-    for cname, blocks in clusters.items():
-        if not blocks: continue
-        safe_cname = re.sub(r'[^a-z0-9_]', '_', cname)
-        md_content = f"# 🧩 Architecture Component: {cname.title()}\n\n" + "\n".join(blocks)
-        md_filename = f"component_{safe_cname}.md"
-        (arch_dir / md_filename).write_text(md_content, encoding="utf-8")
-        generated_mds.append(md_filename)
-
-    domain_links = ", ".join([
-        "[file:///{}]".format(str(arch_dir.absolute() / m).replace(chr(92), "/"))
-        for m in generated_mds
-    ])
-    conventions = [
-        "## Innate Project Architecture Rules",
-        "- **Organic Component Isolation**: The project is structured organically. Do not bloat central routers or core files.",
-        "- **Multifile Designs**: When adding large new features, ALWAYS create new standalone component files based on the existing directory structure.",
-        "- **MANDATORY ARCHITECTURE REVIEW**: You MUST use `read_file` on the relevant domain files below BEFORE exploring the source code manually. They contain the exact structural blueprints you need.",
-        "- **Available Domain Files**: " + domain_links
+    # ── Build single consolidated architecture.md (TOC + all clusters) ──────
+    # Remove stale split files from previous multi-file runs
+    for _stale in arch_dir.glob("component_*.md"):
+        try:
+            _stale.unlink()
+        except Exception:
+            pass
+    for _stale in (arch_dir / "conventions_summary.txt",):
+        try:
+            if _stale.is_file():
+                _stale.unlink()
+        except Exception:
+            pass
+
+    # Stable ordering for reproducible output
+    _ordered_clusters = sorted(clusters.items(), key=lambda kv: kv[0].lower())
+    # TOC entries — link to per-cluster anchors inside the single file
+    _toc_lines: List[str] = []
+    for cname, blocks in _ordered_clusters:
+        if not blocks:
+            continue
+        safe_cname = re.sub(r'[^a-z0-9_]', '_', cname.lower())
+        anchor = f"component-{safe_cname}"
+        _toc_lines.append(f"- [{cname.title()}](#{anchor}) — {len(blocks)} symbol(s)/note(s)")
+
+    _header = [
+        f"# Project Architecture — `{Path(abs_path).name}`",
+        "",
+        f"- **Stack:** {', '.join(project_type) or 'Unknown'}",
+        f"- **Root:** `{abs_path}`",
+        f"- **Indexed files:** {len(inventory)}",
+        f"- **Generated:** {arch_file.name} (single consolidated file — all domains inline)",
+        "",
+        "## Table of Contents",
+        "- [Conventions](#conventions)",
+    ]
+    if _toc_lines:
+        _header.extend(_toc_lines)
+    _header.extend(["", "---", ""])
+
+    _conventions = [
+        "## Conventions",
+        "- **Component isolation**: Keep domains isolated. Do not bloat central routers.",
+        "- **Multifile expansion**: For large features, create new standalone files following existing directory structure.",
+        "- **Grounding**: This document is the zero-token structural ground truth. Prefer it over blind directory walks.",
+        "",
+        "---",
+        "",
     ]
-    (arch_dir / "conventions_summary.txt").write_text("\n".join(conventions), encoding="utf-8")
 
+    _body_parts: List[str] = _header + _conventions
+    for cname, blocks in _ordered_clusters:
+        if not blocks:
+            continue
+        safe_cname = re.sub(r'[^a-z0-9_]', '_', cname.lower())
+        anchor = f"component-{safe_cname}"
+        _body_parts.append(f'<a id="{anchor}"></a>')
+        _body_parts.append(f"## 🧩 {cname.title()}")
+        _body_parts.append("")
+        _body_parts.extend(blocks)
+        _body_parts.append("")
+        _body_parts.append("---")
+        _body_parts.append("")
+
+    _arch_content = "\n".join(_body_parts).rstrip() + "\n"
+    arch_file.write_text(_arch_content, encoding="utf-8")
+
+    # ── Structural dependency graph (kept for tooling; not the LLM-facing artifact)
     unique_nodes = {n["id"]: n for n in nodes}.values()
-
     graph_data = {
         "project_path": abs_path,
         "project_type": project_type,
         "total_files": len(inventory),
         "nodes": list(unique_nodes),
         "edges": edges,
-        "capabilities": ["Project orientation", "Graph traversal", "Symbol resolution"]
+        "capabilities": ["Project orientation", "Graph traversal", "Symbol resolution"],
     }
-    
-    with open(brain_file, 'w', encoding='utf-8') as bf:
+    with open(brain_file, "w", encoding="utf-8") as bf:
         json.dump(graph_data, bf, indent=2)
 
     # Write meta sidecar for disk-cache invalidation (tree hash + timestamp)
@@ -353,24 +383,17 @@ def architecture_lock(project_path: str = ".") -> str:
     except Exception:
         pass
 
-    component_bullets = "\n".join([
-        f"- {m}: [file:///{str(arch_dir.absolute() / m).replace(chr(92), '/')}]"
-        for m in generated_mds
-    ]) if generated_mds else "- None"
-
+    _arch_uri = f"file:///{str(arch_file.absolute()).replace(chr(92), '/')}"
     _result_str = (
-        f"✓ Architecture lock successfully generated at: {arch_dir}\n"
-        f"Identified stack: {', '.join(project_type) or 'Unknown'} | Indexed files: {len(inventory)}\n\n"
-        f"WHAT WAS PROVIDED:\n"
-        f"1. Structural Dependency Graph: `00_architecture_map.json` (all file nodes, module imports, and symbol definitions)\n"
-        f"2. Architecture Conventions: `conventions_summary.txt`\n"
-        f"3. Modular Component Blueprints ({len(generated_mds)} domain modules):\n{component_bullets}\n\n"
-        f"WHY THIS IS NEEDED & NEXT ACTION:\n"
-        f"- Zero-token structural grounding eliminates hallucinations and token-wasting blind repo exploration.\n"
-        f"- NEXT STEP: Use `read_file` on the relevant `component_<domain>.md` blueprint above matching your task to inspect exact function/class signatures and dependencies before reading or editing source code.\n"
-        f"- Do NOT call architecture_lock again this session — reuse the blueprints above."
+        f"✓ Architecture lock successfully generated\n"
+        f"Identified stack: {', '.join(project_type) or 'Unknown'} | Indexed files: {len(inventory)}\n"
+        f"Architecture file: `{arch_file}`\n"
+        f"URI: {_arch_uri}\n\n"
+        f"This single file contains ALL domain sections inline (TOC + conventions + {len([b for _, b in _ordered_clusters if b])} component groups).\n"
+        f"NEXT STEP: Read it with `read_file(\"{arch_file}\")` to inspect exact function/class signatures and dependencies before editing source code.\n"
+        f"Do NOT call architecture_lock again this session — re-use this file."
     )
     # Populate in-memory cache so a second call this session is instant
-    _ARCH_LOCK_MEM_CACHE[proj_id] = {"ts": _now, "arch_dir": str(arch_dir), "result": _result_str}
+    _ARCH_LOCK_MEM_CACHE[proj_id] = {"ts": _now, "arch_file": str(arch_file), "result": _result_str}
     return _result_str