utim-cli 1.47.1__tar.gz → 1.47.2__tar.gz

{utim_cli-1.47.1 → utim_cli-1.47.2}/CHANGELOG.md

@@ -1,14 +1,25 @@
 # Changelog
 
+## [1.47.2] - 2026-07-18
+
+### Fixed
+- **UnboundLocalError in Command Output Renderer**: Pre-initialized stdout and stderr lines lists in `_render_result` to prevent runtime exception on commands yielding empty output.
+- **Chunk-Boundary Unicode Decode Errors**: Upgraded `read_file` tool to slice trailing incomplete bytes during UTF-8 checks, preventing decoding failures on split multi-byte character boundaries.
+- **Reflection Engine Skill Creation Guardrail**: Restructured reflection engine to only create new skill files when at least 3 substantial guidelines (each >= 40 characters) are suggested, preventing clutter from useless "one-liner" skills.
+- **Console Status Spinner Fallback**: Patched the `console.status` spinner in `utim.py` to check for legacy Windows CMD/conhost and non-UTF-8 environments, dynamically falling back to ASCII `line` spinners instead of unicode dots.
+- **Support Chat Model Casing**: Updated frontend support assistant to target `openrouter/free` exclusively to maintain service reliability.
+
 ## [1.47.1] - 2026-07-18
 
 ### Added
+- **Referral Program**: Launched a full referral system. Referrers earn a 2% per-plan discount for each referred user who purchases a subscription. Discounts stack per-plan up to 100% (fully free). Every payment renewal by a referee adds another 2%. Referral dashboard available at `/referral` with live discount breakdown, progress bars, copy-ready referral link/code, and a leaderboard.
 - **Instant Server-Side Deletion**: Connected client share deletion to a new `DELETE /shares/delete/{share_id}` server endpoint to destroy shared zip packages and metadata instantly when removed from the CLI dashboard.
 - **Custom Exclude Checklist Option**: Embedded a dynamic `[ Add custom files/folders... ]` checkbox directly into the share wizard to prompt for custom omits only when selected, rather than asking unconditionally.
 - **Exclusion Path Root Validation**: Added validation to reject and display warnings for typed/pasted custom paths that fall outside the current workspace root directory.
 - **Ctrl+D Dashboard Shortcut**: Resolved key collision where pressing `D` got typed in the default-focused search bar by binding `Ctrl+D` globally to delete the active share.
 
 ### Fixed
+- **Content Security Policy Alignment**: Added `https://ipapi.co` and `https://analytics.google.com` to Netlify's `connect-src` CSP header rules, allowing the website frontend to complete geolocated IP checking and analytics telemetry during startup without throwing console errors or blocking the AI chat component.
 - **Unicode Markdown Rendering Fallbacks**: Patched Rich's markdown rule, table, and list item components to detect legacy Command Prompt terminals and fallback to safe ASCII representations (`*` for bullets, `-` for rules, and `+--+` for table grids) instead of throwing UnicodeEncodeErrors or printing replacement boxes.
 - **Unicode Fallback Spinners**: Re-engineered all loading/thinking spinners and progress bar characters to detect legacy Windows CMD/conhost terminals and non-UTF-8 console environments, falling back to clean ASCII patterns (`['|', '/', '-', '\\']` and `[#---]`) to prevent rendering boxes/question marks.
 - **Graceful Prompt-Toolkit Dialog Exits**: Introduced a safe-exit mechanism to catch and prevent unhandled `Application.exit()` loop exceptions.

{utim_cli-1.47.1/utim_cli.egg-info → utim_cli-1.47.2}/PKG-INFO

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

{utim_cli-1.47.1 → utim_cli-1.47.2}/pyproject.toml

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

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

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/_version.py

@@ -11,4 +11,4 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "1.47.1"
+VERSION = "1.47.2"

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/orchestrator.py

@@ -2330,6 +2330,8 @@ class Orchestrator:
             stdout_section = ""
             stderr_section = ""
             current_section = None
+            stdout_lines = []
+            stderr_lines = []
 
             for line in raw_output.splitlines():
                 if line.startswith("[exit_code:"):

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/reflection.py

@@ -969,15 +969,24 @@ def apply_skill_modifications(skill_modifications: Dict[str, List[str]]):
 
         for skill_path in paths_to_write:
             try:
