utim-cli 1.0.0__py3-none-any.whl

utim_cli/bootstrap.py

@@ -0,0 +1,324 @@
+"""
+UTIM Bootstrap Module
+Auto-creates the .utim folder structure, custom skills, and local database on first run.
+"""
+
+import os
+from pathlib import Path
+
+UTIM_DIR = Path('.utim')
+
+DEFAULT_AGENTS_MD = """# Project-Scoped Rules and Guidelines for UTIM CLI
+
+Welcome to the UTIM CLI development workspace. Follow these rules and activate the corresponding workspace-scoped skills based on your current task.
+
+## Available Workspace Skills
+
+You MUST read the corresponding `SKILL.md` file using the file viewer tool before implementing features in these domains:
+
+1. **Terminal UI (TUI) Design**: [.utim/skills/terminal-ui-design/SKILL.md](file:///C:/Users/user/Desktop/New%20folder/New%20folder/.utim/skills/terminal-ui-design/SKILL.md)
+   - *Use when*: Modifying interactive menus, Rich console logs, layouts, and `prompt_toolkit` inputs.
+2. **Software Architecture**: [.utim/skills/software-architecture/SKILL.md](file:///C:/Users/user/Desktop/New%20folder/New%20folder/.utim/skills/software-architecture/SKILL.md)
+   - *Use when*: Designing new Python modules, modifying state/orchestrator files, or refactoring codebase structures.
+3. **MCP Server Development**: [.utim/skills/mcp-server-development/SKILL.md](file:///C:/Users/user/Desktop/New%20folder/New%20folder/.utim/skills/mcp-server-development/SKILL.md)
+   - *Use when*: Writing new MCP servers, modifying connection pools, or handling stdio protocol wrappers.
+4. **CLI UX Patterns**: [.utim/skills/cli-ux-patterns/SKILL.md](file:///C:/Users/user/Desktop/New%20folder/New%20folder/.utim/skills/cli-ux-patterns/SKILL.md)
+   - *Use when*: Refining CLI prompts, progress indicators, non-interactive (TTY) handling, and user confirmations.
+5. **Premium Web Design**: [.utim/skills/web-design-premium/SKILL.md](file:///C:/Users/user/Desktop/New%20folder/New%20folder/.utim/skills/web-design-premium/SKILL.md)
+   - *Use when*: Coding web interfaces, using HSL colors, glassmorphism UI, transitions, or applying SEO tags.
+6. **LLM Orchestration**: [.utim/skills/llm-orchestration/SKILL.md](file:///C:/Users/user/Desktop/New%20folder/New%20folder/.utim/skills/llm-orchestration/SKILL.md)
+   - *Use when*: Editing LLM prompting context, parser loops, tools injection, token pruner, or semantic vector DB memory retrieval.
+7. **Asynchronous Python (asyncio)**: [.utim/skills/async-python/SKILL.md](file:///C:/Users/user/Desktop/New%20folder/New%20folder/.utim/skills/async-python/SKILL.md)
+   - *Use when*: Implementing asynchronous background tasks, reading subprocess streams, or thread safety locks.
+"""
+
+DEFAULT_SKILLS = {
+    "terminal-ui-design": """---
+name: terminal-ui-design
+description: Guidelines and best practices for creating beautiful, responsive terminal UIs (TUIs) in Python using Rich and prompt_toolkit.
+---
+
+# Terminal UI (TUI) Design Guide
+
+Terminal UIs must combine aesthetic appeal with technical reliability. Use Rich for output panels/tables and prompt_toolkit for interactive prompts, validations, and completion suggestions.
+
+---
+
+## 1. Color Palette & Theming
+- Primary/Accent: Cyan or magenta.
+- Success: Green.
+- Warning: Yellow.
+- Error: Red.
+- Dim/Muted: Gray.
+
+Always use a centralized theme rather than hardcoding colors.
+""",
+    "software-architecture": """---
+name: software-architecture
+description: Guidelines and design patterns for Python application architecture, focus on modularity, decoupling, state management, and reliable abstractions.
+---
+
+# Software Architecture Guidelines
+
+Adhere to modular separation of concerns. Keep UI scripts, business logic, state models, and tool execution independent to prevent tight coupling.
+""",
+    "mcp-server-development": """---
+name: mcp-server-development
+description: Guidelines for developing and integrating Model Context Protocol (MCP) servers, troubleshooting stdio stream corruption, and implementing robust tool/resource handlers.
+---
+
+# MCP Server Development Guide
+
+- Redirect all logs and debug printing to stderr, never stdout, to prevent stdio transport corruption.
+- Process stdin EOF gracefully to prevent hanging subprocesses.
+""",
+    "cli-ux-patterns": """---
+name: cli-ux-patterns
+description: Core guidelines for designing highly polished Command Line Interface (CLI) user experiences.
+---
+
+# CLI UX Patterns
+
+- Always clean up temporary or interactive question prompts using screen clearing codes.
+- Ensure all mutating commands support non-destructive dry-run modes.
+""",
+    "web-design-premium": """---
+name: web-design-premium
+description: Design principles and code implementation guidelines for premium, modern, and visually striking web interfaces.
+---
+
+# Premium Web Design Guide
+
+Apply glassmorphism (backdrop-filter blur), modern sans-serif fonts (e.g. Outfit, Inter), clean HSL-tailored colors, smooth transitions, and standard SEO best practices.
+""",
+    "llm-orchestration": """---
+name: llm-orchestration
+description: Guidelines and patterns for LLM agent loops, tool-calling, context management, semantic token pruning, and reflection strategies.
+---
+
+# LLM Orchestration & Agent Loops
+
+- Ensure iteration limits are set to prevent infinite LLM reasoning loops.
+- Perform pre-commit validation checks before executing tool code modifications.
+""",
+    "async-python": """---
+name: async-python
+description: Guidelines and patterns for asynchronous Python programming using asyncio.
+---
+
+# Asynchronous Python (asyncio)
+
+- Use asyncio.create_subprocess_exec to execute subprocesses concurrently.
+- Protect asynchronous actions with timeouts using asyncio.timeout.
+"""
+}
+
+def initialize_utim() -> str:
+    """Initialize .utim directory, local SQLite database, and auto-create custom skills/rules if they don't exist."""
+    try:
+        from utim_cli.backup import restore_state
+        restore_state()
+    except Exception as e:
+        from utim_cli.logger import log_error
+        log_error("bootstrap", "Failed to restore state during initialization", e)
+        
+    UTIM_DIR.mkdir(exist_ok=True)
+    
+    # 1. Initialize local_utim database using SQLAlchemy init_db
+    try:
+        from utim_cli.server.db import init_db
+        init_db()
+    except Exception as e:
+        from utim_cli.logger import log_error
+        log_error("bootstrap", "Failed to initialize SQLite local database", e)
+        
+    # 2. Write analytical_rules.md if not exists
+    _write_analytical_rules_md()
+    
+    # 3. Write UTIM.md if not exists
+    _write_utim_md()
+    
+    # 4. Auto-create skills directory and default skills/rules
+    _write_skills_and_agents()
+    
+    db_path = UTIM_DIR / 'utim_local.db'
+    return str(db_path)
+
+def _write_skills_and_agents():
+    """Auto-create skills/ directory, AGENTS.md, and all default SKILL.md files inside .utim/."""
+    try:
+        # Write AGENTS.md
+        agents_path = UTIM_DIR / 'AGENTS.md'
+        if not agents_path.exists():
+            with open(agents_path, 'w', encoding='utf-8') as f:
+                f.write(DEFAULT_AGENTS_MD)
+                
+        # Write skills
+        skills_dir = UTIM_DIR / 'skills'
+        for skill_name, content in DEFAULT_SKILLS.items():
+            skill_dir = skills_dir / skill_name
+            skill_dir.mkdir(parents=True, exist_ok=True)
+            skill_file = skill_dir / 'SKILL.md'
+            if not skill_file.exists():
+                with open(skill_file, 'w', encoding='utf-8') as f:
+                    f.write(content)
+                    
+        # Write DESIGN.md
+        design_path = UTIM_DIR / 'DESIGN.md'
+        if not design_path.exists():
+            _write_default_design_md(design_path)
+    except Exception as e:
+        from utim_cli.logger import log_error
+        log_error("bootstrap", "Failed to write skills and agents configuration to .utim/", e)
+
+def _write_default_design_md(md_path: Path):
+    content = """# Premium Web Design System (Aesthetics Cheat-Sheet)
+Use this guide to build modern, beautiful, and "award-winning" web interfaces. Apply these principles, variables, and recipes to wow the user.
+
+---
+
+## 1. Typography
+*   **Body & UI**: 'Outfit', sans-serif (clean, rounded, premium feel).
+*   **Headings**: 'Bricolage Grotesque', sans-serif (vibrant, high-agency design).
+
+## 2. Color Palette (Clean Dark/Light HSL)
+- Primary HSL colors, gradients, and custom themes to prevent generic looks.
+"""
+    try:
+        with open(md_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+    except Exception:
+        pass
+
+def _write_analytical_rules_md():
+    """Write the analytical_rules.md file to .utim folder if not exists."""
+    md_path = UTIM_DIR / 'analytical_rules.md'
+    if md_path.exists():
+        return
+        
+    content = """# Enhanced Analytical Framework for UTIM AI
+
+## Core Principle: GOAL-FIRST ANALYSIS
+Always start by identifying the TRUE objective, then work backwards to feasible actions.
+"""
+    try:
+        with open(md_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+    except Exception as e:
+        from utim_cli.logger import log_error
+        log_error("bootstrap", f"Failed to write analytical rules markdown to {md_path}", e)
+
+def _write_utim_md():
+    """Write the UTIM.md file to .utim folder if not exists."""
+    md_path = UTIM_DIR / 'UTIM.md'
+    if md_path.exists():
+        return
+        
+    content = """## 1. Identity & Operating Mindset
+* **Role**: You are UTIM AI, a high-agency senior software engineering intelligence operating inside a developer CLI.
+"""
+    try:
+        with open(md_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+    except Exception as e:
+        from utim_cli.logger import log_error
+        log_error("bootstrap", f"Failed to write UTIM.md markdown to {md_path}", e)
+
+def get_rag_context(user_prompt: str = "") -> str:
+    """Get RAG context string for system prompt injection by matching user_prompt keywords to skills."""
+    try:
+        from utim_cli.state import STATE
+        STATE["injected_contexts"] = []
+        
+        # Simple keyword matching to select relevant skills
+        matched_skills = []
+        user_prompt_lower = user_prompt.lower()
+        
+        keywords = {
+            "terminal-ui-design": ["ui", "tui", "console", "rich", "prompt", "menu", "prompt_toolkit", "layout"],
+            "software-architecture": ["architecture", "design", "module", "structure", "refactor", "coupling"],
+            "mcp-server-development": ["mcp", "server", "figma", "github", "stdio", "json-rpc"],
+            "cli-ux-patterns": ["cli", "ux", "undo", "redo", "prompt", "interactive", "confirm"],
+            "web-design-premium": ["web", "css", "html", "react", "premium", "glassmorphism", "style"],
+            "llm-orchestration": ["llm", "agent", "orchestration", "token", "prune", "prompt", "thinking"],
+            "async-python": ["async", "sync", "await", "loop", "concurrency", "thread", "process"]
+        }
+        
+        for skill_name, keys in keywords.items():
+            if any(k in user_prompt_lower for k in keys):
+                matched_skills.append(skill_name)
+                
+        # If no keywords matched, default to AGENTS.md
+        if not matched_skills:
+            agents_path = UTIM_DIR / 'AGENTS.md'
+            if agents_path.exists():
+                with open(agents_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                STATE["injected_contexts"].append(content)
+                return f"\n### PROJECT RULES & GUIDELINES ###\n{content}\n"
+            return ""
+            
+        context = ""
+        for skill_name in matched_skills[:2]: # Load top 2 matched skills
+            skill_path = UTIM_DIR / 'skills' / skill_name / 'SKILL.md'
+            if skill_path.exists():
+                with open(skill_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                if content.startswith('---'):
+                    parts = content.split('---', 2)
+                    if len(parts) >= 3:
+                        content = parts[2].strip()
+                STATE["injected_contexts"].append(content)
+                context += f"\n### RELEVANT CORE SKILL: {skill_name.upper()} ###\n{content[:1500]}\n"
+                
+        return context
+    except Exception as e:
+        from utim_cli.logger import log_error
+        log_error("bootstrap", "Failed to get RAG context from skills", e)
+        return ""
+
+def get_subagent_rag_context(subagent_name: str, query: str = "") -> str:
+    """Get RAG context string for the specified sub-agent prompt injection by reading from markdown skill files directly."""
+    try:
+        # Map subagent name to the most relevant skill file
+        mapping = {
+            "project_res": "software-architecture",
+            "plan_project": "llm-orchestration",
+            "web_search": "cli-ux-patterns",
+            "generate_image": "web-design-premium"
+        }
+        skill_name = mapping.get(subagent_name)
+        if not skill_name:
+            return ""
+        
+        skill_path = UTIM_DIR / 'skills' / skill_name / 'SKILL.md'
+        if not skill_path.exists():
+            return ""
+            
+        with open(skill_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+        # Strip YAML frontmatter if present
+        if content.startswith('---'):
+            parts = content.split('---', 2)
+            if len(parts) >= 3:
+                content = parts[2].strip()
+                
+        # Return a formatted summary context
+        context = f"\n\n### SUB-AGENT {subagent_name.upper()} SKILLS & FRAMEWORK (from {skill_name}) ###\n"
+        if len(content) > 1500:
+            context += content[:1500] + "\n... [Truncated for Context Limit]"
+        else:
+            context += content
+        return context
+    except Exception as e:
+        from utim_cli.logger import log_error
+        log_error("bootstrap", f"Failed to load subagent markdown context for {subagent_name}", e)
+        return ""
+
+def get_time_rag_context(user_prompt: str) -> str:
+    """Gets relevant past task execution time experiences (mock/empty as databases are simplified)."""
+    return ""
+
+if __name__ == '__main__':
+    print(f"Initializing UTIM... Database: {initialize_utim()}")

utim_cli/client_utils.py

@@ -0,0 +1,135 @@
+import os
+import json
+import requests
+from utim_cli.config import config
+
+class WrappedResponse:
+    """A compatibility wrapper that mimics requests.Response for client callers."""
+    def __init__(self, content_str=None, generator=None, status_code=200):
+        self.content_str = content_str
+        self.generator = generator
+        self.status_code = status_code
+        self.encoding = "utf-8"
+
+    def raise_for_status(self):
+        if self.status_code != 200:
+            raise requests.HTTPError(f"HTTP {self.status_code}")
+
+    def json(self):
+        if self.content_str:
+            return json.loads(self.content_str)
+        raise ValueError("No JSON content available")
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def iter_lines(self, decode_unicode=False):
+        if self.generator:
+            return self.generator
+        if self.content_str:
+            return [self.content_str]
+        return []
+
+def get_server_url() -> str:
+    return "https://utim-cli-production.up.railway.app"
+
+def proxy_openrouter_request(json_data: dict, stream: bool = False, timeout=None) -> WrappedResponse:
+    """Routes LLM request to UTIM server /completions, or falls back to direct OpenRouter."""
+    # Ensure environment variables are loaded (orchestrator handles this, but tools.py is independent)
+    _cwd_env = os.path.join(os.getcwd(), ".env")
+    if os.path.isfile(_cwd_env):
+        try:
+            from dotenv import load_dotenv
+            load_dotenv(_cwd_env, override=True)
+        except Exception:
+            pass
+
+    api_key = config.get("api_key")
+    server_url = get_server_url()
+
+    if api_key:
+        headers = {
+            "X-API-Key": api_key,
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "messages": json_data.get("messages"),
+            "model_id": json_data.get("model"),
+            "tools": json_data.get("tools"),
+        }
+        
+        # UTIM server completions is a streaming endpoint
+        resp = requests.post(f"{server_url}/completions", json=payload, headers=headers, stream=True, timeout=timeout)
+        resp.raise_for_status()
+
+        if stream or json_data.get("stream"):
+            def line_generator():
+                for line in resp.iter_lines(decode_unicode=True):
+                    if line:
+                        try:
+                            data = json.loads(line)
+                            if data.get("type") == "content_delta" and data.get("text"):
+                                chunk = {
+                                    "choices": [{
+                                        "delta": {"content": data["text"]}
+                                    }]
+                                }
+                                yield "data: " + json.dumps(chunk)
+                            elif data.get("type") == "done":
+                                if data.get("error"):
+                                    yield "data: " + json.dumps({"error": {"message": data["error"]}})
+                                    break
+                                tcs = data.get("tool_calls")
+                                if tcs:
+                                    chunk = {
+                                        "choices": [{
+                                            "delta": {"tool_calls": tcs}
+                                        }]
+                                    }
+                                    yield "data: " + json.dumps(chunk)
+                                break
+                        except Exception:
+                            pass
+                yield "data: [DONE]"
+            return WrappedResponse(generator=line_generator())
+        else:
+            # Consume stream to construct final non-streaming response dict
+            content = ""
+            tool_calls = None
+            for line in resp.iter_lines(decode_unicode=True):
+                if line:
+                    try:
+                        data = json.loads(line)
+                        if data.get("type") == "content_delta" and data.get("text"):
+                            content += data["text"]
+                        elif data.get("type") == "done":
+                            if data.get("error"):
+                                raise RuntimeError(data["error"])
+                            content = data.get("content") or content
+                            tool_calls = data.get("tool_calls")
+                    except Exception:
+                        pass
+            res_dict = {
+                "choices": [{
+                    "message": {
+                        "role": "assistant",
+                        "content": content,
+                        "tool_calls": tool_calls
+                    }
+                }]
+            }
+            return WrappedResponse(content_str=json.dumps(res_dict))
+    else:
+        llm_key = os.getenv("OPENROUTER_API_KEY")
+        if not llm_key:
+            raise RuntimeError("Neither UTIM API key nor local OPENROUTER_API_KEY is configured.")
+        
+        headers = {
+            "Authorization": f"Bearer {llm_key}",
+            "Content-Type": "application/json"
+        }
+        # Direct forwarding to OpenRouter
+        return requests.post("https://openrouter.ai/api/v1/chat/completions", json=json_data, headers=headers, stream=stream or json_data.get("stream"), timeout=timeout)

utim_cli/config.py

@@ -0,0 +1,194 @@
+import json
+import shutil
+import os
+import pathlib
+from typing import Any, Dict, Optional
+
+class Config:
+    def __init__(self):
+        self.global_dir = pathlib.Path.home() / ".utim"
+        self.local_dir = pathlib.Path(".utim").resolve()
+        self._data: Dict[str, Any] = self._load()
+
+    def _load(self) -> Dict[str, Any]:
+        data = {}
+        # Load global config
+        global_config = self.global_dir / "config.json"
+        if global_config.exists():
+            try:
+                with open(global_config, "r", encoding="utf-8") as f:
+                    data.update(json.load(f))
+            except Exception:
+                pass
+        
+        # Load local config if exists
+        local_config = self.local_dir / "config.json"
+        if local_config.exists():
+            try:
+                with open(local_config, "r", encoding="utf-8") as f:
+                    data.update(json.load(f))
+            except Exception:
+                pass
+        return data
+
+    def save(self):
+        # Save to global config directory
+        self.global_dir.mkdir(parents=True, exist_ok=True)
+        global_config = self.global_dir / "config.json"
+        try:
+            with open(global_config, "w", encoding="utf-8") as f:
+                json.dump(self._data, f, indent=4)
+        except Exception:
+            pass
+
+        # Save to local config directory if it exists
+        if self.local_dir.exists():
+            local_config = self.local_dir / "config.json"
+            try:
+                with open(local_config, "w", encoding="utf-8") as f:
+                    json.dump(self._data, f, indent=4)
+            except Exception:
+                pass
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def set(self, key: str, value: Any):
+        self._data[key] = value
+        self.save()
+
+    @property
+    def token(self) -> Optional[str]:
+        return self.get("token")
+
+    @property
+    def email(self) -> str:
+        return self.get("email", os.getenv("UTIM_EMAIL", "local@utim.dev"))
+
+    @property
+    def name(self) -> Optional[str]:
+        return self.get("name")
+
+    def clear(self):
+        self._data = {}
+        self.save()
+
+    # ── Custom / Bring-Your-Own-Model support ─────────────────────────────────
+
+    @property
+    def custom_models(self) -> list:
+        """Return the list of user-defined models.
+
+        Each entry is a dict with the following keys:
+          model_id      – unique identifier shown in the picker (e.g. "gpt-4o")
+          provider_name – human-readable label (e.g. "OpenAI")
+          base_url      – OpenAI-compatible chat completions base URL
+                         (e.g. "https://api.openai.com/v1")
+          api_key       – API key for that provider (stored in plain text
+                          in .utim/config.json; the user is warned)
+          context_window – integer token budget (default 128 000)
+        """
+        return self._data.get("custom_models", [])
+
+    @custom_models.setter
+    def custom_models(self, value: list):
+        self._data["custom_models"] = value
+        self.save()
+
+    def add_custom_model(self, entry: dict) -> None:
+        """Append or replace a custom model entry keyed on model_id."""
+        models = self.custom_models
+        models = [m for m in models if m.get("model_id") != entry["model_id"]]
+        models.append(entry)
+        self.custom_models = models
+
+    def remove_custom_model(self, model_id: str) -> bool:
+        """Remove a custom model by model_id. Returns True if it existed."""
+        models = self.custom_models
+        new = [m for m in models if m.get("model_id") != model_id]
+        if len(new) == len(models):
+            return False
+        self.custom_models = new
+        return True
+
+    def get_custom_model(self, model_id: str) -> Optional[dict]:
+        """Return the custom model entry for *model_id*, or None."""
+        for m in self.custom_models:
+            if m.get("model_id") == model_id:
+                return m
+        return None
+
+    @property
+    def debug_mode(self) -> bool:
+        return os.environ.get("UTIM_DEBUG", "0").lower() in ("1", "true", "yes")
+
+    @property
+    def dry_run(self) -> bool:
+        return os.environ.get("UTIM_DRY_RUN", "0").lower() in ("1", "true", "yes") or self.get("dry_run", False)
+
+
+    @property
+    def fallback_models(self) -> list:
+        """Return fallback LLM models list."""
+        models = os.environ.get("UTIM_FALLBACK_MODELS")
+        if models:
+            return [m.strip() for m in models.split(",")]
+        return [
+            "poolside/laguna-m.1:free",
+            "qwen/qwen3-coder:free",
+            "nvidia/nemotron-3-ultra-550b-a55b:free",
+            "openrouter/free"
+        ]
+
+    @property
+    def keep_full_turns(self) -> int:
+        # Number of recent turns to retain in memory
+
+        try:
+            return int(os.environ.get("UTIM_KEEP_TURNS", "10"))
+        except ValueError:
+            return 10
+
+    @property
+    def compression_enabled(self) -> bool:
+        # Enable adaptive context compression
+        return os.environ.get("UTIM_COMPRESSION", "true").lower() in ("1", "true", "yes")
+
+    @property
+    def blender_path(self) -> str:
+        """Return the absolute path to the Blender executable.
+
+        Detection order:
+        1. Environment variable ``UTIM_BLENDER_PATH``
+        2. Stored user config key ``blender_path``
+        3. Common Windows install locations
+        4. ``shutil.which('blender')`` fallback
+        """
+        # 1. explicit env var
+        env_path = os.getenv("UTIM_BLENDER_PATH")
+        if env_path and os.path.isfile(env_path):
+            return env_path
+        # 2. stored in config file
+        stored = self.get("blender_path")
+        if stored and os.path.isfile(stored):
+            return stored
+        # 3. common install locations (Windows default)
+        common_paths = [
+            r"C:\\Program Files\\Blender Foundation\\Blender\\blender.exe",
+            r"C:\\Program Files (x86)\\Blender Foundation\\Blender\\blender.exe",
+            r"E:\\Blender\\blender.exe",
+        ]
+        for p in common_paths:
+            if os.path.isfile(p):
+                return p
+        # 4. which search (covers custom PATH entries)
+        which_path = shutil.which("blender")
+        if which_path:
+            return which_path
+        # Fallback – raise informative error later when used
+        return ""
+
+# Global config instance
+config = Config()
+# Convenience constant for direct access
+BLENDER_PATH = config.blender_path