-                # Ensure parent directory exists
-                skill_path.parent.mkdir(parents=True, exist_ok=True)
+                skill_exists = skill_path.exists()
+                
+                # Filter rules by length and substance based on whether the skill already exists
+                min_len = 25 if skill_exists else 40
+                valid_rules = [r.strip() for r in new_rules if r and len(r.strip()) >= min_len]
+                
+                # Enforce strict guardrail for new skills: must have at least 3 substantial rules
+                if not skill_exists and len(valid_rules) < 3:
+                    continue  # Ignore creation of this new skill entirely
                 
                 content = ""
-                if skill_path.exists():
+                if skill_exists:
                     with open(skill_path, 'r', encoding='utf-8') as f:
                         content = f.read()
                     
                 if not content:
+                    # Ensure parent directory exists before writing
+                    skill_path.parent.mkdir(parents=True, exist_ok=True)
                     # Initialize a new skill md template
                     title_name = skill_name.replace('-', ' ').title()
                     content = f"""---
@@ -992,10 +1001,7 @@ description: Automatically learned guidelines for {title_name}.
                 
                 # Append new rules avoiding duplicates
                 rules_to_add = []
-                for rule in new_rules:
-                    rule_clean = rule.strip()
-                    if not rule_clean:
-                        continue
+                for rule_clean in valid_rules:
                     # Check if already present in content (case-insensitive substring check)
                     if rule_clean.lower() not in content.lower():
                         rules_to_add.append(rule_clean)

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/server/db.py

@@ -54,7 +54,10 @@ class User(Base):
     created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)
     last_project_folder = Column(Text, nullable=True)
     firebase_uid = Column(String(128), nullable=True, index=True)
+    referrer_id = Column(String(36), ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    referral_code = Column(String(50), unique=True, nullable=False, default=lambda: uuid.uuid4().hex[:8])
 
+    referrer = relationship("User", remote_side=[id], backref="referees")
     credits = relationship("Credit", back_populates="user", uselist=False, cascade="all, delete-orphan")
     conversations = relationship("Conversation", back_populates="user", cascade="all, delete-orphan")
     transactions = relationship("Transaction", back_populates="user", cascade="all, delete-orphan")
@@ -472,6 +475,14 @@ def init_db(silent: bool = True) -> None:
     # Run manual migrations for missing columns
     # Each ALTER runs in its OWN transaction so one failure doesn't block the rest.
     from sqlalchemy import text, inspect as sa_inspect
+
+    # Ensure referral_discounts table exists (defined in referral_routes, not imported into Base yet)
+    try:
+        from .routes.referral_routes import ReferralDiscount
+        Base.metadata.create_all(bind=engine, tables=[ReferralDiscount.__table__])
+    except Exception as _ref_tbl_exc:
+        _print(f"[DB INIT] referral_discounts table init note: {_ref_tbl_exc}")
+
     is_postgres = DATABASE_URL.startswith("postgresql")
 
     try:
@@ -512,6 +523,8 @@ def init_db(silent: bool = True) -> None:
         _print("[DB INIT] Postgres detected. Running ALTER TABLE migrations if needed.")
         _run_migration("credits", "free_monthly_used", "ALTER TABLE credits ADD COLUMN IF NOT EXISTS free_monthly_used FLOAT DEFAULT 0.0 NOT NULL", "postgres add free_monthly_used")
         _run_migration("users", "firebase_uid", "ALTER TABLE users ADD COLUMN IF NOT EXISTS firebase_uid VARCHAR(128)", "postgres add firebase_uid")
+        _run_migration("users", "referrer_id", "ALTER TABLE users ADD COLUMN IF NOT EXISTS referrer_id VARCHAR(36)", "postgres add referrer_id")
+        _run_migration("users", "referral_code", "ALTER TABLE users ADD COLUMN IF NOT EXISTS referral_code VARCHAR(50)", "postgres add referral_code")
         _run_migration("feedbacks", "chat_history", "ALTER TABLE feedbacks ADD COLUMN IF NOT EXISTS chat_history TEXT", "postgres add chat_history")
     else:
         # SQLite: no IF NOT EXISTS on ADD COLUMN, swallow duplicate errors
@@ -526,6 +539,8 @@ def init_db(silent: bool = True) -> None:
         _run_migration("email_tracking", "bonus_email_sent_at", "ALTER TABLE email_tracking ADD COLUMN bonus_email_sent_at TIMESTAMP", "sqlite add bonus_email_sent_at")
         _run_migration("users", "last_project_folder", "ALTER TABLE users ADD COLUMN last_project_folder TEXT", "sqlite add last_project_folder")
         _run_migration("users", "firebase_uid", "ALTER TABLE users ADD COLUMN firebase_uid VARCHAR(128)", "sqlite add firebase_uid")
+        _run_migration("users", "referrer_id", "ALTER TABLE users ADD COLUMN referrer_id VARCHAR(36)", "sqlite add referrer_id")
+        _run_migration("users", "referral_code", "ALTER TABLE users ADD COLUMN referral_code VARCHAR(50)", "sqlite add referral_code")
         _run_migration("feedbacks", "chat_history", "ALTER TABLE feedbacks ADD COLUMN chat_history TEXT", "sqlite add feedbacks chat_history")
         
     # Seed the plans if they don't exist
@@ -654,6 +669,17 @@ def init_db(silent: bool = True) -> None:
                     ultimate_plan.credits_per_month = 90000
                 if ultimate_plan.price_inr != 11000:
                     ultimate_plan.price_inr = 11000
+            
+            # Generate referral codes for existing users that don't have one
+            try:
+                users_without_code = db.query(User).filter(User.referral_code == None).all()
+                if users_without_code:
+                    _print(f"[DB INIT] Generating referral codes for {len(users_without_code)} users...")
+                    for u in users_without_code:
+                        u.referral_code = uuid.uuid4().hex[:8]
+            except Exception as ref_exc:
+                _print(f"[DB INIT] Referral code migration check failed: {ref_exc}")
+                
             db.commit()
     except Exception as exc:
         db.rollback()

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/server/models.py

@@ -1116,6 +1116,33 @@ MODEL_REGISTRY: dict[MODEL_ID, ModelEntry] = {
         capabilities=["chat", "code"],
         tags=["premium"],
     ),
+    "thinkingmachines/inkling": ModelEntry(
+        model_id="thinkingmachines/inkling",
+        provider="openrouter",
+        cost_input_per_1k=0.00105,
+        cost_output_per_1k=0.0042525,
+        context_window=1_048_576,
+        capabilities=["chat", "code"],
+        tags=["premium"],
+    ),
+    "moonshotai/kimi-k3": ModelEntry(
+        model_id="moonshotai/kimi-k3",
+        provider="openrouter",
+        cost_input_per_1k=0.00315,
+        cost_output_per_1k=0.01575,
+        context_window=1_000_000,
+        capabilities=["chat", "reasoning"],
+        tags=["premium", "reasoning"],
+    ),
+    "meta/muse-spark-1.1": ModelEntry(
+        model_id="meta/muse-spark-1.1",
+        provider="openrouter",
+        cost_input_per_1k=0.0013125,
+        cost_output_per_1k=0.0044625,
+        context_window=1_048_576,
+        capabilities=["chat", "code", "multimodal"],
+        tags=["premium", "multimodal"],
+    ),
 }
 
 # Default model used when the user does not specify one

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/server/router.py

@@ -26,7 +26,7 @@ from .logging_config import configure_logging, RequestLoggingMiddleware
 from .rate_limit import limiter
 from slowapi import _rate_limit_exceeded_handler
 from slowapi.errors import RateLimitExceeded
-from .routes import auth_router, credit_router, session_router, completion_router, quota_router, share_router, feedback_router
+from .routes import auth_router, credit_router, session_router, completion_router, quota_router, share_router, feedback_router, referral_router
 from .models import list_models
 from .auth import get_admin_user
 
@@ -112,6 +112,7 @@ app.include_router(completion_router)
 app.include_router(quota_router)
 app.include_router(share_router)
 app.include_router(feedback_router)
+app.include_router(referral_router)
 
 # ── Support Chatbot Endpoint ──────────────────────────────────────────────────
 
@@ -189,8 +190,9 @@ async def support_chat(request: Request, req: SupportChatRequest):
     import json
     ALLOWED_FREE_MODELS = {
         "poolside/laguna-xs.2:free",
-        "google/gemma-2-9b-it:free",
         "cohere/north-mini-code:free",
+        "google/gemma-4-31b-it:free",
+        "google/gemma-4-26b-a4b-it:free",
         "openrouter/free"
     }
     
@@ -210,7 +212,7 @@ async def support_chat(request: Request, req: SupportChatRequest):
 
     # Generate candidate models starting with the requested one
     candidate_models = [model_name]
-    for fallback in ["openrouter/free", "google/gemma-2-9b-it:free", "cohere/north-mini-code:free", "poolside/laguna-xs.2:free"]:
+    for fallback in ["openrouter/free", "cohere/north-mini-code:free", "google/gemma-4-31b-it:free", "poolside/laguna-xs.2:free"]:
         if fallback not in candidate_models:
             candidate_models.append(fallback)
 

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/server/routes/__init__.py

@@ -5,6 +5,7 @@ from .completion_routes import router as completion_router
 from .quota_routes import router as quota_router
 from .share_routes import router as share_router
 from .feedback_routes import router as feedback_router
+from .referral_routes import router as referral_router
 
-__all__ = ["auth_router", "credit_router", "session_router", "completion_router", "quota_router", "share_router", "feedback_router"]
+__all__ = ["auth_router", "credit_router", "session_router", "completion_router", "quota_router", "share_router", "feedback_router", "referral_router"]
 

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/server/routes/quota_routes.py

@@ -1196,6 +1196,23 @@ def api_subscription_create(
 
     currency = (req.currency or "INR").upper().strip()
 
+    # Fetch user's active referral discounts
+    from .referral_routes import get_referrer_discounts
+    try:
+        discounts = get_referrer_discounts(db, user.id)
+    except Exception:
+        discounts = {}
+    
+    discount_pct = min(100.0, discounts.get(db_plan_id, 0.0))
+
+    # If the user has a 100% discount, bypass Razorpay payment entirely
+    if discount_pct >= 100.0:
+        return {
+            "success": True,
+            "subscriptionId": f"free_referral_100pct_{db_plan_id}_monthly",
+            "keyId": "free"
+        }
+
     if not key_id or key_id == "mock_key_id":
         return {
             "success": True,
@@ -1205,7 +1222,48 @@ def api_subscription_create(
 
     import requests
     
-    env_plan_id = get_razorpay_plan_id(db_plan_id, interval, currency)
+    # Try to load discounted plan from environment variables or JSON mapping
+    env_plan_id = None
+    if 0.0 < discount_pct < 100.0:
+        # Map to closest step of 2 (2%, 4%, ..., 98%)
+        pct_step = int(round(discount_pct / 2) * 2)
+        pct_step = max(2, min(98, pct_step))
+        
+        # Determine variable keys checking aliases
+        plan_env_name = db_plan_id.upper()
+        if plan_env_name == "PRO":
+            plan_env_name = "STARTER"
+        elif plan_env_name == "MAX":
+            plan_env_name = "PROFESSIONAL"
+            
+        env_key = f"RAZORPAY_PLAN_{plan_env_name}_{pct_step}"
+        env_plan_id = os.environ.get(env_key)
+        
+        # Fallback check for direct DB plan name
+        if not env_plan_id:
+            env_key_direct = f"RAZORPAY_PLAN_{db_plan_id.upper()}_{pct_step}"
+            env_plan_id = os.environ.get(env_key_direct)
+            
+        if env_plan_id:
+            logger.info(f"Dynamic discounted plan resolved from environment: {env_plan_id} ({env_key})")
+        else:
+            # Fallback to local JSON mapping file
+            import json
+            json_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "razorpay_discounted_plans.json")
+            if os.path.exists(json_path):
+                try:
+                    with open(json_path, "r", encoding="utf-8") as f:
+                        plans_map = json.load(f)
+                    plan_key = f"{db_plan_id}_{pct_step}"
+                    env_plan_id = plans_map.get(plan_key)
+                    if env_plan_id:
+                        logger.info(f"Dynamic discounted plan resolved from JSON: {env_plan_id} for user {user.id} ({plan_key})")
+                except Exception as json_err:
+                    logger.error(f"Failed to read discounted plans JSON mapping: {json_err}")
+
+    if not env_plan_id:
+        env_plan_id = get_razorpay_plan_id(db_plan_id, interval, currency)
+
     if not env_plan_id:
         raise HTTPException(
             status_code=400, 
@@ -1254,15 +1312,26 @@ def api_subscription_verify(
     key_id = os.environ.get("RAZORPAY_KEY_ID", "")
     key_secret = os.environ.get("RAZORPAY_KEY_SECRET", "")
 
-    if req.razorpay_subscription_id.startswith("sub_mock") or not key_id or key_id == "mock_key_id":
+    if req.razorpay_subscription_id.startswith("free_referral_100pct") or req.razorpay_subscription_id.startswith("sub_mock") or not key_id or key_id == "mock_key_id":
         plan_id = "hobby"
         interval = "monthly"
         parts = req.razorpay_subscription_id.split("_")
-        if len(parts) >= 3 and parts[2] in ("hobby", "pro", "max", "ultimate"):
+        # free_referral_100pct_{plan_id}_monthly
+        if len(parts) >= 4 and parts[3] in ("hobby", "pro", "max", "ultimate"):
+            plan_id = parts[3]
+        elif len(parts) >= 3 and parts[2] in ("hobby", "pro", "max", "ultimate"):
             plan_id = parts[2]
-        if len(parts) >= 4 and parts[3] in ("monthly", "yearly"):
+        if len(parts) >= 5 and parts[4] in ("monthly", "yearly"):
+            interval = parts[4]
+        elif len(parts) >= 4 and parts[3] in ("monthly", "yearly"):
             interval = parts[3]
         activate_subscription(db, user_id=user.id, plan_id=plan_id, razorpay_sub_id=req.razorpay_subscription_id, interval=interval)
+        # Award referral discount to referrer if applicable
+        try:
+            from .referral_routes import apply_referral_purchase
+            apply_referral_purchase(db, referee_id=user.id, plan_id=plan_id)
+        except Exception as _ref_err:
+            logger.warning(f"referral_purchase_hook_failed: {_ref_err}")
         return {"success": True}
 
     import hmac
@@ -1304,7 +1373,14 @@ def api_subscription_verify(
         razorpay_cust_id=f"cust_{user.id[:8]}",
         interval=interval
     )
-    
+
+    # Award referral discount to referrer if applicable
+    try:
+        from .referral_routes import apply_referral_purchase
+        apply_referral_purchase(db, referee_id=user.id, plan_id=plan_id)
+    except Exception as _ref_err:
+        logger.warning(f"referral_purchase_hook_failed: {_ref_err}")
+
     return {"success": True}
 
 

utim_cli-1.47.2/utim_cli/server/routes/referral_routes.py

@@ -0,0 +1,248 @@
+"""
+Referral System API routes.
+
+Logic:
+- Each user has a unique referral_code (8 hex chars stored on the User model).
+- When a new user signs up with ?ref=<code>, the server stores the referrer's ID on their account.
+- Every time a referred user's subscription payment is verified, the referrer earns a 2% discount
+  on that exact plan (e.g. if B buys hobby, referrer gets 2% off hobby).
+- Discounts stack per-plan up to 100%.  If the same referred user renews, the discount
+  increments again.
+- The discount is stored in a separate ReferralDiscount table so it's queryable per plan.
+"""
+
+import uuid
+import datetime
+import logging
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from sqlalchemy import Column, String, Integer, Float, DateTime, ForeignKey, UniqueConstraint
+from sqlalchemy.orm import Session, relationship
+
+from ..db import Base, get_db, SessionLocal
+from ..auth import get_current_firebase_user
+from ..db import User
+
+logger = logging.getLogger("utim.referrals")
+
+router = APIRouter()
+
+
+# ── ORM Model ─────────────────────────────────────────────────────────────────
+
+class ReferralDiscount(Base):
+    """Tracks per-plan discount percentage earned by a referrer."""
+    __tablename__ = "referral_discounts"
+    __table_args__ = (
+        UniqueConstraint("referrer_id", "plan_id", name="uq_referral_discount_referrer_plan"),
+    )
+
+    id         = Column(String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    referrer_id = Column(String(36), ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
+    plan_id    = Column(String(50), nullable=False)          # e.g. "hobby", "pro", "max"
+    discount_pct = Column(Float, default=0.0, nullable=False) # 0-100
+    referee_count = Column(Integer, default=0, nullable=False) # how many distinct referral purchases stacked this
+    updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
+
+    referrer   = relationship("User", foreign_keys=[referrer_id], backref="referral_discounts")
+
+
+# ── Pydantic Schemas ───────────────────────────────────────────────────────────
+
+class RegisterReferralRequest(BaseModel):
+    referral_code: str   # code of the referrer
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+MAX_DISCOUNT_PCT = 100.0
+DISCOUNT_PER_REFERRAL = 2.0
+
+
+def apply_referral_purchase(db: Session, referee_id: str, plan_id: str) -> bool:
+    """
+    Called after a successful payment by `referee_id`.
+    Finds their referrer and increments the plan-specific discount by 2%.
+    Returns True if a referrer was found and updated.
+    """
+    referee = db.query(User).filter(User.id == referee_id).first()
+    if not referee or not referee.referrer_id:
+        return False
+
+    referrer_id = referee.referrer_id
+
+    # Normalise plan alias
+    normalised = _normalise_plan(plan_id)
+
+    discount_row = (
+        db.query(ReferralDiscount)
+        .filter(
+            ReferralDiscount.referrer_id == referrer_id,
+            ReferralDiscount.plan_id == normalised,
+        )
+        .first()
+    )
+
+    if not discount_row:
+        discount_row = ReferralDiscount(
+            referrer_id=referrer_id,
+            plan_id=normalised,
+            discount_pct=0.0,
+            referee_count=0,
+        )
+        db.add(discount_row)
+
+    new_pct = min(MAX_DISCOUNT_PCT, discount_row.discount_pct + DISCOUNT_PER_REFERRAL)
+    discount_row.discount_pct = new_pct
+    discount_row.referee_count += 1
+    discount_row.updated_at = datetime.datetime.utcnow()
+
+    try:
+        db.commit()
+    except Exception as e:
+        db.rollback()
+        logger.error(f"referral_discount_commit_error: {e}")
+        return False
+
+    logger.info(
+        f"referral_discount_updated referrer={referrer_id} plan={normalised} "
+        f"new_pct={new_pct} referee_count={discount_row.referee_count}"
+    )
+    return True
+
+
+def _normalise_plan(plan_id: str) -> str:
+    """Map frontend plan aliases to canonical DB plan ids."""
+    mapping = {"starter": "pro", "professional": "max", "ultimate": "ultimate"}
+    pid = plan_id.lower().strip()
+    return mapping.get(pid, pid)
+
+
+def get_referrer_discounts(db: Session, referrer_id: str) -> dict:
+    """Return a dict of plan_id -> discount_pct for a given referrer."""
+    rows = db.query(ReferralDiscount).filter(ReferralDiscount.referrer_id == referrer_id).all()
+    return {r.plan_id: round(r.discount_pct, 2) for r in rows}
+
+
+# ── Routes ─────────────────────────────────────────────────────────────────────
+
+@router.post("/api/referrals/register")
+def register_referral(
+    req: RegisterReferralRequest,
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_firebase_user),
+):
+    """
+    Link the current user to a referrer by their referral_code.
+    Can only be called once per user (if they don't already have a referrer).
+    """
+    if user.referrer_id:
+        raise HTTPException(status_code=400, detail="You have already been linked to a referrer.")
+
+    referrer = db.query(User).filter(User.referral_code == req.referral_code.strip()).first()
+    if not referrer:
+        raise HTTPException(status_code=404, detail="Referral code not found.")
+
+    if referrer.id == user.id:
+        raise HTTPException(status_code=400, detail="You cannot use your own referral code.")
+
+    user.referrer_id = referrer.id
+    try:
+        db.commit()
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Failed to link referral: {e}")
+
+    logger.info(f"referral_linked referee={user.id} referrer={referrer.id}")
+    return {"success": True, "message": f"Successfully linked to referrer."}
+
+
+@router.get("/api/referrals/info")
+def get_referral_info(
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_firebase_user),
+):
+    """
+    Returns the current user's referral code, stats, and any discounts they have earned
+    as a referrer.
+    """
+    # Ensure user has a referral code (backfill for old accounts)
+    if not user.referral_code:
+        user.referral_code = uuid.uuid4().hex[:8]
+        try:
+            db.commit()
+        except Exception:
+            db.rollback()
+
+    # Count how many users they've referred
+    try:
+        referee_count = db.query(User).filter(User.referrer_id == user.id).count()
+    except Exception:
+        referee_count = 0
+
+    # Get their earned discounts
+    try:
+        discounts = get_referrer_discounts(db, user.id)
+    except Exception:
+        discounts = {}
+
+    # Did they sign up via a referral?
+    referred_by = None
+    if user.referrer_id:
+        try:
+            referrer = db.query(User).filter(User.id == user.referrer_id).first()
+            if referrer:
+                referred_by = {
+                    "display_name": referrer.display_name or referrer.email.split("@")[0],
+                    "email_hint": referrer.email[:3] + "***"
+                }
+        except Exception:
+            pass
+
+    return {
+        "referral_code": user.referral_code,
+        "referral_url": f"https://utim.dev/auth?ref={user.referral_code}",
+        "referee_count": referee_count,
+        "discounts": discounts,
+        "referred_by": referred_by,
+    }
+
+
+@router.get("/api/referrals/leaderboard")
+def referral_leaderboard(
+    db: Session = Depends(get_db),
+    user: User = Depends(get_current_firebase_user),
+):
+    """
+    Returns the top referrers by total referee count (anonymized).
+    Also returns current user's rank.
+    """
+    from sqlalchemy import text
+    try:
+        result = db.execute(
+            text("""
+                SELECT u.id, u.display_name, COUNT(r.id) as cnt
+                FROM users u
+                LEFT JOIN users r ON r.referrer_id = u.id
+                GROUP BY u.id, u.display_name
+                HAVING COUNT(r.id) > 0
+                ORDER BY cnt DESC
+                LIMIT 10
+            """)
+        ).fetchall()
+
+        board = [
+            {
+                "rank": i + 1,
+                "name": (row[1] or "Anonymous")[:15],
+                "referrals": row[2],
+                "is_me": row[0] == user.id,
+            }
+            for i, row in enumerate(result)
+        ]
+    except Exception as e:
+        logger.error(f"leaderboard_query_error: {e}")
+        board = []
+
+    return {"leaderboard": board}

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/tools.py

@@ -102,11 +102,28 @@ def read_file(filepath: str, start_line: int = None, end_line: int = None) -> st
             chunk = f.read(2048)
             if b"\x00" in chunk:
                 return f"Error: '{filepath}' appears to be a binary file and cannot be read as text."
+            
             # Test decode
+            decode_success = False
             try:
                 chunk.decode("utf-8")
+                decode_success = True
             except UnicodeDecodeError:
-                return f"Error: '{filepath}' uses an unsupported encoding and cannot be read as text."
+                # If it's a split multi-byte character at the end of the chunk, check smaller chunks
+                for i in range(1, min(5, len(chunk))):
+                    try:
+                        chunk[:-i].decode("utf-8")
+                        decode_success = True
+                        break
+                    except UnicodeDecodeError:
+                        continue
+            
+            if not decode_success:
+                # Bypass check for known text extensions
+                ext = _os.path.splitext(filepath)[1].lower()
+                text_extensions = {'.txt', '.md', '.py', '.js', '.ts', '.jsx', '.tsx', '.json', '.yaml', '.yml', '.ini', '.cfg', '.conf', '.sh', '.bat', '.ps1', '.html', '.css', '.csv', '.xml', '.toml'}
+                if ext not in text_extensions:
+                    return f"Error: '{filepath}' uses an unsupported encoding and cannot be read as text."
 
         with open(filepath, "r", encoding="utf-8", errors="replace") as f:
             all_lines = f.readlines()

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/tui/model_dialog.py

@@ -214,6 +214,9 @@ def _dialog_model_main(orchestrator, target="main"):
                 "google/gemini-3.5-flash",
                 "qwen/qwen3.7-max",
                 "stepfun/step-3.7-flash",
+                "thinkingmachines/inkling",
+                "moonshotai/kimi-k3",
+                "meta/muse-spark-1.1",
             
                 "anthropic/claude-sonnet-4.5",
                 "anthropic/claude-sonnet-4.6",
@@ -284,11 +287,13 @@ def _dialog_model_main(orchestrator, target="main"):
                 "qwen/qwen3.7-max",
                 "qwen/qwen3.6-plus",
                 "openai/gpt-5.4-mini",
-                "minimax/minimax-m2.5",
                 "x-ai/grok-4.20",
                 "x-ai/grok-build-0.1",
                 "moonshotai/kimi-k2.5",
-})
+                "thinkingmachines/inkling",
+                "moonshotai/kimi-k3",
+                "meta/muse-spark-1.1",
+            })
     elif target == "subagent_image_gen":
         # subagent_image_gen
         approved_set = {
@@ -407,6 +412,9 @@ def _dialog_model_main(orchestrator, target="main"):
         "google/gemini-3.5-flash": (3, "High"),
         "qwen/qwen3.7-max": (3, "High"),
         "stepfun/step-3.7-flash": (1, "Low"),
+        "thinkingmachines/inkling": (0, "Very low"),
+        "moonshotai/kimi-k3": (1, "Low"),
+        "meta/muse-spark-1.1": (0, "Very low"),
         
         # Free NVIDIA models:
         
@@ -500,6 +508,9 @@ def _dialog_model_main(orchestrator, target="main"):
         "google/gemini-3.5-flash": ("Fast, multimodal and agentic model by Google.", []),
         "qwen/qwen3.7-max": ("Flagship agentic and reasoning model by Qwen.", []),
         "stepfun/step-3.7-flash": ("Cost-effective multimodal assistant by StepFun.", []),
+        "thinkingmachines/inkling": ("Large-context, code-optimized reasoning model by Thinking Machines Lab.", ["premium"]),
+        "moonshotai/kimi-k3": ("Frontier-class reasoning MoE model by Moonshot AI.", ["premium", "reasoning"]),
+        "meta/muse-spark-1.1": ("Multimodal reasoning and agentic model by Meta Superintelligence Labs.", ["premium", "multimodal"]),
         
         # Free NVIDIA models:
         

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli/utim.py

@@ -939,7 +939,7 @@ def _print_animated_banner(animated: bool = True):
     else:
         console.print(f"[bold {color}]{BANNER_BIG}[/bold {color}]")
             
-    console.print(f" [bold white]U Think I Make[/bold white] [dim]v1.47.1[/dim]")
+    console.print(f" [bold white]U Think I Make[/bold white] [dim]v1.47.2[/dim]")
     user_email = config.email
     user_type = "UTIM Community"
     api_key = config.get("api_key")
@@ -3521,7 +3521,7 @@ def check_and_update_background():
                 return
 
             latest_ver = resp.json().get("version", "")
-            current_ver = "1.47.1"
+            current_ver = "1.47.2"
 
             def parse_ver(v):
                 return [int(x) for x in v.split(".") if x.isdigit()]
@@ -4154,7 +4154,8 @@ def upgrade():
         console.print("  [yellow]Upgrade cancelled.[/yellow]\n")
         return
 
-    with console.status("[bold green]Creating subscription link...", spinner="dots"):
+    spinner_type = "line" if (_IS_LEGACY_WIN or getattr(sys.stdout, 'encoding', '').lower() not in ('utf-8', 'utf8', 'cp65001')) else "dots"
+    with console.status("[bold green]Creating subscription link...", spinner=spinner_type):
         try:
             resp = requests.post(
                 f"{SERVER_URL}/subscribe",

{utim_cli-1.47.1 → utim_cli-1.47.2/utim_cli.egg-info}/PKG-INFO

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

{utim_cli-1.47.1 → utim_cli-1.47.2}/utim_cli.egg-info/SOURCES.txt

@@ -60,6 +60,7 @@ utim_cli/server/routes/completion_routes.py
 utim_cli/server/routes/credit_routes.py
 utim_cli/server/routes/feedback_routes.py
 utim_cli/server/routes/quota_routes.py
+utim_cli/server/routes/referral_routes.py
 utim_cli/server/routes/session_routes.py
 utim_cli/server/routes/share_routes.py
 utim_cli/tui/__init__.py